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

Commit 2b1d4feb authored by Ruchir Rastogi's avatar Ruchir Rastogi
Browse files

Cleaned up StatsLogProcessor Test 

Test: bit statsd_test:*
Bug: 131658651
Change-Id: I9c70bb493d0d7cb668f2105b9b723d8f58e272ac
parent 8dd45ee8

cmds/statsd/tests/StatsLogProcessor_test.cpp

+123 −184
Original line number Diff line number Diff line
@@ -1199,87 +1199,66 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 


    ConfigKey cfgKey1(uid, 12341);

    long timeBase1 = 1;

    sp<StatsLogProcessor> processor =

    sp<StatsLogProcessor> processor1 =

            CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1);



    // Metric 1 is not active.

    // Metric 2 is active.

    // {{{---------------------------------------------------------------------------

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

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

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

    EXPECT_EQ(1, processor1->mMetricsManagers.size());

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

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

    auto& metricsManager1 = it->second;

    EXPECT_TRUE(metricsManager1->isActive());



    auto metricIt = metricsManager1->mAllMetricProducers.begin();

    for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {

        if ((*metricIt)->getMetricId() == metricId1) {

            break;

        }

    }

    EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());

    auto& metricProducer1 = *metricIt;

    EXPECT_FALSE(metricProducer1->isActive());



    metricIt = metricsManager1->mAllMetricProducers.begin();

    for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {

        if ((*metricIt)->getMetricId() == metricId2) {

            break;

        }

    }

    EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());

    auto& metricProducer2 = *metricIt;

    EXPECT_TRUE(metricProducer2->isActive());



    int i = 0;

    for (; i < metricsManager1->mAllAtomMatchers.size(); i++) {

        if (metricsManager1->mAllAtomMatchers[i]->getId() ==

                metric1ActivationTrigger1->atom_matcher_id()) {

            break;

        }

    }

    const auto& activation1 = metricProducer1->mEventActivationMap.at(i);

    EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns);

    EXPECT_EQ(0, activation1->start_ns);

    EXPECT_EQ(kNotActive, activation1->state);

    EXPECT_EQ(ACTIVATE_ON_BOOT, activation1->activationType);



    i = 0;

    for (; i < metricsManager1->mAllAtomMatchers.size(); i++) {

        if (metricsManager1->mAllAtomMatchers[i]->getId() ==

                metric1ActivationTrigger2->atom_matcher_id()) {

            break;

        }

    }

    const auto& activation2 = metricProducer1->mEventActivationMap.at(i);

    EXPECT_EQ(200 * NS_PER_SEC, activation2->ttl_ns);

    EXPECT_EQ(0, activation2->start_ns);

    EXPECT_EQ(kNotActive, activation2->state);

    EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation2->activationType);

    EXPECT_EQ(metricsManager1->mAllMetricProducers.size(), 2);

    // We assume that the index of a MetricProducer within the mAllMetricProducers

    // array follows the order in which metrics are added to the config.

    auto& metricProducer1_1 = metricsManager1->mAllMetricProducers[0];

    EXPECT_EQ(metricProducer1_1->getMetricId(), metricId1);

    EXPECT_FALSE(metricProducer1_1->isActive());  // inactive due to associated MetricActivation



    auto& metricProducer1_2 = metricsManager1->mAllMetricProducers[1];

    EXPECT_EQ(metricProducer1_2->getMetricId(), metricId2);

    EXPECT_TRUE(metricProducer1_2->isActive());



    EXPECT_EQ(metricProducer1_1->mEventActivationMap.size(), 2);

    // The key in mEventActivationMap is the index of the associated atom matcher. We assume

    // that matchers are indexed in the order that they are added to the config.

    const auto& activation1_1_1 = metricProducer1_1->mEventActivationMap.at(0);

    EXPECT_EQ(100 * NS_PER_SEC, activation1_1_1->ttl_ns);

    EXPECT_EQ(0, activation1_1_1->start_ns);

    EXPECT_EQ(kNotActive, activation1_1_1->state);

    EXPECT_EQ(ACTIVATE_ON_BOOT, activation1_1_1->activationType);



    const auto& activation1_1_2 = metricProducer1_1->mEventActivationMap.at(1);

    EXPECT_EQ(200 * NS_PER_SEC, activation1_1_2->ttl_ns);

    EXPECT_EQ(0, activation1_1_2->start_ns);

    EXPECT_EQ(kNotActive, activation1_1_2->state);

    EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1_1_2->activationType);

    // }}}------------------------------------------------------------------------------



    // Trigger Activation 1 for Metric 1

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

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

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

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



    // Metric 1 is not active; Activation 1 set to kActiveOnBoot

    // Metric 2 is active.

    // {{{---------------------------------------------------------------------------

    EXPECT_FALSE(metricProducer1->isActive());

    EXPECT_EQ(0, activation1->start_ns);

    EXPECT_EQ(kActiveOnBoot, activation1->state);

    EXPECT_EQ(0, activation2->start_ns);

    EXPECT_EQ(kNotActive, activation2->state);

    EXPECT_FALSE(metricProducer1_1->isActive());

    EXPECT_EQ(0, activation1_1_1->start_ns);

    EXPECT_EQ(kActiveOnBoot, activation1_1_1->state);

    EXPECT_EQ(0, activation1_1_2->start_ns);

    EXPECT_EQ(kNotActive, activation1_1_2->state);



    EXPECT_TRUE(metricProducer2->isActive());

    EXPECT_TRUE(metricProducer1_2->isActive());

    // }}}-----------------------------------------------------------------------------



    // Simulate shutdown by saving state to disk

    int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC;

    processor->SaveActiveConfigsToDisk(shutDownTime);

    EXPECT_FALSE(metricProducer1->isActive());

    int64_t ttl1 = metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC;

    processor1->SaveActiveConfigsToDisk(shutDownTime);

    EXPECT_FALSE(metricProducer1_1->isActive());



    // Simulate device restarted state by creating new instance of StatsLogProcessor with the

    // same config.
