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

Commit 1fd0572b authored by Muhammad Qureshi's avatar Muhammad Qureshi Committed by Automerger Merge Worker
Browse files

Merge "Use ASSERT_EQ for size assertions." into rvc-dev am: a3461a2d am: 543b79d2 

Change-Id: Ie149eba39efa649527a8cf05e4d4cb7db9c5a4e9
parents 33bd3b7c 543b79d2

cmds/statsd/tests/AlarmMonitor_test.cpp

+3 −3
Original line number Diff line number Diff line
@@ -49,19 +49,19 @@ TEST(AlarmMonitor, popSoonerThan) { 
    EXPECT_TRUE(set.empty());



    set = am.popSoonerThan(30);

    EXPECT_EQ(4u, set.size());

    ASSERT_EQ(4u, set.size());

    EXPECT_EQ(1u, set.count(a));

    EXPECT_EQ(1u, set.count(b));

    EXPECT_EQ(1u, set.count(c));

    EXPECT_EQ(1u, set.count(d));



    set = am.popSoonerThan(60);

    EXPECT_EQ(2u, set.size());

    ASSERT_EQ(2u, set.size());

    EXPECT_EQ(1u, set.count(e));

    EXPECT_EQ(1u, set.count(f));



    set = am.popSoonerThan(80);

    EXPECT_EQ(0u, set.size());

    ASSERT_EQ(0u, set.size());

}



#else

cmds/statsd/tests/FieldValue_test.cpp

+18 −18
Original line number Diff line number Diff line
@@ -74,7 +74,7 @@ TEST(AtomMatcherTest, TestFieldTranslation) { 
    vector<Matcher> output;

    translateFieldMatcher(matcher1, &output);



    EXPECT_EQ((size_t)1, output.size());

    ASSERT_EQ((size_t)1, output.size());



    const auto& matcher12 = output[0];

    EXPECT_EQ((int32_t)10, matcher12.mMatcher.getTag());
@@ -95,7 +95,7 @@ TEST(AtomMatcherTest, TestFieldTranslation_ALL) { 
    vector<Matcher> output;

    translateFieldMatcher(matcher1, &output);



    EXPECT_EQ((size_t)1, output.size());

    ASSERT_EQ((size_t)1, output.size());



    const auto& matcher12 = output[0];

    EXPECT_EQ((int32_t)10, matcher12.mMatcher.getTag());
@@ -128,7 +128,7 @@ TEST(AtomMatcherTest, TestFilter_ALL) { 


    filterValues(matchers, event.getValues(), &output);



    EXPECT_EQ((size_t)7, output.getValues().size());

    ASSERT_EQ((size_t)7, output.getValues().size());

    EXPECT_EQ((int32_t)0x02010101, output.getValues()[0].mField.getField());

    EXPECT_EQ((int32_t)1111, output.getValues()[0].mValue.int_value);

    EXPECT_EQ((int32_t)0x02010102, output.getValues()[1].mField.getField());
@@ -218,12 +218,12 @@ TEST(AtomMatcherTest, TestMetric2ConditionLink) { 
    translateFieldMatcher(whatMatcher, &link.metricFields);

    translateFieldMatcher(conditionMatcher, &link.conditionFields);



    EXPECT_EQ((size_t)1, link.metricFields.size());

    ASSERT_EQ((size_t)1, link.metricFields.size());

    EXPECT_EQ((int32_t)0x02010001, link.metricFields[0].mMatcher.getField());

    EXPECT_EQ((int32_t)0xff7f007f, link.metricFields[0].mMask);

    EXPECT_EQ((int32_t)10, link.metricFields[0].mMatcher.getTag());



    EXPECT_EQ((size_t)1, link.conditionFields.size());

    ASSERT_EQ((size_t)1, link.conditionFields.size());

    EXPECT_EQ((int32_t)0x02028002, link.conditionFields[0].mMatcher.getField());

    EXPECT_EQ((int32_t)0xff7f807f, link.conditionFields[0].mMask);

    EXPECT_EQ((int32_t)27, link.conditionFields[0].mMatcher.getTag());
@@ -264,15 +264,15 @@ TEST(AtomMatcherTest, TestWriteDimensionPath) { 
        }



        DimensionsValue result;

        EXPECT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));

        ASSERT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));



        EXPECT_EQ(10, result.field());

        EXPECT_EQ(DimensionsValue::ValueCase::kValueTuple, result.value_case());

        EXPECT_EQ(3, result.value_tuple().dimensions_value_size());

        ASSERT_EQ(3, result.value_tuple().dimensions_value_size());



        const auto& dim1 = result.value_tuple().dimensions_value(0);

        EXPECT_EQ(2, dim1.field());

        EXPECT_EQ(2, dim1.value_tuple().dimensions_value_size());

        ASSERT_EQ(2, dim1.value_tuple().dimensions_value_size());



        const auto& dim11 = dim1.value_tuple().dimensions_value(0);

        EXPECT_EQ(1, dim11.field());
