statsd/tests/e2e/WakelockDuration_e2e_test.cpp - platform/packages/modules/StatsD - Git at Google

 // Copyright (C) 2017 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include <gtest/gtest.h>

 #include "src/StatsLogProcessor.h"
 #include "src/stats_log_util.h"
 #include "tests/statsd_test_util.h"

 #include <vector>

 namespace android {
 namespace os {
 namespace statsd {

 #ifdef __ANDROID__

 namespace {

 StatsdConfig CreateStatsdConfig(DurationMetric::AggregationType aggregationType) {
     StatsdConfig config;
     config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
     *config.add_atom_matcher() = CreateScreenTurnedOnAtomMatcher();
     *config.add_atom_matcher() = CreateScreenTurnedOffAtomMatcher();
     *config.add_atom_matcher() = CreateAcquireWakelockAtomMatcher();
     *config.add_atom_matcher() = CreateReleaseWakelockAtomMatcher();

     auto screenIsOffPredicate = CreateScreenIsOffPredicate();
     *config.add_predicate() = screenIsOffPredicate;

     auto holdingWakelockPredicate = CreateHoldingWakelockPredicate();
     // The predicate is dimensioning by any attribution node and both by uid and tag.
     FieldMatcher dimensions = CreateAttributionUidAndTagDimensions(
             util::WAKELOCK_STATE_CHANGED, {Position::FIRST, Position::LAST});
     // Also slice by the wakelock tag
     dimensions.add_child()->set_field(3);  // The wakelock tag is set in field 3 of the wakelock.
     *holdingWakelockPredicate.mutable_simple_predicate()->mutable_dimensions() = dimensions;
     *config.add_predicate() = holdingWakelockPredicate;

     auto durationMetric = config.add_duration_metric();
     durationMetric->set_id(StringToId("WakelockDuration"));
     durationMetric->set_what(holdingWakelockPredicate.id());
     durationMetric->set_condition(screenIsOffPredicate.id());
     durationMetric->set_aggregation_type(aggregationType);
     // The metric is dimensioning by first attribution node and only by uid.
     *durationMetric->mutable_dimensions_in_what() =
         CreateAttributionUidDimensions(
             util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
     durationMetric->set_bucket(FIVE_MINUTES);
     return config;
 }

 std::vector<int> attributionUids1 = {111, 222, 222};
 std::vector<string> attributionTags1 = {"App1", "GMSCoreModule1", "GMSCoreModule2"};

 std::vector<int> attributionUids2 = {111, 222, 222};
 std::vector<string> attributionTags2 = {"App2", "GMSCoreModule1", "GMSCoreModule2"};

 /*
 Events:
 Screen off is met from (200ns,1 min+500ns].
 Acquire event for wl1 from 2ns to 1min+2ns
 Acquire event for wl2 from 1min-10ns to 2min-15ns
 */
 void FeedEvents(StatsdConfig config, sp<StatsLogProcessor> processor) {
     uint64_t bucketStartTimeNs = 10000000000;
     uint64_t bucketSizeNs =
             TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;

     auto screenTurnedOnEvent = CreateScreenStateChangedEvent(
             bucketStartTimeNs + 1, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
     auto screenTurnedOffEvent = CreateScreenStateChangedEvent(
             bucketStartTimeNs + 200, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
     auto screenTurnedOnEvent2 =
             CreateScreenStateChangedEvent(bucketStartTimeNs + bucketSizeNs + 500,
                                           android::view::DisplayStateEnum::DISPLAY_STATE_ON);

     auto acquireEvent1 = CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
                                                     attributionTags1, "wl1");
     auto releaseEvent1 = CreateReleaseWakelockEvent(bucketStartTimeNs + bucketSizeNs + 2,
                                                     attributionUids1, attributionTags1, "wl1");
     auto acquireEvent2 = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 10,
                                                     attributionUids2, attributionTags2, "wl2");
     auto releaseEvent2 = CreateReleaseWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs - 15,
                                                     attributionUids2, attributionTags2, "wl2");

     std::vector<std::unique_ptr<LogEvent>> events;

     events.push_back(std::move(screenTurnedOnEvent));
     events.push_back(std::move(screenTurnedOffEvent));
     events.push_back(std::move(screenTurnedOnEvent2));
     events.push_back(std::move(acquireEvent1));
     events.push_back(std::move(acquireEvent2));
     events.push_back(std::move(releaseEvent1));
     events.push_back(std::move(releaseEvent2));

     sortLogEventsByTimestamp(&events);

     for (const auto& event : events) {
         processor->OnLogEvent(event.get());
     }
 }

 }  // namespace

 TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration1) {
     ConfigKey cfgKey;
     auto config = CreateStatsdConfig(DurationMetric::SUM);
     uint64_t bucketStartTimeNs = 10000000000;
     uint64_t bucketSizeNs =
             TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
     auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
     ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
     FeedEvents(config, processor);
     vector<uint8_t> buffer;
     ConfigMetricsReportList reports;
     processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, ADB_DUMP,
                             FAST, &buffer);
     EXPECT_TRUE(buffer.size() > 0);
     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
     backfillDimensionPath(&reports);
     backfillStringInReport(&reports);
     backfillStartEndTimestamp(&reports);

     ASSERT_EQ(reports.reports_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics_size(), 1);
     // Only 1 dimension output. The tag dimension in the predicate has been aggregated.
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);

     auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
     // Validate dimension value.
     ValidateAttributionUidDimension(data.dimensions_in_what(),
                                     util::WAKELOCK_STATE_CHANGED, 111);
     // Validate bucket info.
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1);
     data = reports.reports(0).metrics(0).duration_metrics().data(0);
     // The wakelock holding interval starts from the screen off event and to the end of the 1st
     // bucket.
     EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs - 200);
 }

 TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration2) {
     ConfigKey cfgKey;
     auto config = CreateStatsdConfig(DurationMetric::SUM);
     uint64_t bucketStartTimeNs = 10000000000;
     uint64_t bucketSizeNs =
             TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
     auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
     ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
     FeedEvents(config, processor);
     vector<uint8_t> buffer;
     ConfigMetricsReportList reports;
     processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, ADB_DUMP,
                             FAST, &buffer);
     EXPECT_TRUE(buffer.size() > 0);
     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
     backfillDimensionPath(&reports);
     backfillStringInReport(&reports);
     backfillStartEndTimestamp(&reports);
     ASSERT_EQ(reports.reports_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
     // Dump the report after the end of 2nd bucket.
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2);
     auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
     // Validate dimension value.
     ValidateAttributionUidDimension(data.dimensions_in_what(),
                                     util::WAKELOCK_STATE_CHANGED, 111);
     // Two output buckets.
     // The wakelock holding interval in the 1st bucket starts from the screen off event and to
     // the end of the 1st bucket.
     EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(),
               bucketStartTimeNs + bucketSizeNs - (bucketStartTimeNs + 200));
     // The wakelock holding interval in the 2nd bucket starts at the beginning of the bucket and
     // ends at the second screen on event.
     EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 500UL);
 }

 TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration3) {
     ConfigKey cfgKey;
     auto config = CreateStatsdConfig(DurationMetric::SUM);
     uint64_t bucketStartTimeNs = 10000000000;
     uint64_t bucketSizeNs =
             TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
     auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
     ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
     FeedEvents(config, processor);
     vector<uint8_t> buffer;
     ConfigMetricsReportList reports;

     std::vector<std::unique_ptr<LogEvent>> events;
     events.push_back(
             CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 90,
                                           android::view::DisplayStateEnum::DISPLAY_STATE_OFF));
     events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
                                                 attributionUids1, attributionTags1, "wl3"));
     events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs + 100,
                                                 attributionUids1, attributionTags1, "wl3"));
     sortLogEventsByTimestamp(&events);
     for (const auto& event : events) {
         processor->OnLogEvent(event.get());
     }

     processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, ADB_DUMP,
                             FAST, &buffer);
     EXPECT_TRUE(buffer.size() > 0);
     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
     backfillDimensionPath(&reports);
     backfillStringInReport(&reports);
     backfillStartEndTimestamp(&reports);
     ASSERT_EQ(reports.reports_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 6);
     auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
     ValidateAttributionUidDimension(data.dimensions_in_what(),
                                     util::WAKELOCK_STATE_CHANGED, 111);
     // The last wakelock holding spans 4 buckets.
     EXPECT_EQ((unsigned long long)data.bucket_info(2).duration_nanos(), bucketSizeNs - 100);
     EXPECT_EQ((unsigned long long)data.bucket_info(3).duration_nanos(), bucketSizeNs);
     EXPECT_EQ((unsigned long long)data.bucket_info(4).duration_nanos(), bucketSizeNs);
     EXPECT_EQ((unsigned long long)data.bucket_info(5).duration_nanos(), 100UL);
 }

 TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration1) {
     ConfigKey cfgKey;
     auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
     uint64_t bucketStartTimeNs = 10000000000;
     uint64_t bucketSizeNs =
             TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
     auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
     ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
     FeedEvents(config, processor);
     ConfigMetricsReportList reports;
     vector<uint8_t> buffer;
     processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, ADB_DUMP,
                             FAST, &buffer);
     EXPECT_TRUE(buffer.size() > 0);

     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
     backfillDimensionPath(&reports);
     backfillStringInReport(&reports);
     backfillStartEndTimestamp(&reports);

     ASSERT_EQ(reports.reports_size(), 1);

     // When using ProtoOutputStream, if nothing written to a sub msg, it won't be treated as
     // one. It was previsouly 1 because we had a fake onDumpReport which calls add_metric() by
     // itself.
     ASSERT_EQ(1, reports.reports(0).metrics_size());
     ASSERT_EQ(0, reports.reports(0).metrics(0).duration_metrics().data_size());
 }

 TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration2) {
     ConfigKey cfgKey;
     auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
     uint64_t bucketStartTimeNs = 10000000000;
     uint64_t bucketSizeNs =
             TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
     auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
     ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
     FeedEvents(config, processor);
     ConfigMetricsReportList reports;
     vector<uint8_t> buffer;
     processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, ADB_DUMP,
                             FAST, &buffer);
     EXPECT_TRUE(buffer.size() > 0);
     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
     backfillDimensionPath(&reports);
     backfillStringInReport(&reports);
     backfillStartEndTimestamp(&reports);
     ASSERT_EQ(reports.reports_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
     // Dump the report after the end of 2nd bucket. One dimension with one bucket.
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1);
     auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
     // Validate dimension value.
     ValidateAttributionUidDimension(data.dimensions_in_what(),
                                     util::WAKELOCK_STATE_CHANGED, 111);
     // The max is acquire event for wl1 to screen off start.
     EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs + 2 - 200);
 }

 TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration3) {
     ConfigKey cfgKey;
     auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
     uint64_t bucketStartTimeNs = 10000000000;
     uint64_t bucketSizeNs =
             TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
     auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
     ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
     FeedEvents(config, processor);
     ConfigMetricsReportList reports;
     vector<uint8_t> buffer;

     std::vector<std::unique_ptr<LogEvent>> events;
     events.push_back(
             CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 90,
                                           android::view::DisplayStateEnum::DISPLAY_STATE_OFF));
     events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
                                                 attributionUids1, attributionTags1, "wl3"));
     events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs + 100,
                                                 attributionUids1, attributionTags1, "wl3"));
     sortLogEventsByTimestamp(&events);
     for (const auto& event : events) {
         processor->OnLogEvent(event.get());
     }

     processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, ADB_DUMP,
                             FAST, &buffer);
     EXPECT_TRUE(buffer.size() > 0);
     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
     backfillDimensionPath(&reports);
     backfillStringInReport(&reports);
     backfillStartEndTimestamp(&reports);
     ASSERT_EQ(reports.reports_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
     ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2);
     auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
     ValidateAttributionUidDimension(data.dimensions_in_what(),
                                     util::WAKELOCK_STATE_CHANGED, 111);
     // The last wakelock holding spans 4 buckets.
     EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 3 * bucketSizeNs);
     EXPECT_EQ((unsigned long long)data.bucket_info(1).start_bucket_elapsed_nanos(),
               bucketStartTimeNs + 5 * bucketSizeNs);
     EXPECT_EQ((unsigned long long)data.bucket_info(1).end_bucket_elapsed_nanos(),
               bucketStartTimeNs + 6 * bucketSizeNs);
 }

 #else
 GTEST_LOG_(INFO) << "This test does nothing.\n";
 #endif

 }  // namespace statsd
 }  // namespace os
 }  // namespace android
	// Copyright (C) 2017 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include <gtest/gtest.h>

	#include "src/StatsLogProcessor.h"
	#include "src/stats_log_util.h"
	#include "tests/statsd_test_util.h"

	#include <vector>

	namespace android {
	namespace os {
	namespace statsd {

	#ifdef __ANDROID__

	namespace {

	StatsdConfig CreateStatsdConfig(DurationMetric::AggregationType aggregationType) {
	StatsdConfig config;
	config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
	*config.add_atom_matcher() = CreateScreenTurnedOnAtomMatcher();
	*config.add_atom_matcher() = CreateScreenTurnedOffAtomMatcher();
	*config.add_atom_matcher() = CreateAcquireWakelockAtomMatcher();
	*config.add_atom_matcher() = CreateReleaseWakelockAtomMatcher();

	auto screenIsOffPredicate = CreateScreenIsOffPredicate();
	*config.add_predicate() = screenIsOffPredicate;

	auto holdingWakelockPredicate = CreateHoldingWakelockPredicate();
	// The predicate is dimensioning by any attribution node and both by uid and tag.
	FieldMatcher dimensions = CreateAttributionUidAndTagDimensions(
	util::WAKELOCK_STATE_CHANGED, {Position::FIRST, Position::LAST});
	// Also slice by the wakelock tag
	dimensions.add_child()->set_field(3); // The wakelock tag is set in field 3 of the wakelock.
	*holdingWakelockPredicate.mutable_simple_predicate()->mutable_dimensions() = dimensions;
	*config.add_predicate() = holdingWakelockPredicate;

	auto durationMetric = config.add_duration_metric();
	durationMetric->set_id(StringToId("WakelockDuration"));
	durationMetric->set_what(holdingWakelockPredicate.id());
	durationMetric->set_condition(screenIsOffPredicate.id());
	durationMetric->set_aggregation_type(aggregationType);
	// The metric is dimensioning by first attribution node and only by uid.
	*durationMetric->mutable_dimensions_in_what() =
	CreateAttributionUidDimensions(
	util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
	durationMetric->set_bucket(FIVE_MINUTES);
	return config;
	}

	std::vector<int> attributionUids1 = {111, 222, 222};
	std::vector<string> attributionTags1 = {"App1", "GMSCoreModule1", "GMSCoreModule2"};

	std::vector<int> attributionUids2 = {111, 222, 222};
	std::vector<string> attributionTags2 = {"App2", "GMSCoreModule1", "GMSCoreModule2"};

	/*
	Events:
	Screen off is met from (200ns,1 min+500ns].
	Acquire event for wl1 from 2ns to 1min+2ns
	Acquire event for wl2 from 1min-10ns to 2min-15ns
	*/
	void FeedEvents(StatsdConfig config, sp<StatsLogProcessor> processor) {
	uint64_t bucketStartTimeNs = 10000000000;
	uint64_t bucketSizeNs =
	TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;

	auto screenTurnedOnEvent = CreateScreenStateChangedEvent(
	bucketStartTimeNs + 1, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
	auto screenTurnedOffEvent = CreateScreenStateChangedEvent(
	bucketStartTimeNs + 200, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
	auto screenTurnedOnEvent2 =
	CreateScreenStateChangedEvent(bucketStartTimeNs + bucketSizeNs + 500,
	android::view::DisplayStateEnum::DISPLAY_STATE_ON);

	auto acquireEvent1 = CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
	attributionTags1, "wl1");
	auto releaseEvent1 = CreateReleaseWakelockEvent(bucketStartTimeNs + bucketSizeNs + 2,
	attributionUids1, attributionTags1, "wl1");
	auto acquireEvent2 = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 10,
	attributionUids2, attributionTags2, "wl2");
	auto releaseEvent2 = CreateReleaseWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs - 15,
	attributionUids2, attributionTags2, "wl2");

	std::vector<std::unique_ptr<LogEvent>> events;

	events.push_back(std::move(screenTurnedOnEvent));
	events.push_back(std::move(screenTurnedOffEvent));
	events.push_back(std::move(screenTurnedOnEvent2));
	events.push_back(std::move(acquireEvent1));
	events.push_back(std::move(acquireEvent2));
	events.push_back(std::move(releaseEvent1));
	events.push_back(std::move(releaseEvent2));

	sortLogEventsByTimestamp(&events);

	for (const auto& event : events) {
	processor->OnLogEvent(event.get());
	}
	}

	} // namespace

	TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration1) {
	ConfigKey cfgKey;
	auto config = CreateStatsdConfig(DurationMetric::SUM);
	uint64_t bucketStartTimeNs = 10000000000;
	uint64_t bucketSizeNs =
	TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
	auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
	ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
	EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
	FeedEvents(config, processor);
	vector<uint8_t> buffer;
	ConfigMetricsReportList reports;
	processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, ADB_DUMP,
	FAST, &buffer);
	EXPECT_TRUE(buffer.size() > 0);
	EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
	backfillDimensionPath(&reports);
	backfillStringInReport(&reports);
	backfillStartEndTimestamp(&reports);

	ASSERT_EQ(reports.reports_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics_size(), 1);
	// Only 1 dimension output. The tag dimension in the predicate has been aggregated.
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);

	auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
	// Validate dimension value.
	ValidateAttributionUidDimension(data.dimensions_in_what(),
	util::WAKELOCK_STATE_CHANGED, 111);
	// Validate bucket info.
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1);
	data = reports.reports(0).metrics(0).duration_metrics().data(0);
	// The wakelock holding interval starts from the screen off event and to the end of the 1st
	// bucket.
	EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs - 200);
	}

	TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration2) {
	ConfigKey cfgKey;
	auto config = CreateStatsdConfig(DurationMetric::SUM);
	uint64_t bucketStartTimeNs = 10000000000;
	uint64_t bucketSizeNs =
	TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
	auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
	ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
	EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
	FeedEvents(config, processor);
	vector<uint8_t> buffer;
	ConfigMetricsReportList reports;
	processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, ADB_DUMP,
	FAST, &buffer);
	EXPECT_TRUE(buffer.size() > 0);
	EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
	backfillDimensionPath(&reports);
	backfillStringInReport(&reports);
	backfillStartEndTimestamp(&reports);
	ASSERT_EQ(reports.reports_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
	// Dump the report after the end of 2nd bucket.
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2);
	auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
	// Validate dimension value.
	ValidateAttributionUidDimension(data.dimensions_in_what(),
	util::WAKELOCK_STATE_CHANGED, 111);
	// Two output buckets.
	// The wakelock holding interval in the 1st bucket starts from the screen off event and to
	// the end of the 1st bucket.
	EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(),
	bucketStartTimeNs + bucketSizeNs - (bucketStartTimeNs + 200));
	// The wakelock holding interval in the 2nd bucket starts at the beginning of the bucket and
	// ends at the second screen on event.
	EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 500UL);
	}

	TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration3) {
	ConfigKey cfgKey;
	auto config = CreateStatsdConfig(DurationMetric::SUM);
	uint64_t bucketStartTimeNs = 10000000000;
	uint64_t bucketSizeNs =
	TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
	auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
	ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
	EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
	FeedEvents(config, processor);
	vector<uint8_t> buffer;
	ConfigMetricsReportList reports;

	std::vector<std::unique_ptr<LogEvent>> events;
	events.push_back(
	CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 90,
	android::view::DisplayStateEnum::DISPLAY_STATE_OFF));
	events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
	attributionUids1, attributionTags1, "wl3"));
	events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs + 100,
	attributionUids1, attributionTags1, "wl3"));
	sortLogEventsByTimestamp(&events);
	for (const auto& event : events) {
	processor->OnLogEvent(event.get());
	}

	processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, ADB_DUMP,
	FAST, &buffer);
	EXPECT_TRUE(buffer.size() > 0);
	EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
	backfillDimensionPath(&reports);
	backfillStringInReport(&reports);
	backfillStartEndTimestamp(&reports);
	ASSERT_EQ(reports.reports_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 6);
	auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
	ValidateAttributionUidDimension(data.dimensions_in_what(),
	util::WAKELOCK_STATE_CHANGED, 111);
	// The last wakelock holding spans 4 buckets.
	EXPECT_EQ((unsigned long long)data.bucket_info(2).duration_nanos(), bucketSizeNs - 100);
	EXPECT_EQ((unsigned long long)data.bucket_info(3).duration_nanos(), bucketSizeNs);
	EXPECT_EQ((unsigned long long)data.bucket_info(4).duration_nanos(), bucketSizeNs);
	EXPECT_EQ((unsigned long long)data.bucket_info(5).duration_nanos(), 100UL);
	}

	TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration1) {
	ConfigKey cfgKey;
	auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
	uint64_t bucketStartTimeNs = 10000000000;
	uint64_t bucketSizeNs =
	TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
	auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
	ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
	EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
	FeedEvents(config, processor);
	ConfigMetricsReportList reports;
	vector<uint8_t> buffer;
	processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, ADB_DUMP,
	FAST, &buffer);
	EXPECT_TRUE(buffer.size() > 0);

	EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
	backfillDimensionPath(&reports);
	backfillStringInReport(&reports);
	backfillStartEndTimestamp(&reports);

	ASSERT_EQ(reports.reports_size(), 1);

	// When using ProtoOutputStream, if nothing written to a sub msg, it won't be treated as
	// one. It was previsouly 1 because we had a fake onDumpReport which calls add_metric() by
	// itself.
	ASSERT_EQ(1, reports.reports(0).metrics_size());
	ASSERT_EQ(0, reports.reports(0).metrics(0).duration_metrics().data_size());
	}

	TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration2) {
	ConfigKey cfgKey;
	auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
	uint64_t bucketStartTimeNs = 10000000000;
	uint64_t bucketSizeNs =
	TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
	auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
	ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
	EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
	FeedEvents(config, processor);
	ConfigMetricsReportList reports;
	vector<uint8_t> buffer;
	processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, ADB_DUMP,
	FAST, &buffer);
	EXPECT_TRUE(buffer.size() > 0);
	EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
	backfillDimensionPath(&reports);
	backfillStringInReport(&reports);
	backfillStartEndTimestamp(&reports);
	ASSERT_EQ(reports.reports_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
	// Dump the report after the end of 2nd bucket. One dimension with one bucket.
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1);
	auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
	// Validate dimension value.
	ValidateAttributionUidDimension(data.dimensions_in_what(),
	util::WAKELOCK_STATE_CHANGED, 111);
	// The max is acquire event for wl1 to screen off start.
	EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs + 2 - 200);
	}

	TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration3) {
	ConfigKey cfgKey;
	auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
	uint64_t bucketStartTimeNs = 10000000000;
	uint64_t bucketSizeNs =
	TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
	auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
	ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
	EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
	FeedEvents(config, processor);
	ConfigMetricsReportList reports;
	vector<uint8_t> buffer;

	std::vector<std::unique_ptr<LogEvent>> events;
	events.push_back(
	CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 90,
	android::view::DisplayStateEnum::DISPLAY_STATE_OFF));
	events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
	attributionUids1, attributionTags1, "wl3"));
	events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs + 100,
	attributionUids1, attributionTags1, "wl3"));
	sortLogEventsByTimestamp(&events);
	for (const auto& event : events) {
	processor->OnLogEvent(event.get());
	}

	processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, ADB_DUMP,
	FAST, &buffer);
	EXPECT_TRUE(buffer.size() > 0);
	EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
	backfillDimensionPath(&reports);
	backfillStringInReport(&reports);
	backfillStartEndTimestamp(&reports);
	ASSERT_EQ(reports.reports_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
	ASSERT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2);
	auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
	ValidateAttributionUidDimension(data.dimensions_in_what(),
	util::WAKELOCK_STATE_CHANGED, 111);
	// The last wakelock holding spans 4 buckets.
	EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 3 * bucketSizeNs);
	EXPECT_EQ((unsigned long long)data.bucket_info(1).start_bucket_elapsed_nanos(),
	bucketStartTimeNs + 5 * bucketSizeNs);
	EXPECT_EQ((unsigned long long)data.bucket_info(1).end_bucket_elapsed_nanos(),
	bucketStartTimeNs + 6 * bucketSizeNs);
	}

	#else
	GTEST_LOG_(INFO) << "This test does nothing.\n";
	#endif

	} // namespace statsd
	} // namespace os
	} // namespace android