@@ -1293,55 +1272,34 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    EXPECT_EQ(1, processor2->mMetricsManagers.size());

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

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

    auto& metricsManager1001 = it->second;

    EXPECT_TRUE(metricsManager1001->isActive());



    metricIt = metricsManager1001->mAllMetricProducers.begin();

    for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {

        if ((*metricIt)->getMetricId() == metricId1) {

            break;

        }

    }

    EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());

    auto& metricProducer1001 = *metricIt;

    EXPECT_FALSE(metricProducer1001->isActive());



    metricIt = metricsManager1001->mAllMetricProducers.begin();

    for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {

        if ((*metricIt)->getMetricId() == metricId2) {

            break;

        }

    }

    EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());

    auto& metricProducer1002 = *metricIt;

    EXPECT_TRUE(metricProducer1002->isActive());



    i = 0;

    for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) {

        if (metricsManager1001->mAllAtomMatchers[i]->getId() ==

                metric1ActivationTrigger1->atom_matcher_id()) {

            break;

        }

    }

    const auto& activation1001_1 = metricProducer1001->mEventActivationMap.at(i);

    EXPECT_EQ(100 * NS_PER_SEC, activation1001_1->ttl_ns);

    EXPECT_EQ(0, activation1001_1->start_ns);

    EXPECT_EQ(kNotActive, activation1001_1->state);

    EXPECT_EQ(ACTIVATE_ON_BOOT, activation1001_1->activationType);



    i = 0;

    for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) {

        if (metricsManager1001->mAllAtomMatchers[i]->getId() ==

                metric1ActivationTrigger2->atom_matcher_id()) {

            break;

        }

    }

    auto& metricsManager2 = it->second;

    EXPECT_TRUE(metricsManager2->isActive());



    const auto& activation1001_2 = metricProducer1001->mEventActivationMap.at(i);

    EXPECT_EQ(200 * NS_PER_SEC, activation1001_2->ttl_ns);

    EXPECT_EQ(0, activation1001_2->start_ns);

    EXPECT_EQ(kNotActive, activation1001_2->state);

    EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1001_2->activationType);

    EXPECT_EQ(metricsManager2->mAllMetricProducers.size(), 2);

    // We assume that the index of a MetricProducer within the mAllMetricProducers

    // array follows the order in which metrics are added to the config.

    auto& metricProducer2_1 = metricsManager2->mAllMetricProducers[0];

    EXPECT_EQ(metricProducer2_1->getMetricId(), metricId1);

    EXPECT_FALSE(metricProducer2_1->isActive());



    auto& metricProducer2_2 = metricsManager2->mAllMetricProducers[1];

    EXPECT_EQ(metricProducer2_2->getMetricId(), metricId2);

    EXPECT_TRUE(metricProducer2_2->isActive());



    EXPECT_EQ(metricProducer2_1->mEventActivationMap.size(), 2);

    // The key in mEventActivationMap is the index of the associated atom matcher. We assume

    // that matchers are indexed in the order that they are added to the config.

    const auto& activation2_1_1 = metricProducer2_1->mEventActivationMap.at(0);

    EXPECT_EQ(100 * NS_PER_SEC, activation2_1_1->ttl_ns);

    EXPECT_EQ(0, activation2_1_1->start_ns);

    EXPECT_EQ(kNotActive, activation2_1_1->state);

    EXPECT_EQ(ACTIVATE_ON_BOOT, activation2_1_1->activationType);



    const auto& activation2_1_2 = metricProducer2_1->mEventActivationMap.at(1);

    EXPECT_EQ(200 * NS_PER_SEC, activation2_1_2->ttl_ns);

    EXPECT_EQ(0, activation2_1_2->start_ns);

    EXPECT_EQ(kNotActive, activation2_1_2->state);

    EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation2_1_2->activationType);

    // }}}-----------------------------------------------------------------------------------



    // Load saved state from disk.
