Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b6628d9f authored by Tej Singh's avatar Tej Singh Committed by Android (Google) Code Review
Browse files

Merge "Unit tests for active config change broadcast"

parents b8e16180 d823aebd

cmds/statsd/tests/StatsLogProcessor_test.cpp

+75 −20
Original line number Diff line number Diff line
@@ -297,7 +297,8 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 


    // Setup a simple config, no activation

    StatsdConfig config1;

    config1.set_id(12341);

    int64_t cfgId1 = 12341;

    config1.set_id(cfgId1);

    config1.add_allowed_log_source("AID_ROOT");  // LogEvent defaults to UID of root.

    auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher();

    *config1.add_atom_matcher() = wakelockAcquireMatcher;
@@ -314,14 +315,12 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    countMetric2->set_what(wakelockAcquireMatcher.id());

    countMetric2->set_bucket(FIVE_MINUTES);



    ConfigKey cfgKey1(uid, 12341);

    long timeBase1 = 1;

    sp<StatsLogProcessor> processor =

            CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1);

    ConfigKey cfgKey1(uid, cfgId1);



    // Add another config, with two metrics, one with activation

    StatsdConfig config2;

    config2.set_id(12342);

    int64_t cfgId2 = 12342;

    config2.set_id(cfgId2);

    config2.add_allowed_log_source("AID_ROOT");  // LogEvent defaults to UID of root.

    *config2.add_atom_matcher() = wakelockAcquireMatcher;
@@ -344,11 +343,12 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    metric3ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id());

    metric3ActivationTrigger->set_ttl_seconds(100);



    ConfigKey cfgKey2(uid, 12342);

    ConfigKey cfgKey2(uid, cfgId2);



    // Add another config, with two metrics, both with activations

    StatsdConfig config3;

    config3.set_id(12342);

    int64_t cfgId3 = 12343;

    config3.set_id(cfgId3);

    config3.add_allowed_log_source("AID_ROOT");  // LogEvent defaults to UID of root.

    *config3.add_atom_matcher() = wakelockAcquireMatcher;
@@ -376,14 +376,37 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    metric6ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id());

    metric6ActivationTrigger->set_ttl_seconds(200);



    ConfigKey cfgKey3(uid, 12343);

    ConfigKey cfgKey3(uid, cfgId3);



    processor->OnConfigUpdated(2, cfgKey2, config2);

    processor->OnConfigUpdated(3, cfgKey3, config3);

    sp<UidMap> m = new UidMap();

    sp<StatsPullerManager> pullerManager = new StatsPullerManager();

    sp<AlarmMonitor> anomalyAlarmMonitor;

    sp<AlarmMonitor> subscriberAlarmMonitor;

    vector<int64_t> activeConfigsBroadcast;



    EXPECT_EQ(3, processor->mMetricsManagers.size());

    auto it = processor->mMetricsManagers.find(cfgKey1);

    EXPECT_TRUE(it != processor->mMetricsManagers.end());

    long timeBase1 = 1;

    int broadcastCount = 0;

    StatsLogProcessor processor(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor,

            timeBase1, [](const ConfigKey& key) { return true; },

            [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,

                    const vector<int64_t>& activeConfigs) {

                broadcastCount++;

                EXPECT_EQ(broadcastUid, uid);

                activeConfigsBroadcast.clear();

                activeConfigsBroadcast.insert(activeConfigsBroadcast.end(),

                        activeConfigs.begin(), activeConfigs.end());

                return true;

            });



    processor.OnConfigUpdated(1, cfgKey1, config1);

    processor.OnConfigUpdated(2, cfgKey2, config2);

    processor.OnConfigUpdated(3, cfgKey3, config3);



    EXPECT_EQ(3, processor.mMetricsManagers.size());



    // Expect the first config and both metrics in it to be active.

    auto it = processor.mMetricsManagers.find(cfgKey1);

    EXPECT_TRUE(it != processor.mMetricsManagers.end());

    auto& metricsManager1 = it->second;

    EXPECT_TRUE(metricsManager1->isActive());