@@ -285,7 +285,7 @@ TEST(AtomMatcherTest, TestWriteDimensionPath) { 


        const auto& dim3 = result.value_tuple().dimensions_value(2);

        EXPECT_EQ(6, dim3.field());

        EXPECT_EQ(1, dim3.value_tuple().dimensions_value_size());

        ASSERT_EQ(1, dim3.value_tuple().dimensions_value_size());

        const auto& dim31 = dim3.value_tuple().dimensions_value(0);

        EXPECT_EQ(2, dim31.field());

    }
@@ -356,14 +356,14 @@ TEST(AtomMatcherTest, TestWriteDimensionToProto) { 
    }



    DimensionsValue result;

    EXPECT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));

    ASSERT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));

    EXPECT_EQ(10, result.field());

    EXPECT_EQ(DimensionsValue::ValueCase::kValueTuple, result.value_case());

    EXPECT_EQ(2, result.value_tuple().dimensions_value_size());

    ASSERT_EQ(2, result.value_tuple().dimensions_value_size());



    const auto& dim1 = result.value_tuple().dimensions_value(0);

    EXPECT_EQ(DimensionsValue::ValueCase::kValueTuple, dim1.value_case());

    EXPECT_EQ(3, dim1.value_tuple().dimensions_value_size());

    ASSERT_EQ(3, dim1.value_tuple().dimensions_value_size());



    const auto& dim11 = dim1.value_tuple().dimensions_value(0);

    EXPECT_EQ(DimensionsValue::ValueCase::kValueInt, dim11.value_case());
@@ -418,8 +418,8 @@ TEST(AtomMatcherTest, TestWriteDimensionLeafNodesToProto) { 
    }



    DimensionsValueTuple result;

    EXPECT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));

    EXPECT_EQ(4, result.dimensions_value_size());

    ASSERT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));

    ASSERT_EQ(4, result.dimensions_value_size());



    const auto& dim1 = result.dimensions_value(0);

    EXPECT_EQ(DimensionsValue::ValueCase::kValueInt, dim1.value_case());
@@ -460,10 +460,10 @@ TEST(AtomMatcherTest, TestWriteAtomToProto) { 
    }



    Atom result;

    EXPECT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));

    ASSERT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));

    EXPECT_EQ(Atom::PushedCase::kBleScanResultReceived, result.pushed_case());

    const auto& atom = result.ble_scan_result_received();

    EXPECT_EQ(2, atom.attribution_node_size());

    ASSERT_EQ(2, atom.attribution_node_size());

    EXPECT_EQ(1111, atom.attribution_node(0).uid());

    EXPECT_EQ("location1", atom.attribution_node(0).tag());

    EXPECT_EQ(2222, atom.attribution_node(1).uid());