@@ -1350,13 +1308,14 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    // Metric 1 active; Activation 1 is active, Activation 2 is not active

    // Metric 2 is active.

    // {{{---------------------------------------------------------------------------

    EXPECT_TRUE(metricProducer1001->isActive());

    EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns);

    EXPECT_EQ(kActive, activation1001_1->state);

    EXPECT_EQ(0, activation1001_2->start_ns);

    EXPECT_EQ(kNotActive, activation1001_2->state);

    EXPECT_TRUE(metricProducer2_1->isActive());

    int64_t ttl1 = metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC;

    EXPECT_EQ(timeBase2 + ttl1 - activation2_1_1->ttl_ns, activation2_1_1->start_ns);

    EXPECT_EQ(kActive, activation2_1_1->state);

    EXPECT_EQ(0, activation2_1_2->start_ns);

    EXPECT_EQ(kNotActive, activation2_1_2->state);



    EXPECT_TRUE(metricProducer1002->isActive());

    EXPECT_TRUE(metricProducer2_2->isActive());

    // }}}--------------------------------------------------------------------------------



    // Trigger Activation 2 for Metric 1.
@@ -1369,23 +1328,23 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    // Metric 1 active; Activation 1 is active, Activation 2 is active

    // Metric 2 is active.

    // {{{---------------------------------------------------------------------------

    EXPECT_TRUE(metricProducer1001->isActive());

    EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns);

    EXPECT_EQ(kActive, activation1001_1->state);

    EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activation1001_2->start_ns);

    EXPECT_EQ(kActive, activation1001_2->state);

    EXPECT_TRUE(metricProducer2_1->isActive());

    EXPECT_EQ(timeBase2 + ttl1 - activation2_1_1->ttl_ns, activation2_1_1->start_ns);

    EXPECT_EQ(kActive, activation2_1_1->state);

    EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activation2_1_2->start_ns);

    EXPECT_EQ(kActive, activation2_1_2->state);



    EXPECT_TRUE(metricProducer1002->isActive());

    EXPECT_TRUE(metricProducer2_2->isActive());

    // }}}---------------------------------------------------------------------------



    // Simulate shutdown by saving state to disk

    shutDownTime = timeBase2 + 50 * NS_PER_SEC;

    processor2->SaveActiveConfigsToDisk(shutDownTime);

    EXPECT_TRUE(metricProducer1001->isActive());

    EXPECT_TRUE(metricProducer1002->isActive());

    ttl1 = timeBase2 + metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC - shutDownTime;

    int64_t ttl2 = screenOnEvent->GetElapsedTimestampNs() +

            metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC - shutDownTime;

    EXPECT_TRUE(metricProducer2_1->isActive());

    EXPECT_TRUE(metricProducer2_2->isActive());

    ttl1 -= shutDownTime - timeBase2;

    int64_t ttl2 = metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC

            - (shutDownTime - screenOnEvent->GetElapsedTimestampNs());



    // Simulate device restarted state by creating new instance of StatsLogProcessor with the

    // same config.