@@ -407,8 +430,9 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    auto& metricProducer2 = *metricIt;

    EXPECT_TRUE(metricProducer2->isActive());



    it = processor->mMetricsManagers.find(cfgKey2);

    EXPECT_TRUE(it != processor->mMetricsManagers.end());

    // Expect config 2 to be active. Metric 3 shouldn't be active, metric 4 should be active.

    it = processor.mMetricsManagers.find(cfgKey2);

    EXPECT_TRUE(it != processor.mMetricsManagers.end());

    auto& metricsManager2 = it->second;

    EXPECT_TRUE(metricsManager2->isActive());
@@ -432,8 +456,9 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    auto& metricProducer4 = *metricIt;

    EXPECT_TRUE(metricProducer4->isActive());



    it = processor->mMetricsManagers.find(cfgKey3);

    EXPECT_TRUE(it != processor->mMetricsManagers.end());

    // Expect the third config and both metrics in it to be inactive.

    it = processor.mMetricsManagers.find(cfgKey3);

    EXPECT_TRUE(it != processor.mMetricsManagers.end());

    auto& metricsManager3 = it->second;

    EXPECT_FALSE(metricsManager3->isActive());
@@ -457,10 +482,30 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    auto& metricProducer6 = *metricIt;

    EXPECT_FALSE(metricProducer6->isActive());



    // No broadcast for active configs should have happened yet.

    EXPECT_EQ(broadcastCount, 0);



    // Activate all 3 metrics that were not active.

    std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")};

    auto event = CreateAcquireWakelockEvent(attributions1, "wl1", 100 + timeBase1);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());



    // Assert that all 3 configs are active.

    EXPECT_TRUE(metricsManager1->isActive());

    EXPECT_TRUE(metricsManager2->isActive());

    EXPECT_TRUE(metricsManager3->isActive());



    // A broadcast should have happened, and all 3 configs should be active in the broadcast.

    EXPECT_EQ(broadcastCount, 1);

    EXPECT_EQ(activeConfigsBroadcast.size(), 3);

    EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId1)

            != activeConfigsBroadcast.end());

    EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId2)

            != activeConfigsBroadcast.end());

    EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId3)

            != activeConfigsBroadcast.end());



    // When we shut down, metrics 3 & 5 have 100ns remaining, metric 6 has 100s + 100ns.

    int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC;

    EXPECT_TRUE(metricProducer3->isActive());

    int64_t ttl3 = metricProducer3->getRemainingTtlNs(shutDownTime);
@@ -472,8 +517,9 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    int64_t ttl6 = metricProducer6->getRemainingTtlNs(shutDownTime);

    EXPECT_EQ(100 + 100 * NS_PER_SEC, ttl6);



    processor->WriteMetricsActivationToDisk(timeBase1 + 100 * NS_PER_SEC);

    processor.WriteMetricsActivationToDisk(shutDownTime);



    // Create a second StatsLogProcessor and push the same 3 configs.

    long timeBase2 = 1000;

    sp<StatsLogProcessor> processor2 =

            CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1);
@@ -481,6 +527,8 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    processor2->OnConfigUpdated(timeBase2, cfgKey3, config3);



    EXPECT_EQ(3, processor2->mMetricsManagers.size());



    // First config and both metrics are active.

    it = processor2->mMetricsManagers.find(cfgKey1);

    EXPECT_TRUE(it != processor2->mMetricsManagers.end());

    auto& metricsManager1001 = it->second;
@@ -506,6 +554,7 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    auto& metricProducer1002 = *metricIt;

    EXPECT_TRUE(metricProducer1002->isActive());



    // Second config is active. Metric 3 is inactive, metric 4 is active.

    it = processor2->mMetricsManagers.find(cfgKey2);

    EXPECT_TRUE(it != processor2->mMetricsManagers.end());

    auto& metricsManager1002 = it->second;
@@ -531,6 +580,7 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    auto& metricProducer1004 = *metricIt;

    EXPECT_TRUE(metricProducer1004->isActive());



    // Config 3 is inactive. both metrics are inactive.

    it = processor2->mMetricsManagers.find(cfgKey3);

    EXPECT_TRUE(it != processor2->mMetricsManagers.end());

    auto& metricsManager1003 = it->second;