@@ -488,7 +488,7 @@ TEST(AtomMatcherTest, TestSubsetDimensions1) { 


    vector<Matcher> matchers1;

    translateFieldMatcher(matcher1, &matchers1);

    EXPECT_EQ(2, matchers1.size());

    ASSERT_EQ(2, matchers1.size());



    // Initialize second set of matchers

    FieldMatcher matcher2;
@@ -501,7 +501,7 @@ TEST(AtomMatcherTest, TestSubsetDimensions1) { 


    vector<Matcher> matchers2;

    translateFieldMatcher(matcher2, &matchers2);

    EXPECT_EQ(1, matchers2.size());

    ASSERT_EQ(1, matchers2.size());



    EXPECT_FALSE(subsetDimensions(matchers1, matchers2));

    EXPECT_TRUE(subsetDimensions(matchers2, matchers1));

cmds/statsd/tests/LogEvent_test.cpp

+11 −11
Original line number Diff line number Diff line
@@ -98,7 +98,7 @@ TEST(LogEventTest, TestPrimitiveParsing) { 
    EXPECT_FALSE(logEvent.hasAttributionChain());



    const vector<FieldValue>& values = logEvent.getValues();

    EXPECT_EQ(4, values.size());

    ASSERT_EQ(4, values.size());



    const FieldValue& int32Item = values[0];

    Field expectedField = getField(100, {1, 1, 1}, 0, {false, false, false});
@@ -147,7 +147,7 @@ TEST(LogEventTest, TestStringAndByteArrayParsing) { 
    EXPECT_FALSE(logEvent.hasAttributionChain());



    const vector<FieldValue>& values = logEvent.getValues();

    EXPECT_EQ(2, values.size());

    ASSERT_EQ(2, values.size());



    const FieldValue& stringItem = values[0];

    Field expectedField = getField(100, {1, 1, 1}, 0, {false, false, false});
@@ -184,7 +184,7 @@ TEST(LogEventTest, TestEmptyString) { 
    EXPECT_FALSE(logEvent.hasAttributionChain());



    const vector<FieldValue>& values = logEvent.getValues();

    EXPECT_EQ(1, values.size());

    ASSERT_EQ(1, values.size());



    const FieldValue& item = values[0];

    Field expectedField = getField(100, {1, 1, 1}, 0, {true, false, false});
@@ -213,7 +213,7 @@ TEST(LogEventTest, TestByteArrayWithNullCharacter) { 
    EXPECT_EQ(1001, logEvent.GetPid());



    const vector<FieldValue>& values = logEvent.getValues();

    EXPECT_EQ(1, values.size());

    ASSERT_EQ(1, values.size());



    const FieldValue& item = values[0];

    Field expectedField = getField(100, {1, 1, 1}, 0, {true, false, false});
@@ -249,7 +249,7 @@ TEST(LogEventTest, TestAttributionChain) { 
    EXPECT_EQ(1001, logEvent.GetPid());



    const vector<FieldValue>& values = logEvent.getValues();

    EXPECT_EQ(4, values.size());  // 2 per attribution node

    ASSERT_EQ(4, values.size());  // 2 per attribution node



    std::pair<int, int> attrIndexRange;

    EXPECT_TRUE(logEvent.hasAttributionChain(&attrIndexRange));
@@ -290,7 +290,7 @@ TEST(LogEventTest, TestAnnotationIdIsUid) { 
    createIntWithBoolAnnotationLogEvent(&event, ANNOTATION_ID_IS_UID, true);



    const vector<FieldValue>& values = event.getValues();

    EXPECT_EQ(values.size(), 1);

    ASSERT_EQ(values.size(), 1);

    EXPECT_EQ(event.getUidFieldIndex(), 0);

}
@@ -299,7 +299,7 @@ TEST(LogEventTest, TestAnnotationIdStateNested) { 
    createIntWithBoolAnnotationLogEvent(&event, ANNOTATION_ID_STATE_NESTED, true);



    const vector<FieldValue>& values = event.getValues();

    EXPECT_EQ(values.size(), 1);

    ASSERT_EQ(values.size(), 1);

    EXPECT_TRUE(values[0].mAnnotations.isNested());

}
@@ -308,7 +308,7 @@ TEST(LogEventTest, TestPrimaryFieldAnnotation) { 
    createIntWithBoolAnnotationLogEvent(&event, ANNOTATION_ID_PRIMARY_FIELD, true);



    const vector<FieldValue>& values = event.getValues();

    EXPECT_EQ(values.size(), 1);

    ASSERT_EQ(values.size(), 1);

    EXPECT_TRUE(values[0].mAnnotations.isPrimaryField());

}
@@ -317,7 +317,7 @@ TEST(LogEventTest, TestExclusiveStateAnnotation) { 
    createIntWithBoolAnnotationLogEvent(&event, ANNOTATION_ID_EXCLUSIVE_STATE, true);



    const vector<FieldValue>& values = event.getValues();

    EXPECT_EQ(values.size(), 1);

    ASSERT_EQ(values.size(), 1);

    EXPECT_TRUE(values[0].mAnnotations.isExclusiveState());

}
@@ -349,7 +349,7 @@ TEST(LogEventTest, TestPrimaryFieldFirstUidAnnotation) { 


    // Check annotation

    const vector<FieldValue>& values = logEvent.getValues();

    EXPECT_EQ(values.size(), numInts + 4);

    ASSERT_EQ(values.size(), numInts + 4);

    EXPECT_TRUE(values[firstUidInChainIndex].mAnnotations.isPrimaryField());

}
@@ -359,7 +359,7 @@ TEST(LogEventTest, TestResetStateAnnotation) { 
    createIntWithIntAnnotationLogEvent(&event, ANNOTATION_ID_TRIGGER_STATE_RESET, resetState);



    const vector<FieldValue>& values = event.getValues();

    EXPECT_EQ(values.size(), 1);

    ASSERT_EQ(values.size(), 1);

    EXPECT_EQ(event.getResetState(), resetState);

}

cmds/statsd/tests/MetricsManager_test.cpp

+4 −4
Original line number Diff line number Diff line
@@ -309,10 +309,10 @@ TEST(MetricsManagerTest, TestGoodConfig) { 
                                 activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap,

                                 alertTrackerMap, metricsWithActivation,

                                 noReportMetricIds));

    EXPECT_EQ(1u, allMetricProducers.size());

    EXPECT_EQ(1u, allAnomalyTrackers.size());

    EXPECT_EQ(1u, noReportMetricIds.size());

    EXPECT_EQ(1u, alertTrackerMap.size());

    ASSERT_EQ(1u, allMetricProducers.size());

    ASSERT_EQ(1u, allAnomalyTrackers.size());

    ASSERT_EQ(1u, noReportMetricIds.size());

    ASSERT_EQ(1u, alertTrackerMap.size());

    EXPECT_NE(alertTrackerMap.find(kAlertId), alertTrackerMap.end());

    EXPECT_EQ(alertTrackerMap.find(kAlertId)->second, 0);

}

cmds/statsd/tests/StatsLogProcessor_test.cpp

+37 −37
Original line number Diff line number Diff line
@@ -187,7 +187,7 @@ TEST(StatsLogProcessorTest, TestUidMapHasSnapshot) { 
    EXPECT_TRUE(output.reports_size() > 0);

    auto uidmap = output.reports(0).uid_map();

    EXPECT_TRUE(uidmap.snapshots_size() > 0);

    EXPECT_EQ(2, uidmap.snapshots(0).package_info_size());

    ASSERT_EQ(2, uidmap.snapshots(0).package_info_size());

}



TEST(StatsLogProcessorTest, TestEmptyConfigHasNoUidMap) {
@@ -248,7 +248,7 @@ TEST(StatsLogProcessorTest, TestReportIncludesSubConfig) { 
    output.ParseFromArray(bytes.data(), bytes.size());

    EXPECT_TRUE(output.reports_size() > 0);

    auto report = output.reports(0);

    EXPECT_EQ(1, report.annotation_size());

    ASSERT_EQ(1, report.annotation_size());

    EXPECT_EQ(1, report.annotation(0).field_int64());

    EXPECT_EQ(2, report.annotation(0).field_int32());

}
@@ -281,16 +281,16 @@ TEST(StatsLogProcessorTest, TestOnDumpReportEraseData) { 
    processor->onDumpReport(cfgKey, 3, true, false /* Do NOT erase data. */, ADB_DUMP, FAST,

                            &bytes);

    output.ParseFromArray(bytes.data(), bytes.size());

    EXPECT_EQ(output.reports_size(), 1);

    EXPECT_EQ(output.reports(0).metrics_size(), 1);

    EXPECT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1);

    ASSERT_EQ(output.reports_size(), 1);

    ASSERT_EQ(output.reports(0).metrics_size(), 1);

    ASSERT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1);



    // Dump report WITH erasing data. There should be data since we didn't previously erase it.

    processor->onDumpReport(cfgKey, 4, true, true /* DO erase data. */, ADB_DUMP, FAST, &bytes);

    output.ParseFromArray(bytes.data(), bytes.size());

    EXPECT_EQ(output.reports_size(), 1);

    EXPECT_EQ(output.reports(0).metrics_size(), 1);

    EXPECT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1);

    ASSERT_EQ(output.reports_size(), 1);

    ASSERT_EQ(output.reports(0).metrics_size(), 1);

    ASSERT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1);



    // Dump report again. There should be no data since we erased it.

    processor->onDumpReport(cfgKey, 5, true, true /* DO erase data. */, ADB_DUMP, FAST, &bytes);
@@ -438,7 +438,7 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    processor.OnConfigUpdated(2, cfgKey2, config2);

    processor.OnConfigUpdated(3, cfgKey3, config3);



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

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



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

    auto it = processor.mMetricsManagers.find(cfgKey1);
@@ -535,7 +535,7 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 


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

    EXPECT_EQ(broadcastCount, 1);

    EXPECT_EQ(activeConfigsBroadcast.size(), 3);

    ASSERT_EQ(activeConfigsBroadcast.size(), 3);

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

                activeConfigsBroadcast.end());

    EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId2) !=
@@ -560,7 +560,7 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    processor2->OnConfigUpdated(timeBase2, cfgKey2, config2);

    processor2->OnConfigUpdated(timeBase2, cfgKey3, config3);



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

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



    // First config and both metrics are active.

    it = processor2->mMetricsManagers.find(cfgKey1);
@@ -619,7 +619,7 @@ TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 
    EXPECT_TRUE(it != processor2->mMetricsManagers.end());

    auto& metricsManager1003 = it->second;

    EXPECT_FALSE(metricsManager1003->isActive());

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

    ASSERT_EQ(2, metricsManager1003->mAllMetricProducers.size());



    metricIt = metricsManager1003->mAllMetricProducers.begin();

    for (; metricIt != metricsManager1002->mAllMetricProducers.end(); metricIt++) {
@@ -702,7 +702,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBoot) { 
    sp<StatsLogProcessor> processor =

            CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1);



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

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

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

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

    auto& metricsManager1 = it->second;
@@ -752,7 +752,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBoot) { 
    sp<StatsLogProcessor> processor2 =

            CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1);



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

    ASSERT_EQ(1, processor2->mMetricsManagers.size());

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

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

    auto& metricsManager1001 = it->second;