@@ -1399,55 +1358,34 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    EXPECT_EQ(1, processor3->mMetricsManagers.size());

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

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

    auto& metricsManagerTimeBase3 = it->second;

    EXPECT_TRUE(metricsManagerTimeBase3->isActive());



    metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin();

    for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) {

        if ((*metricIt)->getMetricId() == metricId1) {

            break;

        }

    }

    EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end());

    auto& metricProducerTimeBase3_1 = *metricIt;

    EXPECT_FALSE(metricProducerTimeBase3_1->isActive());



    metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin();

    for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) {

        if ((*metricIt)->getMetricId() == metricId2) {

            break;

        }

    }

    EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end());

    auto& metricProducerTimeBase3_2 = *metricIt;

    EXPECT_TRUE(metricProducerTimeBase3_2->isActive());



    i = 0;

    for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) {

        if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() ==

                metric1ActivationTrigger1->atom_matcher_id()) {

            break;

        }

    }

    const auto& activationTimeBase3_1 = metricProducerTimeBase3_1->mEventActivationMap.at(i);

    EXPECT_EQ(100 * NS_PER_SEC, activationTimeBase3_1->ttl_ns);

    EXPECT_EQ(0, activationTimeBase3_1->start_ns);

    EXPECT_EQ(kNotActive, activationTimeBase3_1->state);

    EXPECT_EQ(ACTIVATE_ON_BOOT, activationTimeBase3_1->activationType);



    i = 0;

    for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) {

        if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() ==

                metric1ActivationTrigger2->atom_matcher_id()) {

            break;

        }

    }

    auto& metricsManager3 = it->second;

    EXPECT_TRUE(metricsManager3->isActive());



    const auto& activationTimeBase3_2 = metricProducerTimeBase3_1->mEventActivationMap.at(i);

    EXPECT_EQ(200 * NS_PER_SEC, activationTimeBase3_2->ttl_ns);

    EXPECT_EQ(0, activationTimeBase3_2->start_ns);

    EXPECT_EQ(kNotActive, activationTimeBase3_2->state);

    EXPECT_EQ(ACTIVATE_IMMEDIATELY, activationTimeBase3_2->activationType);

    EXPECT_EQ(metricsManager3->mAllMetricProducers.size(), 2);

    // We assume that the index of a MetricProducer within the mAllMetricProducers

    // array follows the order in which metrics are added to the config.

    auto& metricProducer3_1 = metricsManager3->mAllMetricProducers[0];

    EXPECT_EQ(metricProducer3_1->getMetricId(), metricId1);

    EXPECT_FALSE(metricProducer3_1->isActive());



    auto& metricProducer3_2 = metricsManager3->mAllMetricProducers[1];

    EXPECT_EQ(metricProducer3_2->getMetricId(), metricId2);

    EXPECT_TRUE(metricProducer3_2->isActive());



    EXPECT_EQ(metricProducer3_1->mEventActivationMap.size(), 2);

    // The key in mEventActivationMap is the index of the associated atom matcher. We assume

    // that matchers are indexed in the order that they are added to the config.

    const auto& activation3_1_1 = metricProducer3_1->mEventActivationMap.at(0);

    EXPECT_EQ(100 * NS_PER_SEC, activation3_1_1->ttl_ns);

    EXPECT_EQ(0, activation3_1_1->start_ns);

    EXPECT_EQ(kNotActive, activation3_1_1->state);

    EXPECT_EQ(ACTIVATE_ON_BOOT, activation3_1_1->activationType);



    const auto& activation3_1_2 = metricProducer3_1->mEventActivationMap.at(1);

    EXPECT_EQ(200 * NS_PER_SEC, activation3_1_2->ttl_ns);

    EXPECT_EQ(0, activation3_1_2->start_ns);

    EXPECT_EQ(kNotActive, activation3_1_2->state);

    EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation3_1_2->activationType);

    // }}}----------------------------------------------------------------------------------



    // Load saved state from disk.