@@ -557,6 +607,7 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    auto& metricProducer1006 = *metricIt;

    EXPECT_FALSE(metricProducer1006->isActive());



    // Assert that all 3 metrics with activation are inactive and that the ttls were properly set.

    EXPECT_FALSE(metricProducer1003->isActive());

    const auto& activation1003 = metricProducer1003->mEventActivationMap.begin()->second;

    EXPECT_EQ(100 * NS_PER_SEC, activation1003.ttl_ns);
@@ -572,12 +623,16 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 


    processor2->LoadMetricsActivationFromDisk();



    // After loading activations from disk, assert that all 3 metrics are active.

    EXPECT_TRUE(metricProducer1003->isActive());

    EXPECT_EQ(timeBase2 + ttl3 - activation1003.ttl_ns, activation1003.activation_ns);

    EXPECT_TRUE(metricProducer1005->isActive());

    EXPECT_EQ(timeBase2 + ttl5 - activation1005.ttl_ns, activation1005.activation_ns);

    EXPECT_TRUE(metricProducer1006->isActive());

    EXPECT_EQ(timeBase2 + ttl6 - activation1006.ttl_ns, activation1003.activation_ns);



    // Make sure no more broadcasts have happened.

    EXPECT_EQ(broadcastCount, 1);

}



TEST(StatsLogProcessorTest, TestActivationOnBoot) {

cmds/statsd/tests/e2e/MetricActivation_e2e_test.cpp

+62 −19
Original line number Diff line number Diff line
@@ -66,17 +66,42 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 
    auto config = CreateStatsdConfig();



    int64_t bucketStartTimeNs = 10000000000;

    int64_t bucketSizeNs =

        TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;



    ConfigKey cfgKey;

    auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);

    EXPECT_EQ(processor->mMetricsManagers.size(), 1u);

    EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());

    sp<MetricProducer> metricProducer =

        processor->mMetricsManagers.begin()->second->mAllMetricProducers[0];

    int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;



    int uid = 12345;

    int64_t cfgId = 98765;

    ConfigKey cfgKey(uid, cfgId);



    sp<UidMap> m = new UidMap();

    sp<StatsPullerManager> pullerManager = new StatsPullerManager();

    sp<AlarmMonitor> anomalyAlarmMonitor;

    sp<AlarmMonitor> subscriberAlarmMonitor;

    vector<int64_t> activeConfigsBroadcast;



    long timeBase1 = 1;

    int broadcastCount = 0;

    StatsLogProcessor processor(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor,

            bucketStartTimeNs, [](const ConfigKey& key) { return true; },

            [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,

                    const vector<int64_t>& activeConfigs) {

                broadcastCount++;

                EXPECT_EQ(broadcastUid, uid);

                activeConfigsBroadcast.clear();

                activeConfigsBroadcast.insert(activeConfigsBroadcast.end(),

                        activeConfigs.begin(), activeConfigs.end());

                return true;

            });



    processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config);



    EXPECT_EQ(processor.mMetricsManagers.size(), 1u);

    sp<MetricsManager> metricsManager = processor.mMetricsManagers.begin()->second;

    EXPECT_TRUE(metricsManager->isConfigValid());

    EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1);

    sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];

    auto& eventActivationMap = metricProducer->mEventActivationMap;



    EXPECT_FALSE(metricsManager->isActive());

    EXPECT_FALSE(metricProducer->mIsActive);

    // Two activations: one is triggered by battery saver mode (tracker index 0), the other is

    // triggered by screen on event (tracker index 2).
@@ -93,13 +118,19 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 
    std::unique_ptr<LogEvent> event;



    event = CreateAppCrashEvent(111, bucketStartTimeNs + 5);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());

    EXPECT_FALSE(metricsManager->isActive());

    EXPECT_FALSE(metricProducer->mIsActive);

    EXPECT_EQ(broadcastCount, 0);



    // Activated by battery save mode.

    event = CreateBatterySaverOnEvent(bucketStartTimeNs + 10);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());

    EXPECT_TRUE(metricsManager->isActive());

    EXPECT_TRUE(metricProducer->mIsActive);

    EXPECT_EQ(broadcastCount, 1);

    EXPECT_EQ(activeConfigsBroadcast.size(), 1);

    EXPECT_EQ(activeConfigsBroadcast[0], cfgId);

    EXPECT_EQ(eventActivationMap[0].state, ActivationState::kActive);

    EXPECT_EQ(eventActivationMap[0].activation_ns, bucketStartTimeNs + 10);

    EXPECT_EQ(eventActivationMap[0].ttl_ns, 60 * 6 * NS_PER_SEC);