@@ -835,7 +835,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { 
    // Metric 1 is not active.

    // Metric 2 is active.

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

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

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

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

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

    auto& metricsManager1 = it->second;
@@ -920,7 +920,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { 
    // Metric 1 is not active.

    // Metric 2 is active.

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

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

    ASSERT_EQ(1, processor2->mMetricsManagers.size());

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

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

    auto& metricsManager1001 = it->second;
@@ -1021,7 +1021,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { 
    // Metric 1 is not active.

    // Metric 2 is active.

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

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

    ASSERT_EQ(1, processor3->mMetricsManagers.size());

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

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

    auto& metricsManagerTimeBase3 = it->second;
@@ -1123,7 +1123,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { 
    // Metric 1 is not active.

    // Metric 2 is active.

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

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

    ASSERT_EQ(1, processor4->mMetricsManagers.size());

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

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

    auto& metricsManagerTimeBase4 = it->second;
@@ -1237,13 +1237,13 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    // Metric 1 is not active.

    // Metric 2 is active.

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

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

    ASSERT_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());



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

    ASSERT_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];
@@ -1254,7 +1254,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    EXPECT_EQ(metricProducer1_2->getMetricId(), metricId2);

    EXPECT_TRUE(metricProducer1_2->isActive());



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

    ASSERT_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);
@@ -1303,13 +1303,13 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    // Metric 1 is not active.

    // Metric 2 is active.

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

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

    ASSERT_EQ(1, processor2->mMetricsManagers.size());

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

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

    auto& metricsManager2 = it->second;

    EXPECT_TRUE(metricsManager2->isActive());



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

    ASSERT_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];