@@ -1456,13 +1394,13 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    // Metric 1 active: Activation 1 is active, Activation 2 is active

    // Metric 2 is active.

    // {{{---------------------------------------------------------------------------

    EXPECT_TRUE(metricProducerTimeBase3_1->isActive());

    EXPECT_EQ(timeBase3 + ttl1 - activationTimeBase3_1->ttl_ns, activationTimeBase3_1->start_ns);

    EXPECT_EQ(kActive, activationTimeBase3_1->state);

    EXPECT_EQ(timeBase3 + ttl2 - activationTimeBase3_2->ttl_ns, activationTimeBase3_2->start_ns);

    EXPECT_EQ(kActive, activationTimeBase3_2->state);

    EXPECT_TRUE(metricProducer3_1->isActive());

    EXPECT_EQ(timeBase3 + ttl1 - activation3_1_1->ttl_ns, activation3_1_1->start_ns);

    EXPECT_EQ(kActive, activation3_1_1->state);

    EXPECT_EQ(timeBase3 + ttl2 - activation3_1_2->ttl_ns, activation3_1_2->start_ns);

    EXPECT_EQ(kActive, activation3_1_2->state);



    EXPECT_TRUE(metricProducerTimeBase3_2->isActive());

    EXPECT_TRUE(metricProducer3_2->isActive());

    // }}}-------------------------------------------------------------------------------
@@ -1473,15 +1411,16 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    );

    processor3->OnLogEvent(screenOnEvent.get());



    // Metric 1 active; Activation 1 is not active, Activation 2 is set to active

    // Metric 1 active; Activation 1 is inactive (above screenOnEvent causes ttl1 to expire),

    //                  Activation 2 is set to active

    // Metric 2 is active.

    // {{{---------------------------------------------------------------------------

    EXPECT_TRUE(metricProducerTimeBase3_1->isActive());

    EXPECT_EQ(kNotActive, activationTimeBase3_1->state);

    EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activationTimeBase3_2->start_ns);

    EXPECT_EQ(kActive, activationTimeBase3_2->state);

    EXPECT_TRUE(metricProducer3_1->isActive());

    EXPECT_EQ(kNotActive, activation3_1_1->state);

    EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activation3_1_2->start_ns);

    EXPECT_EQ(kActive, activation3_1_2->state);



    EXPECT_TRUE(metricProducerTimeBase3_2->isActive());

    EXPECT_TRUE(metricProducer3_2->isActive());

    // }}}---------------------------------------------------------------------------

}