@@ -109,12 +140,13 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 


    // First processed event.

    event = CreateAppCrashEvent(222, bucketStartTimeNs + 15);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());



    // Activated by screen on event.

    event = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,

                                          bucketStartTimeNs + 20);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());

    EXPECT_TRUE(metricsManager->isActive());

    EXPECT_TRUE(metricProducer->mIsActive);

    EXPECT_EQ(eventActivationMap[0].state, ActivationState::kActive);

    EXPECT_EQ(eventActivationMap[0].activation_ns, bucketStartTimeNs + 10);
@@ -126,7 +158,8 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 
    // 2nd processed event.

    // The activation by screen_on event expires, but the one by battery save mode is still active.

    event = CreateAppCrashEvent(333, bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());

    EXPECT_TRUE(metricsManager->isActive());

    EXPECT_TRUE(metricProducer->mIsActive);

    EXPECT_EQ(eventActivationMap[0].state, ActivationState::kActive);

    EXPECT_EQ(eventActivationMap[0].activation_ns, bucketStartTimeNs + 10);
@@ -134,15 +167,21 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 
    EXPECT_EQ(eventActivationMap[2].state, ActivationState::kNotActive);

    EXPECT_EQ(eventActivationMap[2].activation_ns, bucketStartTimeNs + 20);

    EXPECT_EQ(eventActivationMap[2].ttl_ns, 60 * 2 * NS_PER_SEC);

    // No new broadcast since the config should still be active.

    EXPECT_EQ(broadcastCount, 1);



    // 3rd processed event.

    event = CreateAppCrashEvent(444, bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());



    // All activations expired.

    event = CreateAppCrashEvent(555, bucketStartTimeNs + NS_PER_SEC * 60 * 8);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());

    EXPECT_FALSE(metricsManager->isActive());

    EXPECT_FALSE(metricProducer->mIsActive);

    // New broadcast since the config is no longer active.

    EXPECT_EQ(broadcastCount, 2);

    EXPECT_EQ(activeConfigsBroadcast.size(), 0);

    EXPECT_EQ(eventActivationMap[0].state, ActivationState::kNotActive);

    EXPECT_EQ(eventActivationMap[0].activation_ns, bucketStartTimeNs + 10);

    EXPECT_EQ(eventActivationMap[0].ttl_ns, 60 * 6 * NS_PER_SEC);
@@ -153,8 +192,12 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 
    // Re-activate.

    event = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,

                                          bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());

    EXPECT_TRUE(metricsManager->isActive());

    EXPECT_TRUE(metricProducer->mIsActive);

    EXPECT_EQ(broadcastCount, 3);

    EXPECT_EQ(activeConfigsBroadcast.size(), 1);

    EXPECT_EQ(activeConfigsBroadcast[0], cfgId);

    EXPECT_EQ(eventActivationMap[0].state, ActivationState::kNotActive);

    EXPECT_EQ(eventActivationMap[0].activation_ns, bucketStartTimeNs + 10);

    EXPECT_EQ(eventActivationMap[0].ttl_ns, 60 * 6 * NS_PER_SEC);
@@ -163,11 +206,11 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 
    EXPECT_EQ(eventActivationMap[2].ttl_ns, 60 * 2 * NS_PER_SEC);



    event = CreateAppCrashEvent(666, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1);

    processor->OnLogEvent(event.get());

    processor.OnLogEvent(event.get());



    ConfigMetricsReportList reports;

    vector<uint8_t> buffer;

    processor->onDumpReport(cfgKey, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 1, false, true,

    processor.onDumpReport(cfgKey, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 1, false, true,

                            ADB_DUMP, &buffer);

    EXPECT_TRUE(buffer.size() > 0);

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