@@ -1320,7 +1320,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    EXPECT_EQ(metricProducer2_2->getMetricId(), metricId2);

    EXPECT_TRUE(metricProducer2_2->isActive());



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

    ASSERT_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);
@@ -1387,13 +1387,13 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    // Metric 1 is not active.

    // Metric 2 is active.

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

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

    ASSERT_EQ(1, processor3->mMetricsManagers.size());

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

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

    auto& metricsManager3 = it->second;

    EXPECT_TRUE(metricsManager3->isActive());



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

    ASSERT_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];
@@ -1404,7 +1404,7 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActi 
    EXPECT_EQ(metricProducer3_2->getMetricId(), metricId2);

    EXPECT_TRUE(metricProducer3_2->isActive());



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

    ASSERT_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);
@@ -1531,12 +1531,12 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { 
    // Metric 3 is active.

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

    sp<StatsLogProcessor> processor = service->mProcessor;

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

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

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

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

    auto& metricsManager1 = it->second;

    EXPECT_TRUE(metricsManager1->isActive());

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

    ASSERT_EQ(3, metricsManager1->mAllMetricProducers.size());



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

    EXPECT_EQ(metricId1, metricProducer1->getMetricId());
@@ -1551,7 +1551,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { 
    EXPECT_TRUE(metricProducer3->isActive());



    // Check event activations.

    EXPECT_EQ(metricsManager1->mAllAtomMatchers.size(), 4);

    ASSERT_EQ(metricsManager1->mAllAtomMatchers.size(), 4);

    EXPECT_EQ(metricsManager1->mAllAtomMatchers[0]->getId(),

              metric1ActivationTrigger1->atom_matcher_id());

    const auto& activation1 = metricProducer1->mEventActivationMap.at(0);
@@ -1628,12 +1628,12 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { 


    // We should have a new metrics manager. Lets get it and ensure activation status is restored.

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

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

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

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

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

    auto& metricsManager2 = it->second;

    EXPECT_TRUE(metricsManager2->isActive());

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

    ASSERT_EQ(3, metricsManager2->mAllMetricProducers.size());



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

    EXPECT_EQ(metricId1, metricProducer1001->getMetricId());
@@ -1651,7 +1651,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { 
    // Activation 1 is kActiveOnBoot.

    // Activation 2 and 3 are not active.

    // Activation 4 is active.

    EXPECT_EQ(metricsManager2->mAllAtomMatchers.size(), 4);

    ASSERT_EQ(metricsManager2->mAllAtomMatchers.size(), 4);

    EXPECT_EQ(metricsManager2->mAllAtomMatchers[0]->getId(),

              metric1ActivationTrigger1->atom_matcher_id());

    const auto& activation1001 = metricProducer1001->mEventActivationMap.at(0);
@@ -1709,7 +1709,7 @@ TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogHostUid) { 
    processor->OnLogEvent(logEvent.get());



    const vector<FieldValue>* actualFieldValues = &logEvent->getValues();

    EXPECT_EQ(3, actualFieldValues->size());

    ASSERT_EQ(3, actualFieldValues->size());

    EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);

    EXPECT_EQ(field1, actualFieldValues->at(1).mValue.int_value);

    EXPECT_EQ(field2, actualFieldValues->at(2).mValue.int_value);
@@ -1734,7 +1734,7 @@ TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogIsolatedUid) { 
    processor->OnLogEvent(logEvent.get());



    const vector<FieldValue>* actualFieldValues = &logEvent->getValues();

    EXPECT_EQ(3, actualFieldValues->size());

    ASSERT_EQ(3, actualFieldValues->size());

    EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);

    EXPECT_EQ(field1, actualFieldValues->at(1).mValue.int_value);

    EXPECT_EQ(field2, actualFieldValues->at(2).mValue.int_value);
@@ -1759,7 +1759,7 @@ TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogHostUidAttributionChain) 
    processor->OnLogEvent(logEvent.get());



    const vector<FieldValue>* actualFieldValues = &logEvent->getValues();

    EXPECT_EQ(6, actualFieldValues->size());

    ASSERT_EQ(6, actualFieldValues->size());

    EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);

    EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);

    EXPECT_EQ(200, actualFieldValues->at(2).mValue.int_value);
@@ -1787,7 +1787,7 @@ TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogIsolatedUidAttributionCha 
    processor->OnLogEvent(logEvent.get());



    const vector<FieldValue>* actualFieldValues = &logEvent->getValues();

    EXPECT_EQ(6, actualFieldValues->size());

    ASSERT_EQ(6, actualFieldValues->size());

    EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);

    EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);

    EXPECT_EQ(200, actualFieldValues->at(2).mValue.int_value);