diff --git a/cmds/statsd/tests/AlarmMonitor_test.cpp b/cmds/statsd/tests/AlarmMonitor_test.cpp index edbf8b5e8ee6a..1dc9795dcf169 100644 --- a/cmds/statsd/tests/AlarmMonitor_test.cpp +++ b/cmds/statsd/tests/AlarmMonitor_test.cpp @@ -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 diff --git a/cmds/statsd/tests/FieldValue_test.cpp b/cmds/statsd/tests/FieldValue_test.cpp index f5ba8fd0d60d3..23f8ca4e74e60 100644 --- a/cmds/statsd/tests/FieldValue_test.cpp +++ b/cmds/statsd/tests/FieldValue_test.cpp @@ -74,7 +74,7 @@ TEST(AtomMatcherTest, TestFieldTranslation) { vector 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 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 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 matchers2; translateFieldMatcher(matcher2, &matchers2); - EXPECT_EQ(1, matchers2.size()); + ASSERT_EQ(1, matchers2.size()); EXPECT_FALSE(subsetDimensions(matchers1, matchers2)); EXPECT_TRUE(subsetDimensions(matchers2, matchers1)); diff --git a/cmds/statsd/tests/LogEvent_test.cpp b/cmds/statsd/tests/LogEvent_test.cpp index 00f336a4986d2..5c170c07eb7d9 100644 --- a/cmds/statsd/tests/LogEvent_test.cpp +++ b/cmds/statsd/tests/LogEvent_test.cpp @@ -98,7 +98,7 @@ TEST(LogEventTest, TestPrimitiveParsing) { EXPECT_FALSE(logEvent.hasAttributionChain()); const vector& 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& 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& 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& 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& values = logEvent.getValues(); - EXPECT_EQ(4, values.size()); // 2 per attribution node + ASSERT_EQ(4, values.size()); // 2 per attribution node std::pair attrIndexRange; EXPECT_TRUE(logEvent.hasAttributionChain(&attrIndexRange)); @@ -290,7 +290,7 @@ TEST(LogEventTest, TestAnnotationIdIsUid) { createIntWithBoolAnnotationLogEvent(&event, ANNOTATION_ID_IS_UID, true); const vector& 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& 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& 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& 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& 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& values = event.getValues(); - EXPECT_EQ(values.size(), 1); + ASSERT_EQ(values.size(), 1); EXPECT_EQ(event.getResetState(), resetState); } diff --git a/cmds/statsd/tests/MetricsManager_test.cpp b/cmds/statsd/tests/MetricsManager_test.cpp index a44541dddf538..3890fbe7dc6ff 100644 --- a/cmds/statsd/tests/MetricsManager_test.cpp +++ b/cmds/statsd/tests/MetricsManager_test.cpp @@ -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); } diff --git a/cmds/statsd/tests/StatsLogProcessor_test.cpp b/cmds/statsd/tests/StatsLogProcessor_test.cpp index e6144c52c4367..076f32752223e 100644 --- a/cmds/statsd/tests/StatsLogProcessor_test.cpp +++ b/cmds/statsd/tests/StatsLogProcessor_test.cpp @@ -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 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 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 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* 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* 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* 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* 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); diff --git a/cmds/statsd/tests/UidMap_test.cpp b/cmds/statsd/tests/UidMap_test.cpp index 29005a2070fe1..293e8ed1c44ce 100644 --- a/cmds/statsd/tests/UidMap_test.cpp +++ b/cmds/statsd/tests/UidMap_test.cpp @@ -86,7 +86,7 @@ TEST(UidMapTest, TestMatching) { EXPECT_FALSE(m.hasApp(1000, "not.app")); std::set name_set = m.getAppNamesFromUid(1000u, true /* returnNormalized */); - EXPECT_EQ(name_set.size(), 2u); + ASSERT_EQ(name_set.size(), 2u); EXPECT_TRUE(name_set.find(kApp1) != name_set.end()); EXPECT_TRUE(name_set.find(kApp2) != name_set.end()); @@ -115,7 +115,7 @@ TEST(UidMapTest, TestAddAndRemove) { m.updateMap(1, uids, versions, versionStrings, apps, installers); std::set name_set = m.getAppNamesFromUid(1000, true /* returnNormalized */); - EXPECT_EQ(name_set.size(), 2u); + ASSERT_EQ(name_set.size(), 2u); EXPECT_TRUE(name_set.find(kApp1) != name_set.end()); EXPECT_TRUE(name_set.find(kApp2) != name_set.end()); @@ -124,7 +124,7 @@ TEST(UidMapTest, TestAddAndRemove) { EXPECT_EQ(40, m.getAppVersion(1000, kApp1)); name_set = m.getAppNamesFromUid(1000, true /* returnNormalized */); - EXPECT_EQ(name_set.size(), 2u); + ASSERT_EQ(name_set.size(), 2u); EXPECT_TRUE(name_set.find(kApp1) != name_set.end()); EXPECT_TRUE(name_set.find(kApp2) != name_set.end()); @@ -132,7 +132,7 @@ TEST(UidMapTest, TestAddAndRemove) { EXPECT_FALSE(m.hasApp(1000, kApp1)); EXPECT_TRUE(m.hasApp(1000, kApp2)); name_set = m.getAppNamesFromUid(1000, true /* returnNormalized */); - EXPECT_EQ(name_set.size(), 1u); + ASSERT_EQ(name_set.size(), 1u); EXPECT_TRUE(name_set.find(kApp1) == name_set.end()); EXPECT_TRUE(name_set.find(kApp2) != name_set.end()); @@ -149,14 +149,14 @@ TEST(UidMapTest, TestUpdateApp) { m.updateMap(1, {1000, 1000}, {4, 5}, {String16("v4"), String16("v5")}, {String16(kApp1.c_str()), String16(kApp2.c_str())}, {String16(""), String16("")}); std::set name_set = m.getAppNamesFromUid(1000, true /* returnNormalized */); - EXPECT_EQ(name_set.size(), 2u); + ASSERT_EQ(name_set.size(), 2u); EXPECT_TRUE(name_set.find(kApp1) != name_set.end()); EXPECT_TRUE(name_set.find(kApp2) != name_set.end()); // Adds a new name for uid 1000. m.updateApp(2, String16("NeW_aPP1_NAmE"), 1000, 40, String16("v40"), String16("")); name_set = m.getAppNamesFromUid(1000, true /* returnNormalized */); - EXPECT_EQ(name_set.size(), 3u); + ASSERT_EQ(name_set.size(), 3u); EXPECT_TRUE(name_set.find(kApp1) != name_set.end()); EXPECT_TRUE(name_set.find(kApp2) != name_set.end()); EXPECT_TRUE(name_set.find("NeW_aPP1_NAmE") == name_set.end()); @@ -165,7 +165,7 @@ TEST(UidMapTest, TestUpdateApp) { // This name is also reused by another uid 2000. m.updateApp(3, String16("NeW_aPP1_NAmE"), 2000, 1, String16("v1"), String16("")); name_set = m.getAppNamesFromUid(2000, true /* returnNormalized */); - EXPECT_EQ(name_set.size(), 1u); + ASSERT_EQ(name_set.size(), 1u); EXPECT_TRUE(name_set.find("NeW_aPP1_NAmE") == name_set.end()); EXPECT_TRUE(name_set.find("new_app1_name") != name_set.end()); } @@ -212,7 +212,7 @@ TEST(UidMapTest, TestOutputIncludesAtLeastOneSnapshot) { // Check there's still a uidmap attached this one. UidMapping results; protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(1, results.snapshots_size()); + ASSERT_EQ(1, results.snapshots_size()); EXPECT_EQ("v1", results.snapshots(0).package_info(0).version_string()); } @@ -240,7 +240,7 @@ TEST(UidMapTest, TestRemovedAppRetained) { // Snapshot should still contain this item as deleted. UidMapping results; protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(1, results.snapshots(0).package_info_size()); + ASSERT_EQ(1, results.snapshots(0).package_info_size()); EXPECT_EQ(true, results.snapshots(0).package_info(0).deleted()); } @@ -269,7 +269,7 @@ TEST(UidMapTest, TestRemovedAppOverGuardrail) { ProtoOutputStream proto; m.appendUidMap(3, config1, nullptr, true, true, &proto); protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(maxDeletedApps + 10, results.snapshots(0).package_info_size()); + ASSERT_EQ(maxDeletedApps + 10, results.snapshots(0).package_info_size()); // Now remove all the apps. m.updateMap(1, uids, versions, versionStrings, apps, installers); @@ -281,7 +281,7 @@ TEST(UidMapTest, TestRemovedAppOverGuardrail) { m.appendUidMap(5, config1, nullptr, true, true, &proto); // Snapshot drops the first nine items. protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(maxDeletedApps, results.snapshots(0).package_info_size()); + ASSERT_EQ(maxDeletedApps, results.snapshots(0).package_info_size()); } TEST(UidMapTest, TestClearingOutput) { @@ -313,44 +313,44 @@ TEST(UidMapTest, TestClearingOutput) { m.appendUidMap(2, config1, nullptr, true, true, &proto); UidMapping results; protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(1, results.snapshots_size()); + ASSERT_EQ(1, results.snapshots_size()); // We have to keep at least one snapshot in memory at all times. proto.clear(); m.appendUidMap(2, config1, nullptr, true, true, &proto); protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(1, results.snapshots_size()); + ASSERT_EQ(1, results.snapshots_size()); // Now add another configuration. m.OnConfigUpdated(config2); m.updateApp(5, String16(kApp1.c_str()), 1000, 40, String16("v40"), String16("")); - EXPECT_EQ(1U, m.mChanges.size()); + ASSERT_EQ(1U, m.mChanges.size()); proto.clear(); m.appendUidMap(6, config1, nullptr, true, true, &proto); protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(1, results.snapshots_size()); - EXPECT_EQ(1, results.changes_size()); - EXPECT_EQ(1U, m.mChanges.size()); + ASSERT_EQ(1, results.snapshots_size()); + ASSERT_EQ(1, results.changes_size()); + ASSERT_EQ(1U, m.mChanges.size()); // Add another delta update. m.updateApp(7, String16(kApp2.c_str()), 1001, 41, String16("v41"), String16("")); - EXPECT_EQ(2U, m.mChanges.size()); + ASSERT_EQ(2U, m.mChanges.size()); // We still can't remove anything. proto.clear(); m.appendUidMap(8, config1, nullptr, true, true, &proto); protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(1, results.snapshots_size()); - EXPECT_EQ(1, results.changes_size()); - EXPECT_EQ(2U, m.mChanges.size()); + ASSERT_EQ(1, results.snapshots_size()); + ASSERT_EQ(1, results.changes_size()); + ASSERT_EQ(2U, m.mChanges.size()); proto.clear(); m.appendUidMap(9, config2, nullptr, true, true, &proto); protoOutputStreamToUidMapping(&proto, &results); - EXPECT_EQ(1, results.snapshots_size()); - EXPECT_EQ(2, results.changes_size()); + ASSERT_EQ(1, results.snapshots_size()); + ASSERT_EQ(2, results.changes_size()); // At this point both should be cleared. - EXPECT_EQ(0U, m.mChanges.size()); + ASSERT_EQ(0U, m.mChanges.size()); } TEST(UidMapTest, TestMemoryComputed) { @@ -408,13 +408,13 @@ TEST(UidMapTest, TestMemoryGuardrail) { m.updateApp(3, String16("EXTREMELY_LONG_STRING_FOR_APP_TO_WASTE_MEMORY.0"), 1000, 2, String16("v2"), String16("")); - EXPECT_EQ(1U, m.mChanges.size()); + ASSERT_EQ(1U, m.mChanges.size()); // Now force deletion by limiting the memory to hold one delta change. m.maxBytesOverride = 120; // Since the app string alone requires >45 characters. m.updateApp(5, String16("EXTREMELY_LONG_STRING_FOR_APP_TO_WASTE_MEMORY.0"), 1000, 4, String16("v4"), String16("")); - EXPECT_EQ(1U, m.mChanges.size()); + ASSERT_EQ(1U, m.mChanges.size()); } #else diff --git a/cmds/statsd/tests/anomaly/AlarmTracker_test.cpp b/cmds/statsd/tests/anomaly/AlarmTracker_test.cpp index 90ffcd009efde..322cfaf68a41a 100644 --- a/cmds/statsd/tests/anomaly/AlarmTracker_test.cpp +++ b/cmds/statsd/tests/anomaly/AlarmTracker_test.cpp @@ -56,7 +56,7 @@ TEST(AlarmTrackerTest, TestTriggerTimestamp) { currentTimeSec = startMillis / MS_PER_SEC + 7000; firedAlarmSet = subscriberAlarmMonitor->popSoonerThan(static_cast(currentTimeSec)); - EXPECT_EQ(firedAlarmSet.size(), 1u); + ASSERT_EQ(firedAlarmSet.size(), 1u); tracker.informAlarmsFired(currentTimeSec * NS_PER_SEC, firedAlarmSet); EXPECT_TRUE(firedAlarmSet.empty()); EXPECT_EQ(tracker.mAlarmSec, (int64_t)(startMillis / MS_PER_SEC + 15 + 2 * 60 * 60)); diff --git a/cmds/statsd/tests/anomaly/AnomalyTracker_test.cpp b/cmds/statsd/tests/anomaly/AnomalyTracker_test.cpp index 6bde79f52e33c..0cc8af16c782d 100644 --- a/cmds/statsd/tests/anomaly/AnomalyTracker_test.cpp +++ b/cmds/statsd/tests/anomaly/AnomalyTracker_test.cpp @@ -149,7 +149,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { std::shared_ptr bucket6 = MockBucket({{keyA, 2}}); // Start time with no events. - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0u); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0u); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, -1LL); // Event from bucket #0 occurs. @@ -160,7 +160,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds past bucket #0 anomalyTracker.addPastBucket(bucket0, 0); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3u); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3u); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); @@ -174,7 +174,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds past bucket #0 again. The sum does not change. anomalyTracker.addPastBucket(bucket0, 0); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3u); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3u); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); @@ -187,7 +187,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds past bucket #1. anomalyTracker.addPastBucket(bucket1, 1); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 1L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); @@ -201,7 +201,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds past bucket #1 again. Nothing changes. anomalyTracker.addPastBucket(bucket1, 1); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 1L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); @@ -214,7 +214,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds past bucket #2. anomalyTracker.addPastBucket(bucket2, 2); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 2L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL); @@ -227,7 +227,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds bucket #3. anomalyTracker.addPastBucket(bucket3, 3L); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 3L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL); @@ -240,7 +240,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds bucket #4. anomalyTracker.addPastBucket(bucket4, 4); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 4L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 5LL); @@ -253,7 +253,7 @@ TEST(AnomalyTrackerTest, TestConsecutiveBuckets) { // Adds bucket #5. anomalyTracker.addPastBucket(bucket5, 5); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 5L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 5LL); @@ -294,7 +294,7 @@ TEST(AnomalyTrackerTest, TestSparseBuckets) { int64_t eventTimestamp6 = bucketSizeNs * 27 + 3; EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, -1LL); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 9, bucket9, {}, {keyA, keyB, keyC, keyD})); detectAndDeclareAnomalies(anomalyTracker, 9, bucket9, eventTimestamp1); checkRefractoryTimes(anomalyTracker, eventTimestamp1, refractoryPeriodSec, @@ -303,15 +303,15 @@ TEST(AnomalyTrackerTest, TestSparseBuckets) { // Add past bucket #9 anomalyTracker.addPastBucket(bucket9, 9); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 9L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 16, bucket16, {keyB}, {keyA, keyC, keyD})); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 15L); detectAndDeclareAnomalies(anomalyTracker, 16, bucket16, eventTimestamp2); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 15L); checkRefractoryTimes(anomalyTracker, eventTimestamp2, refractoryPeriodSec, {{keyA, -1}, {keyB, eventTimestamp2}, {keyC, -1}, {keyD, -1}, {keyE, -1}}); @@ -319,27 +319,27 @@ TEST(AnomalyTrackerTest, TestSparseBuckets) { // Add past bucket #16 anomalyTracker.addPastBucket(bucket16, 16); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 16L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 4LL); EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 18, bucket18, {keyB}, {keyA, keyC, keyD})); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 4LL); // Within refractory period. detectAndDeclareAnomalies(anomalyTracker, 18, bucket18, eventTimestamp3); checkRefractoryTimes(anomalyTracker, eventTimestamp3, refractoryPeriodSec, {{keyA, -1}, {keyB, eventTimestamp2}, {keyC, -1}, {keyD, -1}, {keyE, -1}}); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 4LL); // Add past bucket #18 anomalyTracker.addPastBucket(bucket18, 18); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 18L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 20, bucket20, {keyB}, {keyA, keyC, keyD})); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 19L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); detectAndDeclareAnomalies(anomalyTracker, 20, bucket20, eventTimestamp4); @@ -349,11 +349,11 @@ TEST(AnomalyTrackerTest, TestSparseBuckets) { // Add bucket #18 again. Nothing changes. anomalyTracker.addPastBucket(bucket18, 18); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 19L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 20, bucket20, {keyB}, {keyA, keyC, keyD})); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); detectAndDeclareAnomalies(anomalyTracker, 20, bucket20, eventTimestamp4 + 1); @@ -364,12 +364,12 @@ TEST(AnomalyTrackerTest, TestSparseBuckets) { // Add past bucket #20 anomalyTracker.addPastBucket(bucket20, 20); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 20L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 3LL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL); EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 25, bucket25, {}, {keyA, keyB, keyC, keyD})); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 24L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); detectAndDeclareAnomalies(anomalyTracker, 25, bucket25, eventTimestamp5); checkRefractoryTimes(anomalyTracker, eventTimestamp5, refractoryPeriodSec, {{keyA, -1}, {keyB, eventTimestamp4}, {keyC, -1}, {keyD, -1}, {keyE, -1}}); @@ -377,14 +377,14 @@ TEST(AnomalyTrackerTest, TestSparseBuckets) { // Add past bucket #25 anomalyTracker.addPastBucket(bucket25, 25); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 25L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL); EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyD), 1LL); EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 28, bucket28, {}, {keyA, keyB, keyC, keyD, keyE})); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 27L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); detectAndDeclareAnomalies(anomalyTracker, 28, bucket28, eventTimestamp6); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); checkRefractoryTimes(anomalyTracker, eventTimestamp6, refractoryPeriodSec, {{keyA, -1}, {keyB, -1}, {keyC, -1}, {keyD, -1}, {keyE, -1}}); @@ -393,9 +393,9 @@ TEST(AnomalyTrackerTest, TestSparseBuckets) { EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 28, bucket28, {keyE}, {keyA, keyB, keyC, keyD})); EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 27L); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); detectAndDeclareAnomalies(anomalyTracker, 28, bucket28, eventTimestamp6 + 7); - EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); + ASSERT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL); checkRefractoryTimes(anomalyTracker, eventTimestamp6, refractoryPeriodSec, {{keyA, -1}, {keyB, -1}, {keyC, -1}, {keyD, -1}, {keyE, eventTimestamp6 + 7}}); } diff --git a/cmds/statsd/tests/condition/SimpleConditionTracker_test.cpp b/cmds/statsd/tests/condition/SimpleConditionTracker_test.cpp index ba5b032b80d0e..86e24fb0c80b2 100644 --- a/cmds/statsd/tests/condition/SimpleConditionTracker_test.cpp +++ b/cmds/statsd/tests/condition/SimpleConditionTracker_test.cpp @@ -306,13 +306,13 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) { changedCache); if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); } else { - EXPECT_EQ(uids.size(), conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(uids.size(), conditionTracker.mSlicedConditionState.size()); } EXPECT_TRUE(changedCache[0]); if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(conditionTracker.getChangedToTrueDimensions(allConditions)->size(), 1u); + ASSERT_EQ(conditionTracker.getChangedToTrueDimensions(allConditions)->size(), 1u); EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); } else { EXPECT_EQ(conditionTracker.getChangedToTrueDimensions(allConditions)->size(), @@ -338,9 +338,9 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) { changedCache); EXPECT_FALSE(changedCache[0]); if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); } else { - EXPECT_EQ(uids.size(), conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(uids.size(), conditionTracker.mSlicedConditionState.size()); } EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty()); EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); @@ -359,9 +359,9 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) { // nothing changes, because wake lock 2 is still held for this uid EXPECT_FALSE(changedCache[0]); if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); } else { - EXPECT_EQ(uids.size(), conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(uids.size(), conditionTracker.mSlicedConditionState.size()); } EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty()); EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); @@ -375,10 +375,10 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) { changedCache[0] = false; conditionTracker.evaluateCondition(event4, matcherState, allPredicates, conditionCache, changedCache); - EXPECT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); EXPECT_TRUE(changedCache[0]); if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(conditionTracker.getChangedToFalseDimensions(allConditions)->size(), 1u); + ASSERT_EQ(conditionTracker.getChangedToFalseDimensions(allConditions)->size(), 1u); EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty()); } else { EXPECT_EQ(conditionTracker.getChangedToFalseDimensions(allConditions)->size(), @@ -432,7 +432,7 @@ TEST(SimpleConditionTrackerTest, TestSlicedWithNoOutputDim) { conditionTracker.evaluateCondition(event1, matcherState, allPredicates, conditionCache, changedCache); - EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); EXPECT_TRUE(changedCache[0]); // Now test query @@ -480,7 +480,7 @@ TEST(SimpleConditionTrackerTest, TestSlicedWithNoOutputDim) { changedCache[0] = false; conditionTracker.evaluateCondition(event4, matcherState, allPredicates, conditionCache, changedCache); - EXPECT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); EXPECT_TRUE(changedCache[0]); // query again @@ -524,14 +524,14 @@ TEST(SimpleConditionTrackerTest, TestStopAll) { conditionTracker.evaluateCondition(event1, matcherState, allPredicates, conditionCache, changedCache); if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); } else { - EXPECT_EQ(uids1.size(), conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(uids1.size(), conditionTracker.mSlicedConditionState.size()); } EXPECT_TRUE(changedCache[0]); { if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size()); + ASSERT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size()); EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); } else { EXPECT_EQ(uids1.size(), @@ -560,14 +560,14 @@ TEST(SimpleConditionTrackerTest, TestStopAll) { conditionTracker.evaluateCondition(event2, matcherState, allPredicates, conditionCache, changedCache); if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(2UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(2UL, conditionTracker.mSlicedConditionState.size()); } else { - EXPECT_EQ(uids1.size() + uids2.size(), conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(uids1.size() + uids2.size(), conditionTracker.mSlicedConditionState.size()); } EXPECT_TRUE(changedCache[0]); { if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size()); + ASSERT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size()); EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); } else { EXPECT_EQ(uids2.size(), @@ -597,10 +597,10 @@ TEST(SimpleConditionTrackerTest, TestStopAll) { conditionTracker.evaluateCondition(event3, matcherState, allPredicates, conditionCache, changedCache); EXPECT_TRUE(changedCache[0]); - EXPECT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); + ASSERT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); { if (position == Position::FIRST || position == Position::LAST) { - EXPECT_EQ(2UL, conditionTracker.getChangedToFalseDimensions(allConditions)->size()); + ASSERT_EQ(2UL, conditionTracker.getChangedToFalseDimensions(allConditions)->size()); EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty()); } else { EXPECT_EQ(uids1.size() + uids2.size(), diff --git a/cmds/statsd/tests/e2e/Alarm_e2e_test.cpp b/cmds/statsd/tests/e2e/Alarm_e2e_test.cpp index 9ea0b81092090..93b278388a1b5 100644 --- a/cmds/statsd/tests/e2e/Alarm_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/Alarm_e2e_test.cpp @@ -52,9 +52,9 @@ TEST(AlarmE2eTest, TestMultipleAlarms) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(2u, processor->mMetricsManagers.begin()->second->mAllPeriodicAlarmTrackers.size()); + ASSERT_EQ(2u, processor->mMetricsManagers.begin()->second->mAllPeriodicAlarmTrackers.size()); auto alarmTracker1 = processor->mMetricsManagers.begin()->second->mAllPeriodicAlarmTrackers[0]; auto alarmTracker2 = processor->mMetricsManagers.begin()->second->mAllPeriodicAlarmTrackers[1]; @@ -68,7 +68,7 @@ TEST(AlarmE2eTest, TestMultipleAlarms) { const int64_t alarmFiredTimestampSec0 = alarmTimestampSec1 + 5; auto alarmSet = processor->getPeriodicAlarmMonitor()->popSoonerThan( static_cast(alarmFiredTimestampSec0)); - EXPECT_EQ(1u, alarmSet.size()); + ASSERT_EQ(1u, alarmSet.size()); processor->onPeriodicAlarmFired(alarmFiredTimestampSec0 * NS_PER_SEC, alarmSet); EXPECT_EQ(alarmTimestampSec0, alarmTracker1->getAlarmTimestampSec()); EXPECT_EQ(alarmTimestampSec1 + 30 * 60, alarmTracker2->getAlarmTimestampSec()); @@ -77,7 +77,7 @@ TEST(AlarmE2eTest, TestMultipleAlarms) { const int64_t alarmFiredTimestampSec1 = alarmTimestampSec0 + 2 * 60 * 60 + 125; alarmSet = processor->getPeriodicAlarmMonitor()->popSoonerThan( static_cast(alarmFiredTimestampSec1)); - EXPECT_EQ(2u, alarmSet.size()); + ASSERT_EQ(2u, alarmSet.size()); processor->onPeriodicAlarmFired(alarmFiredTimestampSec1 * NS_PER_SEC, alarmSet); EXPECT_EQ(alarmTimestampSec0 + 60 * 60 * 3, alarmTracker1->getAlarmTimestampSec()); EXPECT_EQ(alarmTimestampSec1 + 30 * 60 * 5, alarmTracker2->getAlarmTimestampSec()); diff --git a/cmds/statsd/tests/e2e/Anomaly_count_e2e_test.cpp b/cmds/statsd/tests/e2e/Anomaly_count_e2e_test.cpp index c2d70430afdf7..af9436b98ec84 100644 --- a/cmds/statsd/tests/e2e/Anomaly_count_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/Anomaly_count_e2e_test.cpp @@ -66,9 +66,9 @@ TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_single_bucket) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp anomalyTracker = processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; @@ -183,9 +183,9 @@ TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_multiple_buckets) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp anomalyTracker = processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; @@ -254,16 +254,16 @@ TEST(AnomalyDetectionE2eTest, TestCountMetric_save_refractory_to_disk_no_data_wr int64_t configId = 1000; ConfigKey cfgKey(configUid, configId); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); metadata::StatsMetadataList result; int64_t mockWallClockNs = 1584991200 * NS_PER_SEC; int64_t mockElapsedTimeNs = bucketStartTimeNs + 5000 * NS_PER_SEC; processor->WriteMetadataToProto(mockWallClockNs, mockElapsedTimeNs, &result); - EXPECT_EQ(result.stats_metadata_size(), 0); + ASSERT_EQ(result.stats_metadata_size(), 0); } TEST(AnomalyDetectionE2eTest, TestCountMetric_save_refractory_to_disk) { @@ -279,9 +279,9 @@ TEST(AnomalyDetectionE2eTest, TestCountMetric_save_refractory_to_disk) { int64_t configId = 1000; ConfigKey cfgKey(configUid, configId); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp anomalyTracker = processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; @@ -308,15 +308,15 @@ TEST(AnomalyDetectionE2eTest, TestCountMetric_save_refractory_to_disk) { processor->WriteMetadataToProto(mockWallClockNs, mockElapsedTimeNs, &result); metadata::StatsMetadata statsMetadata = result.stats_metadata(0); - EXPECT_EQ(result.stats_metadata_size(), 1); + ASSERT_EQ(result.stats_metadata_size(), 1); EXPECT_EQ(statsMetadata.config_key().config_id(), configId); EXPECT_EQ(statsMetadata.config_key().uid(), configUid); metadata::AlertMetadata alertMetadata = statsMetadata.alert_metadata(0); - EXPECT_EQ(statsMetadata.alert_metadata_size(), 1); + ASSERT_EQ(statsMetadata.alert_metadata_size(), 1); EXPECT_EQ(alertMetadata.alert_id(), alert_id); metadata::AlertDimensionKeyedData keyedData = alertMetadata.alert_dim_keyed_data(0); - EXPECT_EQ(alertMetadata.alert_dim_keyed_data_size(), 1); + ASSERT_EQ(alertMetadata.alert_dim_keyed_data_size(), 1); EXPECT_EQ(keyedData.last_refractory_ends_sec(), anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1) - mockElapsedTimeNs / NS_PER_SEC + @@ -342,9 +342,9 @@ TEST(AnomalyDetectionE2eTest, TestCountMetric_load_refractory_from_disk) { int64_t configId = 1000; ConfigKey cfgKey(configUid, configId); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp anomalyTracker = processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; diff --git a/cmds/statsd/tests/e2e/Anomaly_duration_sum_e2e_test.cpp b/cmds/statsd/tests/e2e/Anomaly_duration_sum_e2e_test.cpp index 4f9f3153e404d..95e301002a1b8 100644 --- a/cmds/statsd/tests/e2e/Anomaly_duration_sum_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/Anomaly_duration_sum_e2e_test.cpp @@ -104,9 +104,9 @@ TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_single_bucket) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp anomalyTracker = processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; @@ -162,7 +162,7 @@ TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_single_bucket) { // Anomaly alarm fired. auto alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan( static_cast(alarmFiredTimestampSec0)); - EXPECT_EQ(1u, alarmSet.size()); + ASSERT_EQ(1u, alarmSet.size()); processor->onAnomalyAlarmFired(alarmFiredTimestampSec0 * NS_PER_SEC, alarmSet); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1)); EXPECT_EQ(refractory_period_sec + alarmFiredTimestampSec0, @@ -199,7 +199,7 @@ TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_single_bucket) { alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan( static_cast(alarmFiredTimestampSec1)); - EXPECT_EQ(0u, alarmSet.size()); + ASSERT_EQ(0u, alarmSet.size()); // Acquire wakelock wl1 near the end of bucket #0. acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 2, @@ -285,9 +285,9 @@ TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_multiple_buckets) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp anomalyTracker = processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; @@ -406,9 +406,9 @@ TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_long_refractory_period) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); - EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); + ASSERT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp anomalyTracker = processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; @@ -439,7 +439,7 @@ TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_long_refractory_period) { const int64_t firedAlarmTimestampNs = bucketStartTimeNs + 2 * bucketSizeNs - NS_PER_SEC; auto alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan( static_cast(firedAlarmTimestampNs / NS_PER_SEC)); - EXPECT_EQ(1u, alarmSet.size()); + ASSERT_EQ(1u, alarmSet.size()); processor->onAnomalyAlarmFired(firedAlarmTimestampNs, alarmSet); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1)); EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC, diff --git a/cmds/statsd/tests/e2e/Attribution_e2e_test.cpp b/cmds/statsd/tests/e2e/Attribution_e2e_test.cpp index 52229e2c85579..4c2caa904f6ab 100644 --- a/cmds/statsd/tests/e2e/Attribution_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/Attribution_e2e_test.cpp @@ -101,7 +101,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByFirstUid) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); // Here it assumes that GMS core has two uids. @@ -155,17 +155,17 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByFirstUid) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); + ASSERT_EQ(reports.reports_size(), 1); + ASSERT_EQ(reports.reports(0).metrics_size(), 1); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(countMetrics.data_size(), 4); + ASSERT_EQ(countMetrics.data_size(), 4); auto data = countMetrics.data(0); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), util::WAKELOCK_STATE_CHANGED, 111, "App1"); - EXPECT_EQ(data.bucket_info_size(), 2); + ASSERT_EQ(data.bucket_info_size(), 2); EXPECT_EQ(data.bucket_info(0).count(), 2); EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs); EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs); @@ -178,7 +178,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByFirstUid) { ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1"); - EXPECT_EQ(data.bucket_info_size(), 2); + ASSERT_EQ(data.bucket_info_size(), 2); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs); EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs); @@ -190,7 +190,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByFirstUid) { ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule3"); - EXPECT_EQ(data.bucket_info_size(), 1); + ASSERT_EQ(data.bucket_info_size(), 1); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs + 3 * bucketSizeNs); @@ -200,7 +200,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByFirstUid) { ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), util::WAKELOCK_STATE_CHANGED, 444, "GMSCoreModule2"); - EXPECT_EQ(data.bucket_info_size(), 1); + ASSERT_EQ(data.bucket_info_size(), 1); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs + 2 * bucketSizeNs); @@ -214,7 +214,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); // Here it assumes that GMS core has two uids. @@ -268,18 +268,18 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); + ASSERT_EQ(reports.reports_size(), 1); + ASSERT_EQ(reports.reports(0).metrics_size(), 1); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(countMetrics.data_size(), 6); + ASSERT_EQ(countMetrics.data_size(), 6); auto data = countMetrics.data(0); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1"); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -296,7 +296,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { ValidateUidDimension(data.dimensions_in_what(), 1, util::WAKELOCK_STATE_CHANGED, 333); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 1, util::WAKELOCK_STATE_CHANGED, 333, "App3"); - EXPECT_EQ(data.bucket_info_size(), 1); + ASSERT_EQ(data.bucket_info_size(), 1); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs); EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs); @@ -310,7 +310,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 1, util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1"); - EXPECT_EQ(data.bucket_info_size(), 1); + ASSERT_EQ(data.bucket_info_size(), 1); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -327,7 +327,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { ValidateUidDimension(data.dimensions_in_what(), 2, util::WAKELOCK_STATE_CHANGED, 333); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 2, util::WAKELOCK_STATE_CHANGED, 333, "App3"); - EXPECT_EQ(data.bucket_info_size(), 1); + ASSERT_EQ(data.bucket_info_size(), 1); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -343,7 +343,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 2, util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1"); - EXPECT_EQ(data.bucket_info_size(), 1); + ASSERT_EQ(data.bucket_info_size(), 1); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -359,7 +359,7 @@ TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { ValidateUidDimension(data.dimensions_in_what(), 2, util::WAKELOCK_STATE_CHANGED, 333); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 2, util::WAKELOCK_STATE_CHANGED, 333, "App3"); - EXPECT_EQ(data.bucket_info_size(), 1); + ASSERT_EQ(data.bucket_info_size(), 1); EXPECT_EQ(data.bucket_info(0).count(), 1); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); diff --git a/cmds/statsd/tests/e2e/ConfigTtl_e2e_test.cpp b/cmds/statsd/tests/e2e/ConfigTtl_e2e_test.cpp index 16adbddf7dec4..0bce0baa049bc 100644 --- a/cmds/statsd/tests/e2e/ConfigTtl_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/ConfigTtl_e2e_test.cpp @@ -68,7 +68,7 @@ TEST(ConfigTtlE2eTest, TestCountMetric) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); std::vector attributionUids1 = {111}; diff --git a/cmds/statsd/tests/e2e/CountMetric_e2e_test.cpp b/cmds/statsd/tests/e2e/CountMetric_e2e_test.cpp index b1461a1535ba1..1a7cd5584f3de 100644 --- a/cmds/statsd/tests/e2e/CountMetric_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/CountMetric_e2e_test.cpp @@ -65,14 +65,14 @@ TEST(CountMetricE2eTest, TestSlicedState) { auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); // Check that CountMetricProducer was initialized correctly. - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 0); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0); // Check that StateTrackers were initialized correctly. EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount()); @@ -132,23 +132,23 @@ TEST(CountMetricE2eTest, TestSlicedState) { ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs * 2 + 1, false, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_count_metrics()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(3, countMetrics.data_size()); + ASSERT_EQ(3, countMetrics.data_size()); // For each CountMetricData, check StateValue info is correct and buckets // have correct counts. auto data = countMetrics.data(0); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_UNKNOWN, @@ -157,7 +157,7 @@ TEST(CountMetricE2eTest, TestSlicedState) { EXPECT_EQ(1, data.bucket_info(0).count()); data = countMetrics.data(1); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, data.slice_by_state(0).value()); @@ -166,7 +166,7 @@ TEST(CountMetricE2eTest, TestSlicedState) { EXPECT_EQ(2, data.bucket_info(1).count()); data = countMetrics.data(2); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, data.slice_by_state(0).value()); @@ -220,14 +220,14 @@ TEST(CountMetricE2eTest, TestSlicedStateWithMap) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(SCREEN_STATE_ATOM_ID)); // Check that CountMetricProducer was initialized correctly. - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 1); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 1); StateMap map = state.map(); for (auto group : map.group()) { @@ -316,44 +316,44 @@ TEST(CountMetricE2eTest, TestSlicedStateWithMap) { ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs * 2 + 1, false, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_count_metrics()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(3, countMetrics.data_size()); + ASSERT_EQ(3, countMetrics.data_size()); // For each CountMetricData, check StateValue info is correct and buckets // have correct counts. auto data = countMetrics.data(0); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(-1 /* StateTracker::kStateUnknown */, data.slice_by_state(0).value()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); data = countMetrics.data(1); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOnId, data.slice_by_state(0).group_id()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(1, data.bucket_info(1).count()); data = countMetrics.data(2); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOffId, data.slice_by_state(0).group_id()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(4, data.bucket_info(0).count()); EXPECT_EQ(2, data.bucket_info(1).count()); } @@ -405,15 +405,15 @@ TEST(CountMetricE2eTest, TestSlicedStateWithPrimaryFields) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(UID_PROCESS_STATE_ATOM_ID)); // Check that CountMetricProducer was initialized correctly. - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), UID_PROCESS_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 0); - EXPECT_EQ(metricProducer->mMetric2StateLinks.size(), 1); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0); + ASSERT_EQ(metricProducer->mMetric2StateLinks.size(), 1); /* NOTE: "1" or "2" represents the uid associated with the state/app crash event @@ -496,23 +496,23 @@ TEST(CountMetricE2eTest, TestSlicedStateWithPrimaryFields) { ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs * 2 + 1, false, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_count_metrics()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(5, countMetrics.data_size()); + ASSERT_EQ(5, countMetrics.data_size()); // For each CountMetricData, check StateValue info is correct and buckets // have correct counts. auto data = countMetrics.data(0); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(-1 /* StateTracker::kStateUnknown */, data.slice_by_state(0).value()); @@ -520,7 +520,7 @@ TEST(CountMetricE2eTest, TestSlicedStateWithPrimaryFields) { EXPECT_EQ(1, data.bucket_info(0).count()); data = countMetrics.data(1); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::PROCESS_STATE_TOP, data.slice_by_state(0).value()); @@ -528,7 +528,7 @@ TEST(CountMetricE2eTest, TestSlicedStateWithPrimaryFields) { EXPECT_EQ(2, data.bucket_info(0).count()); data = countMetrics.data(2); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::PROCESS_STATE_FOREGROUND_SERVICE, data.slice_by_state(0).value()); @@ -537,7 +537,7 @@ TEST(CountMetricE2eTest, TestSlicedStateWithPrimaryFields) { EXPECT_EQ(2, data.bucket_info(1).count()); data = countMetrics.data(3); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::PROCESS_STATE_IMPORTANT_FOREGROUND, data.slice_by_state(0).value()); @@ -545,7 +545,7 @@ TEST(CountMetricE2eTest, TestSlicedStateWithPrimaryFields) { EXPECT_EQ(2, data.bucket_info(0).count()); data = countMetrics.data(4); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::PROCESS_STATE_IMPORTANT_BACKGROUND, data.slice_by_state(0).value()); @@ -600,16 +600,16 @@ TEST(CountMetricE2eTest, TestMultipleSlicedStates) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(UID_PROCESS_STATE_ATOM_ID)); // Check that CountMetricProducer was initialized correctly. - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 2); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 2); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(1), UID_PROCESS_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 1); - EXPECT_EQ(metricProducer->mMetric2StateLinks.size(), 1); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 1); + ASSERT_EQ(metricProducer->mMetric2StateLinks.size(), 1); StateMap map = state1.map(); for (auto group : map.group()) { @@ -726,23 +726,23 @@ TEST(CountMetricE2eTest, TestMultipleSlicedStates) { ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs * 2 + 1, false, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_count_metrics()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(6, countMetrics.data_size()); + ASSERT_EQ(6, countMetrics.data_size()); // For each CountMetricData, check StateValue info is correct and buckets // have correct counts. auto data = countMetrics.data(0); - EXPECT_EQ(2, data.slice_by_state_size()); + ASSERT_EQ(2, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(-1, data.slice_by_state(0).value()); @@ -753,7 +753,7 @@ TEST(CountMetricE2eTest, TestMultipleSlicedStates) { EXPECT_EQ(1, data.bucket_info(0).count()); data = countMetrics.data(1); - EXPECT_EQ(2, data.slice_by_state_size()); + ASSERT_EQ(2, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOnId, data.slice_by_state(0).group_id()); @@ -764,7 +764,7 @@ TEST(CountMetricE2eTest, TestMultipleSlicedStates) { EXPECT_EQ(1, data.bucket_info(0).count()); data = countMetrics.data(2); - EXPECT_EQ(2, data.slice_by_state_size()); + ASSERT_EQ(2, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOnId, data.slice_by_state(0).group_id()); @@ -775,7 +775,7 @@ TEST(CountMetricE2eTest, TestMultipleSlicedStates) { EXPECT_EQ(1, data.bucket_info(0).count()); data = countMetrics.data(3); - EXPECT_EQ(2, data.slice_by_state_size()); + ASSERT_EQ(2, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOffId, data.slice_by_state(0).group_id()); @@ -786,7 +786,7 @@ TEST(CountMetricE2eTest, TestMultipleSlicedStates) { EXPECT_EQ(2, data.bucket_info(0).count()); data = countMetrics.data(4); - EXPECT_EQ(2, data.slice_by_state_size()); + ASSERT_EQ(2, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOffId, data.slice_by_state(0).group_id()); @@ -797,7 +797,7 @@ TEST(CountMetricE2eTest, TestMultipleSlicedStates) { EXPECT_EQ(1, data.bucket_info(0).count()); data = countMetrics.data(5); - EXPECT_EQ(2, data.slice_by_state_size()); + ASSERT_EQ(2, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOffId, data.slice_by_state(0).group_id()); diff --git a/cmds/statsd/tests/e2e/DurationMetric_e2e_test.cpp b/cmds/statsd/tests/e2e/DurationMetric_e2e_test.cpp index d59ec3ef4a29a..4efb038e538d5 100644 --- a/cmds/statsd/tests/e2e/DurationMetric_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/DurationMetric_e2e_test.cpp @@ -57,10 +57,10 @@ TEST(DurationMetricE2eTest, TestOneBucket) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); @@ -93,18 +93,18 @@ TEST(DurationMetricE2eTest, TestOneBucket) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id()); EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(1, durationMetrics.data_size()); + ASSERT_EQ(1, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(durationEndNs - durationStartNs, data.bucket_info(0).duration_nanos()); EXPECT_EQ(configAddedTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -140,10 +140,10 @@ TEST(DurationMetricE2eTest, TestTwoBuckets) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); @@ -176,18 +176,18 @@ TEST(DurationMetricE2eTest, TestTwoBuckets) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id()); EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(1, durationMetrics.data_size()); + ASSERT_EQ(1, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); auto bucketInfo = data.bucket_info(0); EXPECT_EQ(0, bucketInfo.bucket_num()); @@ -253,16 +253,16 @@ TEST(DurationMetricE2eTest, TestWithActivation) { processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config); // 0:00 - EXPECT_EQ(processor.mMetricsManagers.size(), 1u); + ASSERT_EQ(processor.mMetricsManagers.size(), 1u); sp metricsManager = processor.mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; EXPECT_FALSE(metricsManager->isActive()); EXPECT_FALSE(metricProducer->mIsActive); - EXPECT_EQ(eventActivationMap.size(), 1u); + ASSERT_EQ(eventActivationMap.size(), 1u); EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->start_ns, 0); @@ -289,7 +289,7 @@ TEST(DurationMetricE2eTest, TestWithActivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 1); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[2]->start_ns, activationStartNs); @@ -302,8 +302,8 @@ TEST(DurationMetricE2eTest, TestWithActivation) { EXPECT_FALSE(metricsManager->isActive()); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 2); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); - EXPECT_EQ(eventActivationMap.size(), 1u); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(eventActivationMap.size(), 1u); EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->start_ns, activationStartNs); @@ -333,7 +333,7 @@ TEST(DurationMetricE2eTest, TestWithActivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[2]->start_ns, activation2StartNs); @@ -347,18 +347,18 @@ TEST(DurationMetricE2eTest, TestWithActivation) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id()); EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(1, durationMetrics.data_size()); + ASSERT_EQ(1, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); auto bucketInfo = data.bucket_info(0); EXPECT_EQ(0, bucketInfo.bucket_num()); @@ -393,10 +393,10 @@ TEST(DurationMetricE2eTest, TestWithCondition) { uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; EXPECT_TRUE(metricsManager->isActive()); @@ -428,23 +428,23 @@ TEST(DurationMetricE2eTest, TestWithCondition) { ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs + 1, false, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(1, durationMetrics.data_size()); + ASSERT_EQ(1, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); // Validate bucket info. - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); auto bucketInfo = data.bucket_info(0); EXPECT_EQ(bucketStartTimeNs, bucketInfo.start_bucket_elapsed_nanos()); @@ -497,10 +497,10 @@ TEST(DurationMetricE2eTest, TestWithSlicedCondition) { uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; EXPECT_TRUE(metricsManager->isActive()); @@ -530,25 +530,25 @@ TEST(DurationMetricE2eTest, TestWithSlicedCondition) { ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs + 1, false, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(1, durationMetrics.data_size()); + ASSERT_EQ(1, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); // Validate dimension value. ValidateAttributionUidDimension(data.dimensions_in_what(), util::WAKELOCK_STATE_CHANGED, appUid); // Validate bucket info. - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); auto bucketInfo = data.bucket_info(0); EXPECT_EQ(bucketStartTimeNs, bucketInfo.start_bucket_elapsed_nanos()); @@ -608,15 +608,15 @@ TEST(DurationMetricE2eTest, TestWithActivationAndSlicedCondition) { uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; EXPECT_FALSE(metricsManager->isActive()); EXPECT_FALSE(metricProducer->mIsActive); - EXPECT_EQ(eventActivationMap.size(), 1u); + ASSERT_EQ(eventActivationMap.size(), 1u); EXPECT_TRUE(eventActivationMap.find(4) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[4]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[4]->start_ns, 0); @@ -691,25 +691,25 @@ TEST(DurationMetricE2eTest, TestWithActivationAndSlicedCondition) { ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs + 1, false, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(1, durationMetrics.data_size()); + ASSERT_EQ(1, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); // Validate dimension value. ValidateAttributionUidDimension(data.dimensions_in_what(), util::WAKELOCK_STATE_CHANGED, appUid); // Validate bucket info. - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); auto bucketInfo = data.bucket_info(0); EXPECT_EQ(bucketStartTimeNs, bucketInfo.start_bucket_elapsed_nanos()); @@ -753,16 +753,16 @@ TEST(DurationMetricE2eTest, TestWithSlicedState) { TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); EXPECT_TRUE(metricsManager->isActive()); sp metricProducer = metricsManager->mAllMetricProducers[0]; EXPECT_TRUE(metricProducer->mIsActive); - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 0); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0); // Check that StateTrackers were initialized correctly. EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount()); @@ -814,26 +814,26 @@ TEST(DurationMetricE2eTest, TestWithSlicedState) { processor->onDumpReport(cfgKey, bucketStartTimeNs + 360 * NS_PER_SEC, true /* include current partial bucket */, true, ADB_DUMP, FAST, &buffer); // 6:10 - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(3, durationMetrics.data_size()); + ASSERT_EQ(3, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, data.slice_by_state(0).value()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(50 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -842,11 +842,11 @@ TEST(DurationMetricE2eTest, TestWithSlicedState) { EXPECT_EQ(370 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos()); data = durationMetrics.data(1); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, data.slice_by_state(0).value()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(110 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -855,11 +855,11 @@ TEST(DurationMetricE2eTest, TestWithSlicedState) { EXPECT_EQ(370 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos()); data = durationMetrics.data(2); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_DOZE, data.slice_by_state(0).value()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(40 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -902,16 +902,16 @@ TEST(DurationMetricE2eTest, TestWithConditionAndSlicedState) { TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); EXPECT_TRUE(metricsManager->isActive()); sp metricProducer = metricsManager->mAllMetricProducers[0]; EXPECT_TRUE(metricProducer->mIsActive); - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 0); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0); // Check that StateTrackers were initialized correctly. EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount()); @@ -976,26 +976,26 @@ TEST(DurationMetricE2eTest, TestWithConditionAndSlicedState) { processor->onDumpReport(cfgKey, bucketStartTimeNs + 410 * NS_PER_SEC, true /* include current partial bucket */, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(3, durationMetrics.data_size()); + ASSERT_EQ(3, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, data.slice_by_state(0).value()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(45 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -1004,11 +1004,11 @@ TEST(DurationMetricE2eTest, TestWithConditionAndSlicedState) { EXPECT_EQ(420 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos()); data = durationMetrics.data(1); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, data.slice_by_state(0).value()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(45 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -1017,11 +1017,11 @@ TEST(DurationMetricE2eTest, TestWithConditionAndSlicedState) { EXPECT_EQ(420 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos()); data = durationMetrics.data(2); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_DOZE, data.slice_by_state(0).value()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(30 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -1060,16 +1060,16 @@ TEST(DurationMetricE2eTest, TestWithSlicedStateMapped) { TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); EXPECT_TRUE(metricsManager->isActive()); sp metricProducer = metricsManager->mAllMetricProducers[0]; EXPECT_TRUE(metricProducer->mIsActive); - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 1); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 1); // Check that StateTrackers were initialized correctly. EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount()); @@ -1134,26 +1134,26 @@ TEST(DurationMetricE2eTest, TestWithSlicedStateMapped) { processor->onDumpReport(cfgKey, bucketStartTimeNs + 490 * NS_PER_SEC, true /* include current partial bucket */, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(2, durationMetrics.data_size()); + ASSERT_EQ(2, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOnId, data.slice_by_state(0).group_id()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(130 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -1162,11 +1162,11 @@ TEST(DurationMetricE2eTest, TestWithSlicedStateMapped) { EXPECT_EQ(500 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos()); data = durationMetrics.data(1); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOffId, data.slice_by_state(0).group_id()); - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); EXPECT_EQ(70 * NS_PER_SEC, data.bucket_info(0).duration_nanos()); EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -1216,7 +1216,7 @@ TEST(DurationMetricE2eTest, TestSlicedStatePrimaryFieldsNotSubsetDimInWhat) { // This config is rejected because the dimension in what fields are not a superset of the sliced // state primary fields. - EXPECT_EQ(processor->mMetricsManagers.size(), 0); + ASSERT_EQ(processor->mMetricsManagers.size(), 0); } TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { @@ -1261,16 +1261,16 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); EXPECT_TRUE(metricsManager->isActive()); sp metricProducer = metricsManager->mAllMetricProducers[0]; EXPECT_TRUE(metricProducer->mIsActive); - EXPECT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); + ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1); EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), UID_PROCESS_STATE_ATOM_ID); - EXPECT_EQ(metricProducer->mStateGroupMap.size(), 0); + ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0); // Check that StateTrackers were initialized correctly. EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount()); @@ -1328,24 +1328,24 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { processor->onDumpReport(cfgKey, bucketStartTimeNs + 320 * NS_PER_SEC, true /* include current partial bucket */, true, ADB_DUMP, FAST, &buffer); - EXPECT_GT(buffer.size(), 0); + ASSERT_GT(buffer.size(), 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics()); StatsLogReport::DurationMetricDataWrapper durationMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(), &durationMetrics); - EXPECT_EQ(9, durationMetrics.data_size()); + ASSERT_EQ(9, durationMetrics.data_size()); DurationMetricData data = durationMetrics.data(0); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1, "wakelock1"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND, @@ -1358,7 +1358,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(1); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1, "wakelock1"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND, @@ -1374,7 +1374,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(2); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1, "wakelock2"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND, @@ -1387,7 +1387,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(3); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1, "wakelock2"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND, @@ -1400,7 +1400,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(4); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2, "wakelock1"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(-1 /* StateTracker:: kStateUnknown */, data.slice_by_state(0).value()); @@ -1412,7 +1412,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(5); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2, "wakelock1"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND, @@ -1425,7 +1425,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(6); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2, "wakelock2"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(-1 /* StateTracker:: kStateUnknown */, data.slice_by_state(0).value()); @@ -1437,7 +1437,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(7); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2, "wakelock2"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE, @@ -1453,7 +1453,7 @@ TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) { data = durationMetrics.data(8); ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2, "wakelock2"); - EXPECT_EQ(1, data.slice_by_state_size()); + ASSERT_EQ(1, data.slice_by_state_size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND, diff --git a/cmds/statsd/tests/e2e/GaugeMetric_e2e_pull_test.cpp b/cmds/statsd/tests/e2e/GaugeMetric_e2e_pull_test.cpp index c234b14f12d0e..1be261297e0a0 100644 --- a/cmds/statsd/tests/e2e/GaugeMetric_e2e_pull_test.cpp +++ b/cmds/statsd/tests/e2e/GaugeMetric_e2e_pull_test.cpp @@ -76,7 +76,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), ATOM_TAG); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -87,7 +87,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents) { // When creating the config, the gauge metric producer should register the alarm at the // end of the current bucket. - EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); + ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& nextPullTimeNs = @@ -141,30 +141,30 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); - EXPECT_GT((int)gaugeMetrics.data_size(), 1); + ASSERT_GT((int)gaugeMetrics.data_size(), 1); auto data = gaugeMetrics.data(0); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); - EXPECT_EQ(6, data.bucket_info_size()); + ASSERT_EQ(6, data.bucket_info_size()); - EXPECT_EQ(1, data.bucket_info(0).atom_size()); - EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(0).atom_size()); + ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(1).atom_size()); + ASSERT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); @@ -172,32 +172,32 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents) { EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(2).atom_size()); - EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(2).atom_size()); + ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, data.bucket_info(2).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(3).atom_size()); - EXPECT_EQ(1, data.bucket_info(3).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(3).atom_size()); + ASSERT_EQ(1, data.bucket_info(3).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 1, data.bucket_info(3).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(3).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(3).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(4).atom_size()); - EXPECT_EQ(1, data.bucket_info(4).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(4).atom_size()); + ASSERT_EQ(1, data.bucket_info(4).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, data.bucket_info(4).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(4).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(4).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(4).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(4).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(5).atom_size()); - EXPECT_EQ(1, data.bucket_info(5).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(5).atom_size()); + ASSERT_EQ(1, data.bucket_info(5).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs + 2, data.bucket_info(5).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(5).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(5).end_bucket_elapsed_nanos()); @@ -215,7 +215,7 @@ TEST(GaugeMetricE2eTest, TestConditionChangeToTrueSamplePulledEvents) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), ATOM_TAG); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -259,30 +259,30 @@ TEST(GaugeMetricE2eTest, TestConditionChangeToTrueSamplePulledEvents) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); - EXPECT_GT((int)gaugeMetrics.data_size(), 1); + ASSERT_GT((int)gaugeMetrics.data_size(), 1); auto data = gaugeMetrics.data(0); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); - EXPECT_EQ(3, data.bucket_info_size()); + ASSERT_EQ(3, data.bucket_info_size()); - EXPECT_EQ(1, data.bucket_info(0).atom_size()); - EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(0).atom_size()); + ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(1).atom_size()); + ASSERT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 100, data.bucket_info(1).elapsed_timestamp_nanos(0)); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); @@ -290,8 +290,8 @@ TEST(GaugeMetricE2eTest, TestConditionChangeToTrueSamplePulledEvents) { EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(2, data.bucket_info(2).atom_size()); - EXPECT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size()); + ASSERT_EQ(2, data.bucket_info(2).atom_size()); + ASSERT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, data.bucket_info(2).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 10, data.bucket_info(2).elapsed_timestamp_nanos(1)); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); @@ -312,7 +312,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), ATOM_TAG); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -323,7 +323,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm) { // When creating the config, the gauge metric producer should register the alarm at the // end of the current bucket. - EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); + ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& nextPullTimeNs = @@ -359,29 +359,29 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); - EXPECT_GT((int)gaugeMetrics.data_size(), 1); + ASSERT_GT((int)gaugeMetrics.data_size(), 1); auto data = gaugeMetrics.data(0); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); - EXPECT_EQ(3, data.bucket_info_size()); + ASSERT_EQ(3, data.bucket_info_size()); - EXPECT_EQ(1, data.bucket_info(0).atom_size()); - EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(0).atom_size()); + ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(1).atom_size()); + ASSERT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_EQ(configAddedTimeNs + 3 * bucketSizeNs + 11, data.bucket_info(1).elapsed_timestamp_nanos(0)); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); @@ -390,8 +390,8 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm) { EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(2).atom_size()); - EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(2).atom_size()); + ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs + 12, data.bucket_info(2).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos()); @@ -420,7 +420,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsWithActivation) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), ATOM_TAG); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -432,7 +432,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsWithActivation) { // When creating the config, the gauge metric producer should register the alarm at the // end of the current bucket. - EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); + ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& nextPullTimeNs = @@ -479,45 +479,45 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsWithActivation) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); - EXPECT_GT((int)gaugeMetrics.data_size(), 0); + ASSERT_GT((int)gaugeMetrics.data_size(), 0); auto data = gaugeMetrics.data(0); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); - EXPECT_EQ(3, data.bucket_info_size()); + ASSERT_EQ(3, data.bucket_info_size()); auto bucketInfo = data.bucket_info(0); - EXPECT_EQ(1, bucketInfo.atom_size()); - EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, bucketInfo.atom_size()); + ASSERT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size()); EXPECT_EQ(activationNs, bucketInfo.elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos()); EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0); bucketInfo = data.bucket_info(1); - EXPECT_EQ(1, bucketInfo.atom_size()); - EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, bucketInfo.atom_size()); + ASSERT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, bucketInfo.elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos()); EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0); bucketInfo = data.bucket_info(2); - EXPECT_EQ(1, bucketInfo.atom_size()); - EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, bucketInfo.atom_size()); + ASSERT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 2, bucketInfo.elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); EXPECT_EQ(MillisToNano(NanoToMillis(baseTimeNs + 5 * bucketSizeNs)), bucketInfo.start_bucket_elapsed_nanos()); EXPECT_EQ(MillisToNano(NanoToMillis(activationNs + ttlNs + 1)), @@ -538,7 +538,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsNoCondition) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), ATOM_TAG); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -548,7 +548,7 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsNoCondition) { // When creating the config, the gauge metric producer should register the alarm at the // end of the current bucket. - EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); + ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& nextPullTimeNs = @@ -572,43 +572,43 @@ TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsNoCondition) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; sortMetricDataByDimensionsValue( reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); - EXPECT_GT((int)gaugeMetrics.data_size(), 0); + ASSERT_GT((int)gaugeMetrics.data_size(), 0); auto data = gaugeMetrics.data(0); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); - EXPECT_EQ(3, data.bucket_info_size()); + ASSERT_EQ(3, data.bucket_info_size()); - EXPECT_EQ(1, data.bucket_info(0).atom_size()); - EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(0).atom_size()); + ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(configAddedTimeNs, data.bucket_info(0).elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(1).atom_size()); - EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(1).atom_size()); + ASSERT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, data.bucket_info(1).wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, data.bucket_info(1).wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0); - EXPECT_EQ(1, data.bucket_info(2).atom_size()); - EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(2).atom_size()); + ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 4, data.bucket_info(2).elapsed_timestamp_nanos(0)); - EXPECT_EQ(0, data.bucket_info(2).wall_clock_timestamp_nanos_size()); + ASSERT_EQ(0, data.bucket_info(2).wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty()); diff --git a/cmds/statsd/tests/e2e/GaugeMetric_e2e_push_test.cpp b/cmds/statsd/tests/e2e/GaugeMetric_e2e_push_test.cpp index 60403f2a3e0ff..a40a9484a8414 100644 --- a/cmds/statsd/tests/e2e/GaugeMetric_e2e_push_test.cpp +++ b/cmds/statsd/tests/e2e/GaugeMetric_e2e_push_test.cpp @@ -103,7 +103,7 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); int appUid1 = 123; @@ -160,24 +160,24 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); - EXPECT_EQ(2, gaugeMetrics.data_size()); + ASSERT_EQ(2, gaugeMetrics.data_size()); auto data = gaugeMetrics.data(0); EXPECT_EQ(util::APP_START_OCCURRED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(appUid1, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(3, data.bucket_info_size()); + ASSERT_EQ(3, data.bucket_info_size()); if (sampling_type == GaugeMetric::FIRST_N_SAMPLES) { - EXPECT_EQ(2, data.bucket_info(0).atom_size()); - EXPECT_EQ(2, data.bucket_info(0).elapsed_timestamp_nanos_size()); - EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); + ASSERT_EQ(2, data.bucket_info(0).atom_size()); + ASSERT_EQ(2, data.bucket_info(0).elapsed_timestamp_nanos_size()); + ASSERT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -194,8 +194,8 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { EXPECT_EQ(103L, data.bucket_info(0).atom(1).app_start_occurred().activity_start_millis()); - EXPECT_EQ(1, data.bucket_info(1).atom_size()); - EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(1).atom_size()); + ASSERT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, @@ -207,8 +207,8 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { EXPECT_EQ(104L, data.bucket_info(1).atom(0).app_start_occurred().activity_start_millis()); - EXPECT_EQ(2, data.bucket_info(2).atom_size()); - EXPECT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size()); + ASSERT_EQ(2, data.bucket_info(2).atom_size()); + ASSERT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, @@ -226,8 +226,8 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { EXPECT_EQ(106L, data.bucket_info(2).atom(1).app_start_occurred().activity_start_millis()); } else { - EXPECT_EQ(1, data.bucket_info(0).atom_size()); - EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(0).atom_size()); + ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); @@ -238,8 +238,8 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { EXPECT_EQ(102L, data.bucket_info(0).atom(0).app_start_occurred().activity_start_millis()); - EXPECT_EQ(1, data.bucket_info(1).atom_size()); - EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(1).atom_size()); + ASSERT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, @@ -251,8 +251,8 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { EXPECT_EQ(104L, data.bucket_info(1).atom(0).app_start_occurred().activity_start_millis()); - EXPECT_EQ(1, data.bucket_info(2).atom_size()); - EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info(2).atom_size()); + ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, @@ -268,13 +268,13 @@ TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { data = gaugeMetrics.data(1); EXPECT_EQ(data.dimensions_in_what().field(), util::APP_START_OCCURRED); - EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); + ASSERT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(appUid2, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); - EXPECT_EQ(1, data.bucket_info(0).atom_size()); - EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); + ASSERT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info(0).atom_size()); + ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, diff --git a/cmds/statsd/tests/e2e/MetricActivation_e2e_test.cpp b/cmds/statsd/tests/e2e/MetricActivation_e2e_test.cpp index ba8d283cabe1e..e320419a9d444 100644 --- a/cmds/statsd/tests/e2e/MetricActivation_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/MetricActivation_e2e_test.cpp @@ -267,10 +267,10 @@ TEST(MetricActivationE2eTest, TestCountMetric) { processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config); - EXPECT_EQ(processor.mMetricsManagers.size(), 1u); + ASSERT_EQ(processor.mMetricsManagers.size(), 1u); sp metricsManager = processor.mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; @@ -278,7 +278,7 @@ TEST(MetricActivationE2eTest, TestCountMetric) { 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). - EXPECT_EQ(eventActivationMap.size(), 2u); + ASSERT_EQ(eventActivationMap.size(), 2u); EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end()); EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); @@ -302,7 +302,7 @@ TEST(MetricActivationE2eTest, TestCountMetric) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 1); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); @@ -353,7 +353,7 @@ TEST(MetricActivationE2eTest, TestCountMetric) { EXPECT_FALSE(metricProducer->mIsActive); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 2); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -368,7 +368,7 @@ TEST(MetricActivationE2eTest, TestCountMetric) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); @@ -389,42 +389,42 @@ TEST(MetricActivationE2eTest, TestCountMetric) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(4, countMetrics.data_size()); + ASSERT_EQ(4, countMetrics.data_size()); auto data = countMetrics.data(0); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(1); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(2); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); // Partial bucket as metric is deactivated. EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -433,11 +433,11 @@ TEST(MetricActivationE2eTest, TestCountMetric) { data = countMetrics.data(3); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -478,10 +478,10 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config); - EXPECT_EQ(processor.mMetricsManagers.size(), 1u); + ASSERT_EQ(processor.mMetricsManagers.size(), 1u); sp metricsManager = processor.mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; auto& eventDeactivationMap = metricProducer->mEventDeactivationMap; @@ -490,7 +490,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { 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). - EXPECT_EQ(eventActivationMap.size(), 2u); + ASSERT_EQ(eventActivationMap.size(), 2u); EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end()); EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); @@ -499,9 +499,9 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->start_ns, 0); EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC); - EXPECT_EQ(eventDeactivationMap.size(), 1u); + ASSERT_EQ(eventDeactivationMap.size(), 1u); EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end()); - EXPECT_EQ(eventDeactivationMap[3].size(), 1u); + ASSERT_EQ(eventDeactivationMap[3].size(), 1u); EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]); std::unique_ptr event; @@ -518,7 +518,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 1); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); @@ -572,7 +572,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_FALSE(metricProducer->mIsActive); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 2); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -588,7 +588,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); @@ -608,7 +608,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); @@ -628,7 +628,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); @@ -645,7 +645,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_FALSE(metricProducer->mIsActive); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 4); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -663,7 +663,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 5); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15); @@ -679,7 +679,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_FALSE(metricsManager->isActive()); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 6); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -696,42 +696,42 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(5, countMetrics.data_size()); + ASSERT_EQ(5, countMetrics.data_size()); auto data = countMetrics.data(0); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(1); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(2); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); // Partial bucket as metric is deactivated. EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -740,11 +740,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { data = countMetrics.data(3); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -753,11 +753,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) { data = countMetrics.data(4); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -799,10 +799,10 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config); - EXPECT_EQ(processor.mMetricsManagers.size(), 1u); + ASSERT_EQ(processor.mMetricsManagers.size(), 1u); sp metricsManager = processor.mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; auto& eventDeactivationMap = metricProducer->mEventDeactivationMap; @@ -811,7 +811,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { 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). - EXPECT_EQ(eventActivationMap.size(), 2u); + ASSERT_EQ(eventActivationMap.size(), 2u); EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end()); EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); @@ -820,11 +820,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->start_ns, 0); EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC); - EXPECT_EQ(eventDeactivationMap.size(), 2u); + ASSERT_EQ(eventDeactivationMap.size(), 2u); EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end()); EXPECT_TRUE(eventDeactivationMap.find(4) != eventDeactivationMap.end()); - EXPECT_EQ(eventDeactivationMap[3].size(), 1u); - EXPECT_EQ(eventDeactivationMap[4].size(), 1u); + ASSERT_EQ(eventDeactivationMap[3].size(), 1u); + ASSERT_EQ(eventDeactivationMap[4].size(), 1u); EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]); EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]); @@ -842,7 +842,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 1); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); @@ -899,7 +899,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_FALSE(metricProducer->mIsActive); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 2); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -916,7 +916,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); @@ -937,7 +937,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); @@ -959,7 +959,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_FALSE(metricProducer->mIsActive); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 4); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -975,7 +975,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_FALSE(metricsManager->isActive()); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 4); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -994,7 +994,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 5); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15); @@ -1011,7 +1011,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_FALSE(metricsManager->isActive()); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 6); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15); EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC); @@ -1029,42 +1029,42 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(5, countMetrics.data_size()); + ASSERT_EQ(5, countMetrics.data_size()); auto data = countMetrics.data(0); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(1); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(2); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); // Partial bucket as metric is deactivated. EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1073,11 +1073,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { data = countMetrics.data(3); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1086,11 +1086,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) { data = countMetrics.data(4); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1132,10 +1132,10 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config); - EXPECT_EQ(processor.mMetricsManagers.size(), 1u); + ASSERT_EQ(processor.mMetricsManagers.size(), 1u); sp metricsManager = processor.mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 1); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; auto& eventDeactivationMap = metricProducer->mEventDeactivationMap; @@ -1144,7 +1144,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { 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). - EXPECT_EQ(eventActivationMap.size(), 2u); + ASSERT_EQ(eventActivationMap.size(), 2u); EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end()); EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); @@ -1153,9 +1153,9 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->start_ns, 0); EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC); - EXPECT_EQ(eventDeactivationMap.size(), 1u); + ASSERT_EQ(eventDeactivationMap.size(), 1u); EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end()); - EXPECT_EQ(eventDeactivationMap[3].size(), 2u); + ASSERT_EQ(eventDeactivationMap[3].size(), 2u); EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]); EXPECT_EQ(eventDeactivationMap[3][1], eventActivationMap[2]); EXPECT_EQ(broadcastCount, 0); @@ -1172,7 +1172,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 1); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive); @@ -1205,7 +1205,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { EXPECT_FALSE(metricProducer->mIsActive); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 2); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); @@ -1219,7 +1219,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { EXPECT_TRUE(metricsManager->isActive()); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 15); @@ -1236,7 +1236,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { EXPECT_FALSE(metricsManager->isActive()); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(broadcastCount, 4); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); @@ -1252,42 +1252,42 @@ TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(3, countMetrics.data_size()); + ASSERT_EQ(3, countMetrics.data_size()); auto data = countMetrics.data(0); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(firstDeactivation, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(1); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(firstDeactivation, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(2); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(555, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); // Partial bucket as metric is deactivated. EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, @@ -1329,10 +1329,10 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config); - EXPECT_EQ(processor.mMetricsManagers.size(), 1u); + ASSERT_EQ(processor.mMetricsManagers.size(), 1u); sp metricsManager = processor.mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(metricsManager->mAllMetricProducers.size(), 2); + ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 2); sp metricProducer = metricsManager->mAllMetricProducers[0]; auto& eventActivationMap = metricProducer->mEventActivationMap; auto& eventDeactivationMap = metricProducer->mEventDeactivationMap; @@ -1345,7 +1345,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { EXPECT_FALSE(metricProducer2->mIsActive); // Two activations: one is triggered by battery saver mode (tracker index 0), the other is // triggered by screen on event (tracker index 2). - EXPECT_EQ(eventActivationMap.size(), 2u); + ASSERT_EQ(eventActivationMap.size(), 2u); EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end()); EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end()); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); @@ -1354,15 +1354,15 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[2]->start_ns, 0); EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC); - EXPECT_EQ(eventDeactivationMap.size(), 2u); + ASSERT_EQ(eventDeactivationMap.size(), 2u); EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end()); EXPECT_TRUE(eventDeactivationMap.find(4) != eventDeactivationMap.end()); - EXPECT_EQ(eventDeactivationMap[3].size(), 1u); - EXPECT_EQ(eventDeactivationMap[4].size(), 1u); + ASSERT_EQ(eventDeactivationMap[3].size(), 1u); + ASSERT_EQ(eventDeactivationMap[4].size(), 1u); EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]); EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]); - EXPECT_EQ(eventActivationMap2.size(), 2u); + ASSERT_EQ(eventActivationMap2.size(), 2u); EXPECT_TRUE(eventActivationMap2.find(0) != eventActivationMap2.end()); EXPECT_TRUE(eventActivationMap2.find(2) != eventActivationMap2.end()); EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kNotActive); @@ -1371,11 +1371,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap2[2]->start_ns, 0); EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC); - EXPECT_EQ(eventDeactivationMap2.size(), 2u); + ASSERT_EQ(eventDeactivationMap2.size(), 2u); EXPECT_TRUE(eventDeactivationMap2.find(3) != eventDeactivationMap2.end()); EXPECT_TRUE(eventDeactivationMap2.find(4) != eventDeactivationMap2.end()); - EXPECT_EQ(eventDeactivationMap[3].size(), 1u); - EXPECT_EQ(eventDeactivationMap[4].size(), 1u); + ASSERT_EQ(eventDeactivationMap[3].size(), 1u); + ASSERT_EQ(eventDeactivationMap[4].size(), 1u); EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]); EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]); @@ -1395,7 +1395,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { processor.OnLogEvent(event.get(), bucketStartTimeNs + 10); EXPECT_TRUE(metricsManager->isActive()); EXPECT_EQ(broadcastCount, 1); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); @@ -1487,7 +1487,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { EXPECT_FALSE(metricsManager->isActive()); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 2); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10); @@ -1513,7 +1513,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10); EXPECT_TRUE(metricsManager->isActive()); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); @@ -1545,7 +1545,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); EXPECT_TRUE(metricsManager->isActive()); EXPECT_EQ(broadcastCount, 3); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); @@ -1578,7 +1578,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { EXPECT_FALSE(metricsManager->isActive()); // New broadcast since the config is no longer active. EXPECT_EQ(broadcastCount, 4); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); @@ -1605,7 +1605,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 13); EXPECT_FALSE(metricsManager->isActive()); EXPECT_EQ(broadcastCount, 4); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15); @@ -1635,7 +1635,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15); EXPECT_TRUE(metricsManager->isActive()); EXPECT_EQ(broadcastCount, 5); - EXPECT_EQ(activeConfigsBroadcast.size(), 1); + ASSERT_EQ(activeConfigsBroadcast.size(), 1); EXPECT_EQ(activeConfigsBroadcast[0], cfgId); EXPECT_TRUE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive); @@ -1661,7 +1661,7 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 16); EXPECT_FALSE(metricsManager->isActive()); EXPECT_EQ(broadcastCount, 6); - EXPECT_EQ(activeConfigsBroadcast.size(), 0); + ASSERT_EQ(activeConfigsBroadcast.size(), 0); EXPECT_FALSE(metricProducer->mIsActive); EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive); EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15); @@ -1689,43 +1689,43 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(2, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(2, reports.reports(0).metrics_size()); StatsLogReport::CountMetricDataWrapper countMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); - EXPECT_EQ(5, countMetrics.data_size()); + ASSERT_EQ(5, countMetrics.data_size()); auto data = countMetrics.data(0); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(1); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(2); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); // Partial bucket as metric is deactivated. EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1734,11 +1734,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { data = countMetrics.data(3); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1747,11 +1747,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { data = countMetrics.data(4); EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1760,37 +1760,37 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { countMetrics.clear_data(); sortMetricDataByDimensionsValue(reports.reports(0).metrics(1).count_metrics(), &countMetrics); - EXPECT_EQ(5, countMetrics.data_size()); + ASSERT_EQ(5, countMetrics.data_size()); data = countMetrics.data(0); EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(2222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(1); EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(3333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); data = countMetrics.data(2); EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(4444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); // Partial bucket as metric is deactivated. EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1799,11 +1799,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { data = countMetrics.data(3); EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(6666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); @@ -1812,11 +1812,11 @@ TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) { data = countMetrics.data(4); EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* uid field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(7777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).count()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); diff --git a/cmds/statsd/tests/e2e/MetricConditionLink_e2e_test.cpp b/cmds/statsd/tests/e2e/MetricConditionLink_e2e_test.cpp index f0df2c692733b..5e77ee0f0b0a1 100644 --- a/cmds/statsd/tests/e2e/MetricConditionLink_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/MetricConditionLink_e2e_test.cpp @@ -107,7 +107,7 @@ TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks1) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); int appUid = 123; @@ -204,15 +204,15 @@ TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks1) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 1); + ASSERT_EQ(reports.reports_size(), 1); + ASSERT_EQ(reports.reports(0).metrics_size(), 1); + ASSERT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1); + ASSERT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(0).count(), 1); auto data = reports.reports(0).metrics(0).count_metrics().data(0); // Validate dimension value. EXPECT_EQ(data.dimensions_in_what().field(), util::PROCESS_LIFE_CYCLE_STATE_CHANGED); - EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); + ASSERT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); // Uid field. EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(), 1); EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(), appUid); @@ -226,7 +226,7 @@ TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks2) { ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); int appUid = 123; @@ -324,16 +324,16 @@ TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks2) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 2); + ASSERT_EQ(reports.reports_size(), 1); + ASSERT_EQ(reports.reports(0).metrics_size(), 1); + ASSERT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1); + ASSERT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 2); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(0).count(), 1); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(1).count(), 3); auto data = reports.reports(0).metrics(0).count_metrics().data(0); // Validate dimension value. EXPECT_EQ(data.dimensions_in_what().field(), util::PROCESS_LIFE_CYCLE_STATE_CHANGED); - EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); + ASSERT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); // Uid field. EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(), 1); EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(), appUid); diff --git a/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp b/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp index 911762339b70d..783f31c7bde8d 100644 --- a/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp @@ -127,8 +127,8 @@ TEST(PartialBucketE2eTest, TestCountMetricWithoutSplit) { ConfigMetricsReport report = GetReports(service->mProcessor, start + 3); // Expect no metrics since the bucket has not finished yet. - EXPECT_EQ(1, report.metrics_size()); - EXPECT_EQ(0, report.metrics(0).count_metrics().data_size()); + ASSERT_EQ(1, report.metrics_size()); + ASSERT_EQ(0, report.metrics(0).count_metrics().data_size()); } TEST(PartialBucketE2eTest, TestCountMetricNoSplitOnNewApp) { @@ -147,8 +147,8 @@ TEST(PartialBucketE2eTest, TestCountMetricNoSplitOnNewApp) { service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 3, 100).get()); ConfigMetricsReport report = GetReports(service->mProcessor, start + 4); - EXPECT_EQ(1, report.metrics_size()); - EXPECT_EQ(0, report.metrics(0).count_metrics().data_size()); + ASSERT_EQ(1, report.metrics_size()); + ASSERT_EQ(0, report.metrics(0).count_metrics().data_size()); } TEST(PartialBucketE2eTest, TestCountMetricSplitOnUpgrade) { @@ -267,8 +267,8 @@ TEST(PartialBucketE2eTest, TestValueMetricWithoutMinPartialBucket) { GetReports(service->mProcessor, 5 * 60 * NS_PER_SEC + start + 100 * NS_PER_SEC); backfillStartEndTimestamp(&report); - EXPECT_EQ(1, report.metrics_size()); - EXPECT_EQ(0, report.metrics(0).value_metrics().skipped_size()); + ASSERT_EQ(1, report.metrics_size()); + ASSERT_EQ(0, report.metrics(0).value_metrics().skipped_size()); // The fake subsystem state sleep puller returns two atoms. ASSERT_EQ(2, report.metrics(0).value_metrics().data_size()); @@ -305,7 +305,7 @@ TEST(PartialBucketE2eTest, TestValueMetricWithMinPartialBucket) { report.metrics(0).value_metrics().skipped(0).end_bucket_elapsed_nanos()); ASSERT_EQ(2, report.metrics(0).value_metrics().data_size()); - EXPECT_EQ(1, report.metrics(0).value_metrics().data(0).bucket_info_size()); + ASSERT_EQ(1, report.metrics(0).value_metrics().data(0).bucket_info_size()); } TEST(PartialBucketE2eTest, TestValueMetricOnBootWithoutMinPartialBucket) { @@ -329,7 +329,7 @@ TEST(PartialBucketE2eTest, TestValueMetricOnBootWithoutMinPartialBucket) { // First bucket is dropped due to the initial pull failing ASSERT_EQ(1, report.metrics_size()); - EXPECT_EQ(1, report.metrics(0).value_metrics().skipped_size()); + ASSERT_EQ(1, report.metrics(0).value_metrics().skipped_size()); EXPECT_EQ(MillisToNano(NanoToMillis(bootCompleteTimeNs)), report.metrics(0).value_metrics().skipped(0).end_bucket_elapsed_nanos()); @@ -359,10 +359,10 @@ TEST(PartialBucketE2eTest, TestGaugeMetricWithoutMinPartialBucket) { ConfigMetricsReport report = GetReports(service->mProcessor, 5 * 60 * NS_PER_SEC + start + 100); backfillStartEndTimestamp(&report); ASSERT_EQ(1, report.metrics_size()); - EXPECT_EQ(0, report.metrics(0).gauge_metrics().skipped_size()); + ASSERT_EQ(0, report.metrics(0).gauge_metrics().skipped_size()); // The fake subsystem state sleep puller returns two atoms. ASSERT_EQ(2, report.metrics(0).gauge_metrics().data_size()); - EXPECT_EQ(2, report.metrics(0).gauge_metrics().data(0).bucket_info_size()); + ASSERT_EQ(2, report.metrics(0).gauge_metrics().data(0).bucket_info_size()); } TEST(PartialBucketE2eTest, TestGaugeMetricWithMinPartialBucket) { @@ -391,7 +391,7 @@ TEST(PartialBucketE2eTest, TestGaugeMetricWithMinPartialBucket) { EXPECT_EQ(MillisToNano(NanoToMillis(endSkipped)), report.metrics(0).gauge_metrics().skipped(0).end_bucket_elapsed_nanos()); ASSERT_EQ(2, report.metrics(0).gauge_metrics().data_size()); - EXPECT_EQ(1, report.metrics(0).gauge_metrics().data(0).bucket_info_size()); + ASSERT_EQ(1, report.metrics(0).gauge_metrics().data(0).bucket_info_size()); } TEST(PartialBucketE2eTest, TestGaugeMetricOnBootWithoutMinPartialBucket) { @@ -414,7 +414,7 @@ TEST(PartialBucketE2eTest, TestGaugeMetricOnBootWithoutMinPartialBucket) { backfillStartEndTimestamp(&report); ASSERT_EQ(1, report.metrics_size()); - EXPECT_EQ(0, report.metrics(0).gauge_metrics().skipped_size()); + ASSERT_EQ(0, report.metrics(0).gauge_metrics().skipped_size()); // The fake subsystem state sleep puller returns two atoms. ASSERT_EQ(2, report.metrics(0).gauge_metrics().data_size()); // No data in the first bucket, so nothing is reported diff --git a/cmds/statsd/tests/e2e/ValueMetric_pull_e2e_test.cpp b/cmds/statsd/tests/e2e/ValueMetric_pull_e2e_test.cpp index 0c4a7c69c8e75..e595f290ffdfd 100644 --- a/cmds/statsd/tests/e2e/ValueMetric_pull_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/ValueMetric_pull_e2e_test.cpp @@ -75,7 +75,7 @@ TEST(ValueMetricE2eTest, TestPulledEvents) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), util::SUBSYSTEM_SLEEP_STATE); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -86,7 +86,7 @@ TEST(ValueMetricE2eTest, TestPulledEvents) { // When creating the config, the value metric producer should register the alarm at the // end of the current bucket. - EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); + ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& expectedPullTimeNs = @@ -136,36 +136,36 @@ TEST(ValueMetricE2eTest, TestPulledEvents) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::ValueMetricDataWrapper valueMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).value_metrics(), &valueMetrics); - EXPECT_GT((int)valueMetrics.data_size(), 1); + ASSERT_GT((int)valueMetrics.data_size(), 1); auto data = valueMetrics.data(0); EXPECT_EQ(util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); // We have 4 buckets, the first one was incomplete since the condition was unknown. - EXPECT_EQ(4, data.bucket_info_size()); + ASSERT_EQ(4, data.bucket_info_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); - EXPECT_EQ(1, data.bucket_info(0).values_size()); + ASSERT_EQ(1, data.bucket_info(0).values_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos()); - EXPECT_EQ(1, data.bucket_info(1).values_size()); + ASSERT_EQ(1, data.bucket_info(1).values_size()); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos()); - EXPECT_EQ(1, data.bucket_info(2).values_size()); + ASSERT_EQ(1, data.bucket_info(2).values_size()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos()); - EXPECT_EQ(1, data.bucket_info(3).values_size()); + ASSERT_EQ(1, data.bucket_info(3).values_size()); } TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm) { @@ -179,7 +179,7 @@ TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), util::SUBSYSTEM_SLEEP_STATE); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -190,7 +190,7 @@ TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm) { // When creating the config, the value metric producer should register the alarm at the // end of the current bucket. - EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); + ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& expectedPullTimeNs = @@ -244,31 +244,31 @@ TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::ValueMetricDataWrapper valueMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).value_metrics(), &valueMetrics); - EXPECT_GT((int)valueMetrics.data_size(), 1); + ASSERT_GT((int)valueMetrics.data_size(), 1); auto data = valueMetrics.data(0); EXPECT_EQ(util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); - EXPECT_EQ(3, data.bucket_info_size()); + ASSERT_EQ(3, data.bucket_info_size()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); - EXPECT_EQ(1, data.bucket_info(0).values_size()); + ASSERT_EQ(1, data.bucket_info(0).values_size()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos()); - EXPECT_EQ(1, data.bucket_info(1).values_size()); + ASSERT_EQ(1, data.bucket_info(1).values_size()); EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 10 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos()); - EXPECT_EQ(1, data.bucket_info(2).values_size()); + ASSERT_EQ(1, data.bucket_info(2).values_size()); } TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation) { @@ -291,7 +291,7 @@ TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation) { auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make(), util::SUBSYSTEM_SLEEP_STATE); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->ForceClearPullerCache(); @@ -303,7 +303,7 @@ TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation) { // When creating the config, the value metric producer should register the alarm at the // end of the current bucket. - EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); + ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& expectedPullTimeNs = @@ -347,30 +347,30 @@ TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation) { backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(1, reports.reports_size()); - EXPECT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(1, reports.reports_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::ValueMetricDataWrapper valueMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).value_metrics(), &valueMetrics); - EXPECT_GT((int)valueMetrics.data_size(), 0); + ASSERT_GT((int)valueMetrics.data_size(), 0); auto data = valueMetrics.data(0); EXPECT_EQ(util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field()); - EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); + ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1 /* subsystem name field */, data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); // We have 2 full buckets, the two surrounding the activation are dropped. - EXPECT_EQ(2, data.bucket_info_size()); + ASSERT_EQ(2, data.bucket_info_size()); auto bucketInfo = data.bucket_info(0); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos()); - EXPECT_EQ(1, bucketInfo.values_size()); + ASSERT_EQ(1, bucketInfo.values_size()); bucketInfo = data.bucket_info(1); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos()); - EXPECT_EQ(1, bucketInfo.values_size()); + ASSERT_EQ(1, bucketInfo.values_size()); } /** @@ -416,14 +416,14 @@ TEST(ValueMetricE2eTest, TestInitWithSlicedState) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(SCREEN_STATE_ATOM_ID)); // Check that ValueMetricProducer was initialized correctly. - EXPECT_EQ(1U, processor->mMetricsManagers.size()); + ASSERT_EQ(1U, processor->mMetricsManagers.size()); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(1, metricsManager->mAllMetricProducers.size()); + ASSERT_EQ(1, metricsManager->mAllMetricProducers.size()); sp metricProducer = metricsManager->mAllMetricProducers[0]; - EXPECT_EQ(1, metricProducer->mSlicedStateAtoms.size()); + ASSERT_EQ(1, metricProducer->mSlicedStateAtoms.size()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, metricProducer->mSlicedStateAtoms.at(0)); - EXPECT_EQ(0, metricProducer->mStateGroupMap.size()); + ASSERT_EQ(0, metricProducer->mStateGroupMap.size()); } /** @@ -476,14 +476,14 @@ TEST(ValueMetricE2eTest, TestInitWithSlicedState_WithDimensions) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(UID_PROCESS_STATE_ATOM_ID)); // Check that ValueMetricProducer was initialized correctly. - EXPECT_EQ(1U, processor->mMetricsManagers.size()); + ASSERT_EQ(1U, processor->mMetricsManagers.size()); sp metricsManager = processor->mMetricsManagers.begin()->second; EXPECT_TRUE(metricsManager->isConfigValid()); - EXPECT_EQ(1, metricsManager->mAllMetricProducers.size()); + ASSERT_EQ(1, metricsManager->mAllMetricProducers.size()); sp metricProducer = metricsManager->mAllMetricProducers[0]; - EXPECT_EQ(1, metricProducer->mSlicedStateAtoms.size()); + ASSERT_EQ(1, metricProducer->mSlicedStateAtoms.size()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, metricProducer->mSlicedStateAtoms.at(0)); - EXPECT_EQ(0, metricProducer->mStateGroupMap.size()); + ASSERT_EQ(0, metricProducer->mStateGroupMap.size()); } /** @@ -532,7 +532,7 @@ TEST(ValueMetricE2eTest, TestInitWithSlicedState_WithIncorrectDimensions) { EXPECT_EQ(0, StateManager::getInstance().getStateTrackersCount()); // Config initialization fails. - EXPECT_EQ(0, processor->mMetricsManagers.size()); + ASSERT_EQ(0, processor->mMetricsManagers.size()); } #else diff --git a/cmds/statsd/tests/e2e/WakelockDuration_e2e_test.cpp b/cmds/statsd/tests/e2e/WakelockDuration_e2e_test.cpp index 80f3c28e46f09..52bc222e5fe22 100644 --- a/cmds/statsd/tests/e2e/WakelockDuration_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/WakelockDuration_e2e_test.cpp @@ -121,7 +121,7 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration1) uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor); vector buffer; @@ -134,17 +134,17 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration1) backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); + 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. - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); + 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. - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1); + 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. @@ -158,7 +158,7 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration2) uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor); vector buffer; @@ -170,11 +170,11 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration2) backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); + 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. - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2); + 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(), @@ -196,7 +196,7 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration3) uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor); vector buffer; @@ -222,10 +222,10 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration3) backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 6); + 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); @@ -243,7 +243,7 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration1) uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor); ConfigMetricsReportList reports; @@ -257,13 +257,13 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration1) backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); + 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. - EXPECT_EQ(1, reports.reports(0).metrics_size()); - EXPECT_EQ(0, reports.reports(0).metrics(0).duration_metrics().data_size()); + ASSERT_EQ(1, reports.reports(0).metrics_size()); + ASSERT_EQ(0, reports.reports(0).metrics(0).duration_metrics().data_size()); } TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration2) { @@ -273,7 +273,7 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration2) uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor); ConfigMetricsReportList reports; @@ -285,11 +285,11 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration2) backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); + 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. - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1); + 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(), @@ -305,7 +305,7 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration3) uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); - EXPECT_EQ(processor->mMetricsManagers.size(), 1u); + ASSERT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor); ConfigMetricsReportList reports; @@ -331,10 +331,10 @@ TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration3) backfillDimensionPath(&reports); backfillStringInReport(&reports); backfillStartEndTimestamp(&reports); - EXPECT_EQ(reports.reports_size(), 1); - EXPECT_EQ(reports.reports(0).metrics_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); - EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2); + 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); diff --git a/cmds/statsd/tests/external/StatsCallbackPuller_test.cpp b/cmds/statsd/tests/external/StatsCallbackPuller_test.cpp index 4b9bac127dc86..e37c72ed0ee30 100644 --- a/cmds/statsd/tests/external/StatsCallbackPuller_test.cpp +++ b/cmds/statsd/tests/external/StatsCallbackPuller_test.cpp @@ -131,11 +131,11 @@ TEST_F(StatsCallbackPullerTest, PullSuccess) { EXPECT_TRUE(puller.PullInternal(&dataHolder)); int64_t endTimeNs = getElapsedRealtimeNs(); - EXPECT_EQ(1, dataHolder.size()); + ASSERT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_LT(startTimeNs, dataHolder[0]->GetElapsedTimestampNs()); EXPECT_GT(endTimeNs, dataHolder[0]->GetElapsedTimestampNs()); - EXPECT_EQ(1, dataHolder[0]->size()); + ASSERT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(value, dataHolder[0]->getValues()[0].mValue.int_value); } @@ -149,7 +149,7 @@ TEST_F(StatsCallbackPullerTest, PullFail) { vector> dataHolder; EXPECT_FALSE(puller.PullInternal(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } TEST_F(StatsCallbackPullerTest, PullTimeout) { @@ -173,11 +173,11 @@ TEST_F(StatsCallbackPullerTest, PullTimeout) { // is bigger. EXPECT_LT(pullTimeoutNs, actualPullDurationNs); EXPECT_GT(pullDelayNs, actualPullDurationNs); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); // Let the pull return and make sure that the dataHolder is not modified. pullThread.join(); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } // Register a puller and ensure that the timeout logic works. @@ -204,11 +204,11 @@ TEST_F(StatsCallbackPullerTest, RegisterAndTimeout) { // is bigger. EXPECT_LT(pullTimeoutNs, actualPullDurationNs); EXPECT_GT(pullDelayNs, actualPullDurationNs); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); // Let the pull return and make sure that the dataHolder is not modified. pullThread.join(); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } } // namespace statsd diff --git a/cmds/statsd/tests/external/StatsPuller_test.cpp b/cmds/statsd/tests/external/StatsPuller_test.cpp index 504335845cab7..02a43e4e179a9 100644 --- a/cmds/statsd/tests/external/StatsPuller_test.cpp +++ b/cmds/statsd/tests/external/StatsPuller_test.cpp @@ -93,10 +93,10 @@ TEST_F(StatsPullerTest, PullSuccess) { vector> dataHolder; EXPECT_TRUE(puller.Pull(&dataHolder)); - EXPECT_EQ(1, dataHolder.size()); + ASSERT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); - EXPECT_EQ(1, dataHolder[0]->size()); + ASSERT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value); sleep_for(std::chrono::seconds(1)); @@ -107,10 +107,10 @@ TEST_F(StatsPullerTest, PullSuccess) { pullSuccess = true; EXPECT_TRUE(puller.Pull(&dataHolder)); - EXPECT_EQ(1, dataHolder.size()); + ASSERT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(2222L, dataHolder[0]->GetElapsedTimestampNs()); - EXPECT_EQ(1, dataHolder[0]->size()); + ASSERT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(44, dataHolder[0]->getValues()[0].mValue.int_value); } @@ -121,10 +121,10 @@ TEST_F(StatsPullerTest, PullFailAfterSuccess) { vector> dataHolder; EXPECT_TRUE(puller.Pull(&dataHolder)); - EXPECT_EQ(1, dataHolder.size()); + ASSERT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); - EXPECT_EQ(1, dataHolder[0]->size()); + ASSERT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value); sleep_for(std::chrono::seconds(1)); @@ -135,12 +135,12 @@ TEST_F(StatsPullerTest, PullFailAfterSuccess) { pullSuccess = false; dataHolder.clear(); EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); pullSuccess = true; dataHolder.clear(); EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } // Test pull takes longer than timeout, 2nd pull happens shorter than cooldown @@ -152,7 +152,7 @@ TEST_F(StatsPullerTest, PullTakeTooLongAndPullFast) { vector> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); pullData.clear(); pullData.push_back(createSimpleEvent(2222L, 44)); @@ -160,7 +160,7 @@ TEST_F(StatsPullerTest, PullTakeTooLongAndPullFast) { pullSuccess = true; dataHolder.clear(); EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } TEST_F(StatsPullerTest, PullFail) { @@ -170,7 +170,7 @@ TEST_F(StatsPullerTest, PullFail) { vector> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } TEST_F(StatsPullerTest, PullTakeTooLong) { @@ -181,7 +181,7 @@ TEST_F(StatsPullerTest, PullTakeTooLong) { vector> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } TEST_F(StatsPullerTest, PullTooFast) { @@ -191,10 +191,10 @@ TEST_F(StatsPullerTest, PullTooFast) { vector> dataHolder; EXPECT_TRUE(puller.Pull(&dataHolder)); - EXPECT_EQ(1, dataHolder.size()); + ASSERT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); - EXPECT_EQ(1, dataHolder[0]->size()); + ASSERT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value); pullData.clear(); @@ -204,10 +204,10 @@ TEST_F(StatsPullerTest, PullTooFast) { dataHolder.clear(); EXPECT_TRUE(puller.Pull(&dataHolder)); - EXPECT_EQ(1, dataHolder.size()); + ASSERT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); - EXPECT_EQ(1, dataHolder[0]->size()); + ASSERT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value); } @@ -218,7 +218,7 @@ TEST_F(StatsPullerTest, PullFailsAndTooFast) { vector> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); pullData.clear(); pullData.push_back(createSimpleEvent(2222L, 44)); @@ -226,7 +226,7 @@ TEST_F(StatsPullerTest, PullFailsAndTooFast) { pullSuccess = true; EXPECT_FALSE(puller.Pull(&dataHolder)); - EXPECT_EQ(0, dataHolder.size()); + ASSERT_EQ(0, dataHolder.size()); } } // namespace statsd diff --git a/cmds/statsd/tests/guardrail/StatsdStats_test.cpp b/cmds/statsd/tests/guardrail/StatsdStats_test.cpp index 948d587069714..5cc10cd9840ce 100644 --- a/cmds/statsd/tests/guardrail/StatsdStats_test.cpp +++ b/cmds/statsd/tests/guardrail/StatsdStats_test.cpp @@ -42,7 +42,7 @@ TEST(StatsdStatsTest, TestValidConfigAdd) { StatsdStatsReport report; bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(1, report.config_stats_size()); + ASSERT_EQ(1, report.config_stats_size()); const auto& configReport = report.config_stats(0); EXPECT_EQ(0, configReport.uid()); EXPECT_EQ(12345, configReport.id()); @@ -69,7 +69,7 @@ TEST(StatsdStatsTest, TestInvalidConfigAdd) { StatsdStatsReport report; bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(1, report.config_stats_size()); + ASSERT_EQ(1, report.config_stats_size()); const auto& configReport = report.config_stats(0); // The invalid config should be put into icebox with a deletion time. EXPECT_TRUE(configReport.has_deletion_time_sec()); @@ -89,7 +89,7 @@ TEST(StatsdStatsTest, TestConfigRemove) { StatsdStatsReport report; bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(1, report.config_stats_size()); + ASSERT_EQ(1, report.config_stats_size()); const auto& configReport = report.config_stats(0); EXPECT_FALSE(configReport.has_deletion_time_sec()); @@ -97,7 +97,7 @@ TEST(StatsdStatsTest, TestConfigRemove) { stats.dumpStats(&output, false); good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(1, report.config_stats_size()); + ASSERT_EQ(1, report.config_stats_size()); const auto& configReport2 = report.config_stats(0); EXPECT_TRUE(configReport2.has_deletion_time_sec()); } @@ -145,21 +145,21 @@ TEST(StatsdStatsTest, TestSubStats) { StatsdStatsReport report; bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(1, report.config_stats_size()); + ASSERT_EQ(1, report.config_stats_size()); const auto& configReport = report.config_stats(0); - EXPECT_EQ(2, configReport.broadcast_sent_time_sec_size()); - EXPECT_EQ(1, configReport.data_drop_time_sec_size()); - EXPECT_EQ(1, configReport.data_drop_bytes_size()); + ASSERT_EQ(2, configReport.broadcast_sent_time_sec_size()); + ASSERT_EQ(1, configReport.data_drop_time_sec_size()); + ASSERT_EQ(1, configReport.data_drop_bytes_size()); EXPECT_EQ(123, configReport.data_drop_bytes(0)); - EXPECT_EQ(3, configReport.dump_report_time_sec_size()); - EXPECT_EQ(3, configReport.dump_report_data_size_size()); - EXPECT_EQ(2, configReport.activation_time_sec_size()); - EXPECT_EQ(1, configReport.deactivation_time_sec_size()); - EXPECT_EQ(1, configReport.annotation_size()); + ASSERT_EQ(3, configReport.dump_report_time_sec_size()); + ASSERT_EQ(3, configReport.dump_report_data_size_size()); + ASSERT_EQ(2, configReport.activation_time_sec_size()); + ASSERT_EQ(1, configReport.deactivation_time_sec_size()); + ASSERT_EQ(1, configReport.annotation_size()); EXPECT_EQ(123, configReport.annotation(0).field_int64()); EXPECT_EQ(456, configReport.annotation(0).field_int32()); - EXPECT_EQ(2, configReport.matcher_stats_size()); + ASSERT_EQ(2, configReport.matcher_stats_size()); // matcher1 is the first in the list if (configReport.matcher_stats(0).id() == StringToId("matcher1")) { EXPECT_EQ(2, configReport.matcher_stats(0).matched_times()); @@ -174,18 +174,18 @@ TEST(StatsdStatsTest, TestSubStats) { EXPECT_EQ(StringToId("matcher1"), configReport.matcher_stats(1).id()); } - EXPECT_EQ(2, configReport.alert_stats_size()); + ASSERT_EQ(2, configReport.alert_stats_size()); bool alert1first = configReport.alert_stats(0).id() == StringToId("alert1"); EXPECT_EQ(StringToId("alert1"), configReport.alert_stats(alert1first ? 0 : 1).id()); EXPECT_EQ(2, configReport.alert_stats(alert1first ? 0 : 1).alerted_times()); EXPECT_EQ(StringToId("alert2"), configReport.alert_stats(alert1first ? 1 : 0).id()); EXPECT_EQ(1, configReport.alert_stats(alert1first ? 1 : 0).alerted_times()); - EXPECT_EQ(1, configReport.condition_stats_size()); + ASSERT_EQ(1, configReport.condition_stats_size()); EXPECT_EQ(StringToId("condition1"), configReport.condition_stats(0).id()); EXPECT_EQ(250, configReport.condition_stats(0).max_tuple_counts()); - EXPECT_EQ(1, configReport.metric_stats_size()); + ASSERT_EQ(1, configReport.metric_stats_size()); EXPECT_EQ(StringToId("metric1"), configReport.metric_stats(0).id()); EXPECT_EQ(202, configReport.metric_stats(0).max_tuple_counts()); @@ -199,21 +199,21 @@ TEST(StatsdStatsTest, TestSubStats) { stats.dumpStats(&output, false); good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(1, report.config_stats_size()); + ASSERT_EQ(1, report.config_stats_size()); const auto& configReport2 = report.config_stats(0); - EXPECT_EQ(1, configReport2.matcher_stats_size()); + ASSERT_EQ(1, configReport2.matcher_stats_size()); EXPECT_EQ(StringToId("matcher99"), configReport2.matcher_stats(0).id()); EXPECT_EQ(1, configReport2.matcher_stats(0).matched_times()); - EXPECT_EQ(1, configReport2.condition_stats_size()); + ASSERT_EQ(1, configReport2.condition_stats_size()); EXPECT_EQ(StringToId("condition99"), configReport2.condition_stats(0).id()); EXPECT_EQ(300, configReport2.condition_stats(0).max_tuple_counts()); - EXPECT_EQ(1, configReport2.metric_stats_size()); + ASSERT_EQ(1, configReport2.metric_stats_size()); EXPECT_EQ(StringToId("metric99tion99"), configReport2.metric_stats(0).id()); EXPECT_EQ(270, configReport2.metric_stats(0).max_tuple_counts()); - EXPECT_EQ(1, configReport2.alert_stats_size()); + ASSERT_EQ(1, configReport2.alert_stats_size()); EXPECT_EQ(StringToId("alert99"), configReport2.alert_stats(0).id()); EXPECT_EQ(1, configReport2.alert_stats(0).alerted_times()); } @@ -234,7 +234,7 @@ TEST(StatsdStatsTest, TestAtomLog) { bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(2, report.atom_stats_size()); + ASSERT_EQ(2, report.atom_stats_size()); bool sensorAtomGood = false; bool dropboxAtomGood = false; @@ -267,7 +267,7 @@ TEST(StatsdStatsTest, TestNonPlatformAtomLog) { bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(2, report.atom_stats_size()); + ASSERT_EQ(2, report.atom_stats_size()); bool newAtom1Good = false; bool newAtom2Good = false; @@ -313,7 +313,7 @@ TEST(StatsdStatsTest, TestPullAtomStats) { bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(1, report.pulled_atom_stats_size()); + ASSERT_EQ(1, report.pulled_atom_stats_size()); EXPECT_EQ(util::DISK_SPACE, report.pulled_atom_stats(0).atom_id()); EXPECT_EQ(3, report.pulled_atom_stats(0).total_pull()); @@ -348,7 +348,7 @@ TEST(StatsdStatsTest, TestAtomMetricsStats) { bool good = report.ParseFromArray(&output[0], output.size()); EXPECT_TRUE(good); - EXPECT_EQ(2, report.atom_metric_stats().size()); + ASSERT_EQ(2, report.atom_metric_stats().size()); auto atomStats = report.atom_metric_stats(0); EXPECT_EQ(1000L, atomStats.metric_id()); @@ -407,11 +407,11 @@ TEST(StatsdStatsTest, TestTimestampThreshold) { const auto& configStats = stats.mConfigStats[key]; size_t maxCount = StatsdStats::kMaxTimestampCount; - EXPECT_EQ(maxCount, configStats->broadcast_sent_time_sec.size()); - EXPECT_EQ(maxCount, configStats->data_drop_time_sec.size()); - EXPECT_EQ(maxCount, configStats->dump_report_stats.size()); - EXPECT_EQ(maxCount, configStats->activation_time_sec.size()); - EXPECT_EQ(maxCount, configStats->deactivation_time_sec.size()); + ASSERT_EQ(maxCount, configStats->broadcast_sent_time_sec.size()); + ASSERT_EQ(maxCount, configStats->data_drop_time_sec.size()); + ASSERT_EQ(maxCount, configStats->dump_report_stats.size()); + ASSERT_EQ(maxCount, configStats->activation_time_sec.size()); + ASSERT_EQ(maxCount, configStats->deactivation_time_sec.size()); // the oldest timestamp is the second timestamp in history EXPECT_EQ(1, configStats->broadcast_sent_time_sec.front()); @@ -441,13 +441,13 @@ TEST(StatsdStatsTest, TestSystemServerCrash) { StatsdStatsReport report; EXPECT_TRUE(report.ParseFromArray(&output[0], output.size())); const int maxCount = StatsdStats::kMaxSystemServerRestarts; - EXPECT_EQ(maxCount, (int)report.system_restart_sec_size()); + ASSERT_EQ(maxCount, (int)report.system_restart_sec_size()); stats.noteSystemServerRestart(StatsdStats::kMaxSystemServerRestarts + 1); output.clear(); stats.dumpStats(&output, false); EXPECT_TRUE(report.ParseFromArray(&output[0], output.size())); - EXPECT_EQ(maxCount, (int)report.system_restart_sec_size()); + ASSERT_EQ(maxCount, (int)report.system_restart_sec_size()); EXPECT_EQ(StatsdStats::kMaxSystemServerRestarts + 1, report.system_restart_sec(maxCount - 1)); } @@ -468,19 +468,19 @@ TEST(StatsdStatsTest, TestActivationBroadcastGuardrailHit) { StatsdStatsReport report; EXPECT_TRUE(report.ParseFromArray(&output[0], output.size())); - EXPECT_EQ(2, report.activation_guardrail_stats_size()); + ASSERT_EQ(2, report.activation_guardrail_stats_size()); bool uid1Good = false; bool uid2Good = false; for (const auto& guardrailTimes : report.activation_guardrail_stats()) { if (uid1 == guardrailTimes.uid()) { uid1Good = true; - EXPECT_EQ(2, guardrailTimes.guardrail_met_sec_size()); + ASSERT_EQ(2, guardrailTimes.guardrail_met_sec_size()); EXPECT_EQ(10, guardrailTimes.guardrail_met_sec(0)); EXPECT_EQ(20, guardrailTimes.guardrail_met_sec(1)); } else if (uid2 == guardrailTimes.uid()) { int maxCount = StatsdStats::kMaxTimestampCount; uid2Good = true; - EXPECT_EQ(maxCount, guardrailTimes.guardrail_met_sec_size()); + ASSERT_EQ(maxCount, guardrailTimes.guardrail_met_sec_size()); for (int i = 0; i < maxCount; i++) { EXPECT_EQ(100 - maxCount + i, guardrailTimes.guardrail_met_sec(i)); } @@ -515,13 +515,13 @@ TEST(StatsdStatsTest, TestAtomErrorStats) { EXPECT_TRUE(report.ParseFromArray(&output[0], output.size())); // Check error count = numErrors for push atom - EXPECT_EQ(1, report.atom_stats_size()); + ASSERT_EQ(1, report.atom_stats_size()); const auto& pushedAtomStats = report.atom_stats(0); EXPECT_EQ(pushAtomTag, pushedAtomStats.tag()); EXPECT_EQ(numErrors, pushedAtomStats.error_count()); // Check error count = numErrors for pull atom - EXPECT_EQ(1, report.pulled_atom_stats_size()); + ASSERT_EQ(1, report.pulled_atom_stats_size()); const auto& pulledAtomStats = report.pulled_atom_stats(0); EXPECT_EQ(pullAtomTag, pulledAtomStats.atom_id()); EXPECT_EQ(numErrors, pulledAtomStats.atom_error_count()); diff --git a/cmds/statsd/tests/indexed_priority_queue_test.cpp b/cmds/statsd/tests/indexed_priority_queue_test.cpp index d6cd876e5ad53..3a654565b4aa0 100644 --- a/cmds/statsd/tests/indexed_priority_queue_test.cpp +++ b/cmds/statsd/tests/indexed_priority_queue_test.cpp @@ -44,23 +44,23 @@ TEST(indexed_priority_queue, empty_and_size) { sp aa4 = new AATest{4, emptyMetricId, emptyDimensionId}; sp aa8 = new AATest{8, emptyMetricId, emptyDimensionId}; - EXPECT_EQ(0u, ipq.size()); + ASSERT_EQ(0u, ipq.size()); EXPECT_TRUE(ipq.empty()); ipq.push(aa4); - EXPECT_EQ(1u, ipq.size()); + ASSERT_EQ(1u, ipq.size()); EXPECT_FALSE(ipq.empty()); ipq.push(aa8); - EXPECT_EQ(2u, ipq.size()); + ASSERT_EQ(2u, ipq.size()); EXPECT_FALSE(ipq.empty()); ipq.remove(aa4); - EXPECT_EQ(1u, ipq.size()); + ASSERT_EQ(1u, ipq.size()); EXPECT_FALSE(ipq.empty()); ipq.remove(aa8); - EXPECT_EQ(0u, ipq.size()); + ASSERT_EQ(0u, ipq.size()); EXPECT_TRUE(ipq.empty()); } @@ -126,17 +126,17 @@ TEST(indexed_priority_queue, push_same_aa) { sp aa4_b = new AATest{4, emptyMetricId, emptyDimensionId}; ipq.push(aa4_a); - EXPECT_EQ(1u, ipq.size()); + ASSERT_EQ(1u, ipq.size()); EXPECT_TRUE(ipq.contains(aa4_a)); EXPECT_FALSE(ipq.contains(aa4_b)); ipq.push(aa4_a); - EXPECT_EQ(1u, ipq.size()); + ASSERT_EQ(1u, ipq.size()); EXPECT_TRUE(ipq.contains(aa4_a)); EXPECT_FALSE(ipq.contains(aa4_b)); ipq.push(aa4_b); - EXPECT_EQ(2u, ipq.size()); + ASSERT_EQ(2u, ipq.size()); EXPECT_TRUE(ipq.contains(aa4_a)); EXPECT_TRUE(ipq.contains(aa4_b)); } @@ -150,7 +150,7 @@ TEST(indexed_priority_queue, remove_nonexistant) { ipq.push(aa4); ipq.remove(aa5); - EXPECT_EQ(1u, ipq.size()); + ASSERT_EQ(1u, ipq.size()); EXPECT_TRUE(ipq.contains(aa4)); EXPECT_FALSE(ipq.contains(aa5)); } @@ -164,17 +164,17 @@ TEST(indexed_priority_queue, remove_same_aa) { ipq.push(aa4_a); ipq.push(aa4_b); - EXPECT_EQ(2u, ipq.size()); + ASSERT_EQ(2u, ipq.size()); EXPECT_TRUE(ipq.contains(aa4_a)); EXPECT_TRUE(ipq.contains(aa4_b)); ipq.remove(aa4_b); - EXPECT_EQ(1u, ipq.size()); + ASSERT_EQ(1u, ipq.size()); EXPECT_TRUE(ipq.contains(aa4_a)); EXPECT_FALSE(ipq.contains(aa4_b)); ipq.remove(aa4_a); - EXPECT_EQ(0u, ipq.size()); + ASSERT_EQ(0u, ipq.size()); EXPECT_FALSE(ipq.contains(aa4_a)); EXPECT_FALSE(ipq.contains(aa4_b)); } @@ -205,22 +205,22 @@ TEST(indexed_priority_queue, pop) { ipq.push(c); ipq.push(b); ipq.push(a); - EXPECT_EQ(3u, ipq.size()); + ASSERT_EQ(3u, ipq.size()); ipq.pop(); - EXPECT_EQ(2u, ipq.size()); + ASSERT_EQ(2u, ipq.size()); EXPECT_FALSE(ipq.contains(a)); EXPECT_TRUE(ipq.contains(b)); EXPECT_TRUE(ipq.contains(c)); ipq.pop(); - EXPECT_EQ(1u, ipq.size()); + ASSERT_EQ(1u, ipq.size()); EXPECT_FALSE(ipq.contains(a)); EXPECT_FALSE(ipq.contains(b)); EXPECT_TRUE(ipq.contains(c)); ipq.pop(); - EXPECT_EQ(0u, ipq.size()); + ASSERT_EQ(0u, ipq.size()); EXPECT_FALSE(ipq.contains(a)); EXPECT_FALSE(ipq.contains(b)); EXPECT_FALSE(ipq.contains(c)); diff --git a/cmds/statsd/tests/metrics/CountMetricProducer_test.cpp b/cmds/statsd/tests/metrics/CountMetricProducer_test.cpp index 8131725cd1486..74ecaac0f9e35 100644 --- a/cmds/statsd/tests/metrics/CountMetricProducer_test.cpp +++ b/cmds/statsd/tests/metrics/CountMetricProducer_test.cpp @@ -108,15 +108,15 @@ TEST(CountMetricProducerTest, TestNonDimensionalEvents) { // Flushes at event #2. countProducer.flushIfNeededLocked(bucketStartTimeNs + 2); - EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, countProducer.mPastBuckets.size()); // Flushes. countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); - EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets.size()); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != countProducer.mPastBuckets.end()); const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(1UL, buckets.size()); + ASSERT_EQ(1UL, buckets.size()); EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs); EXPECT_EQ(2LL, buckets[0].mCount); @@ -128,10 +128,10 @@ TEST(CountMetricProducerTest, TestNonDimensionalEvents) { countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); countProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); - EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets.size()); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != countProducer.mPastBuckets.end()); - EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); const auto& bucketInfo2 = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1]; EXPECT_EQ(bucket2StartTimeNs, bucketInfo2.mBucketStartNs); EXPECT_EQ(bucket2StartTimeNs + bucketSizeNs, bucketInfo2.mBucketEndNs); @@ -139,11 +139,11 @@ TEST(CountMetricProducerTest, TestNonDimensionalEvents) { // nothing happens in bucket 3. we should not record anything for bucket 3. countProducer.flushIfNeededLocked(bucketStartTimeNs + 3 * bucketSizeNs + 1); - EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets.size()); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != countProducer.mPastBuckets.end()); const auto& buckets3 = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(2UL, buckets3.size()); + ASSERT_EQ(2UL, buckets3.size()); } TEST(CountMetricProducerTest, TestEventsWithNonSlicedCondition) { @@ -166,7 +166,7 @@ TEST(CountMetricProducerTest, TestEventsWithNonSlicedCondition) { makeLogEvent(&event1, bucketStartTimeNs + 1, /*atomId=*/1); countProducer.onMatchedLogEvent(1 /*matcher index*/, event1); - EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, countProducer.mPastBuckets.size()); countProducer.onConditionChanged(false /*new condition*/, bucketStartTimeNs + 2); @@ -174,15 +174,15 @@ TEST(CountMetricProducerTest, TestEventsWithNonSlicedCondition) { LogEvent event2(/*uid=*/0, /*pid=*/0); makeLogEvent(&event2, bucketStartTimeNs + 10, /*atomId=*/1); countProducer.onMatchedLogEvent(1 /*matcher index*/, event2); - EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, countProducer.mPastBuckets.size()); countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); - EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets.size()); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != countProducer.mPastBuckets.end()); const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(1UL, buckets.size()); + ASSERT_EQ(1UL, buckets.size()); const auto& bucketInfo = buckets[0]; EXPECT_EQ(bucketStartTimeNs, bucketInfo.mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.mBucketEndNs); @@ -229,15 +229,15 @@ TEST(CountMetricProducerTest, TestEventsWithSlicedCondition) { countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); countProducer.flushIfNeededLocked(bucketStartTimeNs + 1); - EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, countProducer.mPastBuckets.size()); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); - EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets.size()); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != countProducer.mPastBuckets.end()); const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(1UL, buckets.size()); + ASSERT_EQ(1UL, buckets.size()); const auto& bucketInfo = buckets[0]; EXPECT_EQ(bucketStartTimeNs, bucketInfo.mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.mBucketEndNs); @@ -271,7 +271,7 @@ TEST_P(CountMetricProducerTest_PartialBucket, TestSplitInCurrentBucket) { LogEvent event1(/*uid=*/0, /*pid=*/0); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId, /*uid=*/"111"); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); - EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, countProducer.mPastBuckets.size()); EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); // App upgrade or boot complete forces bucket flush. @@ -284,7 +284,7 @@ TEST_P(CountMetricProducerTest_PartialBucket, TestSplitInCurrentBucket) { countProducer.onStatsdInitCompleted(eventTimeNs); break; } - EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(bucketStartTimeNs, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs); EXPECT_EQ(eventTimeNs, @@ -299,7 +299,7 @@ TEST_P(CountMetricProducerTest_PartialBucket, TestSplitInCurrentBucket) { LogEvent event2(/*uid=*/0, /*pid=*/0); makeLogEvent(&event2, bucketStartTimeNs + 59 * NS_PER_SEC + 10, tagId, /*uid=*/"222"); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); - EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(eventTimeNs, countProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(0, countProducer.getCurrentBucketNum()); EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); @@ -308,7 +308,7 @@ TEST_P(CountMetricProducerTest_PartialBucket, TestSplitInCurrentBucket) { LogEvent event3(/*uid=*/0, /*pid=*/0); makeLogEvent(&event3, bucketStartTimeNs + 62 * NS_PER_SEC + 10, tagId, /*uid=*/"333"); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); - EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(lastEndTimeNs, countProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(1, countProducer.getCurrentBucketNum()); EXPECT_EQ(2, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); @@ -334,7 +334,7 @@ TEST_P(CountMetricProducerTest_PartialBucket, TestSplitInNextBucket) { LogEvent event1(/*uid=*/0, /*pid=*/0); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId, /*uid=*/"111"); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); - EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, countProducer.mPastBuckets.size()); // App upgrade or boot complete forces bucket flush. // Check that there's a past bucket and the bucket end is not adjusted since the upgrade @@ -347,7 +347,7 @@ TEST_P(CountMetricProducerTest_PartialBucket, TestSplitInNextBucket) { countProducer.onStatsdInitCompleted(eventTimeNs); break; } - EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(bucketStartTimeNs, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, @@ -358,13 +358,13 @@ TEST_P(CountMetricProducerTest_PartialBucket, TestSplitInNextBucket) { LogEvent event2(/*uid=*/0, /*pid=*/0); makeLogEvent(&event2, bucketStartTimeNs + 70 * NS_PER_SEC + 10, tagId, /*uid=*/"222"); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); - EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); // Third event in following bucket. LogEvent event3(/*uid=*/0, /*pid=*/0); makeLogEvent(&event3, bucketStartTimeNs + 121 * NS_PER_SEC + 10, tagId, /*uid=*/"333"); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); - EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ((int64_t)eventTimeNs, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, @@ -416,13 +416,13 @@ TEST(CountMetricProducerTest, TestAnomalyDetectionUnSliced) { countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); - EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); + ASSERT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); EXPECT_EQ(2L, countProducer.mCurrentSlicedCounter->begin()->second); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), 0U); // One event in bucket #2. No alarm as bucket #0 is trashed out. countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); - EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); + ASSERT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); EXPECT_EQ(1L, countProducer.mCurrentSlicedCounter->begin()->second); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), 0U); @@ -430,14 +430,14 @@ TEST(CountMetricProducerTest, TestAnomalyDetectionUnSliced) { countProducer.onMatchedLogEvent(1 /*log matcher index*/, event4); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event5); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event6); - EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); + ASSERT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); EXPECT_EQ(3L, countProducer.mCurrentSlicedCounter->begin()->second); // Anomaly at event 6 is within refractory period. The alarm is at event 5 timestamp not event 6 EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), std::ceil(1.0 * event5.GetElapsedTimestampNs() / NS_PER_SEC + refPeriodSec)); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event7); - EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); + ASSERT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); EXPECT_EQ(4L, countProducer.mCurrentSlicedCounter->begin()->second); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), std::ceil(1.0 * event7.GetElapsedTimestampNs() / NS_PER_SEC + refPeriodSec)); diff --git a/cmds/statsd/tests/metrics/DurationMetricProducer_test.cpp b/cmds/statsd/tests/metrics/DurationMetricProducer_test.cpp index 8ef251952db71..ddda71db4bd42 100644 --- a/cmds/statsd/tests/metrics/DurationMetricProducer_test.cpp +++ b/cmds/statsd/tests/metrics/DurationMetricProducer_test.cpp @@ -104,11 +104,11 @@ TEST(DurationMetricTrackerTest, TestNoCondition) { durationProducer.onMatchedLogEvent(1 /* start index*/, event1); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); - EXPECT_EQ(1UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, durationProducer.mPastBuckets.size()); EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != durationProducer.mPastBuckets.end()); const auto& buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(2UL, buckets.size()); + ASSERT_EQ(2UL, buckets.size()); EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs); EXPECT_EQ(bucketSizeNs - 1LL, buckets[0].mDuration); @@ -150,17 +150,17 @@ TEST(DurationMetricTrackerTest, TestNonSlicedCondition) { durationProducer.onMatchedLogEvent(1 /* start index*/, event1); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); - EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets.size()); durationProducer.onMatchedLogEvent(1 /* start index*/, event3); durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2); durationProducer.onMatchedLogEvent(2 /* stop index*/, event4); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); - EXPECT_EQ(1UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, durationProducer.mPastBuckets.size()); EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != durationProducer.mPastBuckets.end()); const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(1UL, buckets2.size()); + ASSERT_EQ(1UL, buckets2.size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs); EXPECT_EQ(1LL, buckets2[0].mDuration); @@ -198,15 +198,15 @@ TEST(DurationMetricTrackerTest, TestNonSlicedConditionUnknownState) { durationProducer.onMatchedLogEvent(1 /* start index*/, event1); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); - EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets.size()); durationProducer.onMatchedLogEvent(1 /* start index*/, event3); durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2); durationProducer.onMatchedLogEvent(2 /* stop index*/, event4); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); - EXPECT_EQ(1UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, durationProducer.mPastBuckets.size()); const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(1UL, buckets2.size()); + ASSERT_EQ(1UL, buckets2.size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs); EXPECT_EQ(1LL, buckets2[0].mDuration); @@ -241,7 +241,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDuration) { LogEvent event1(/*uid=*/0, /*pid=*/0); makeLogEvent(&event1, startTimeNs, tagId); durationProducer.onMatchedLogEvent(1 /* start index*/, event1); - EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets.size()); EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC; @@ -253,7 +253,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDuration) { durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs); break; } - EXPECT_EQ(1UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); std::vector buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs); @@ -268,7 +268,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDuration) { makeLogEvent(&event2, endTimeNs, tagId); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(3UL, buckets.size()); + ASSERT_EQ(3UL, buckets.size()); EXPECT_EQ(partialBucketSplitTimeNs, buckets[1].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketEndNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - partialBucketSplitTimeNs, buckets[1].mDuration); @@ -303,7 +303,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDurationWithSplitInFollo LogEvent event1(/*uid=*/0, /*pid=*/0); makeLogEvent(&event1, startTimeNs, tagId); durationProducer.onMatchedLogEvent(1 /* start index*/, event1); - EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets.size()); EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC; @@ -315,7 +315,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDurationWithSplitInFollo durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs); break; } - EXPECT_EQ(2UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(2UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); std::vector buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs); @@ -333,7 +333,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDurationWithSplitInFollo makeLogEvent(&event2, endTimeNs, tagId); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(3UL, buckets.size()); + ASSERT_EQ(3UL, buckets.size()); EXPECT_EQ(partialBucketSplitTimeNs, buckets[2].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[2].mBucketEndNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs - partialBucketSplitTimeNs, @@ -411,7 +411,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDuration) { LogEvent event1(/*uid=*/0, /*pid=*/0); makeLogEvent(&event1, startTimeNs, tagId); durationProducer.onMatchedLogEvent(1 /* start index*/, event1); - EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets.size()); EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC; @@ -423,7 +423,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDuration) { durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs); break; } - EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(0, durationProducer.getCurrentBucketNum()); @@ -432,12 +432,12 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDuration) { LogEvent event2(/*uid=*/0, /*pid=*/0); makeLogEvent(&event2, endTimeNs, tagId); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); - EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 3 * bucketSizeNs + 1); std::vector buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(1UL, buckets.size()); + ASSERT_EQ(1UL, buckets.size()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, buckets[0].mBucketEndNs); EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration); @@ -464,7 +464,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDurationWithSplitInNextB LogEvent event1(/*uid=*/0, /*pid=*/0); makeLogEvent(&event1, startTimeNs, tagId); durationProducer.onMatchedLogEvent(1 /* start index*/, event1); - EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets.size()); EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC; @@ -476,7 +476,7 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDurationWithSplitInNextB durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs); break; } - EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(1, durationProducer.getCurrentBucketNum()); @@ -485,13 +485,13 @@ TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDurationWithSplitInNextB LogEvent event2(/*uid=*/0, /*pid=*/0); makeLogEvent(&event2, endTimeNs, tagId); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); - EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); std::vector buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; - EXPECT_EQ(1UL, buckets.size()); + ASSERT_EQ(1UL, buckets.size()); EXPECT_EQ(partialBucketSplitTimeNs, buckets[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketEndNs); EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration); diff --git a/cmds/statsd/tests/metrics/EventMetricProducer_test.cpp b/cmds/statsd/tests/metrics/EventMetricProducer_test.cpp index 97647a7e0867d..5bae3648bd801 100644 --- a/cmds/statsd/tests/metrics/EventMetricProducer_test.cpp +++ b/cmds/statsd/tests/metrics/EventMetricProducer_test.cpp @@ -79,7 +79,7 @@ TEST(EventMetricProducerTest, TestNoCondition) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_event_metrics()); - EXPECT_EQ(2, report.event_metrics().data_size()); + ASSERT_EQ(2, report.event_metrics().data_size()); EXPECT_EQ(bucketStartTimeNs + 1, report.event_metrics().data(0).elapsed_timestamp_nanos()); EXPECT_EQ(bucketStartTimeNs + 2, report.event_metrics().data(1).elapsed_timestamp_nanos()); } @@ -118,7 +118,7 @@ TEST(EventMetricProducerTest, TestEventsWithNonSlicedCondition) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_event_metrics()); - EXPECT_EQ(1, report.event_metrics().data_size()); + ASSERT_EQ(1, report.event_metrics().data_size()); EXPECT_EQ(bucketStartTimeNs + 1, report.event_metrics().data(0).elapsed_timestamp_nanos()); } @@ -168,7 +168,7 @@ TEST(EventMetricProducerTest, TestEventsWithSlicedCondition) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_event_metrics()); - EXPECT_EQ(1, report.event_metrics().data_size()); + ASSERT_EQ(1, report.event_metrics().data_size()); EXPECT_EQ(bucketStartTimeNs + 10, report.event_metrics().data(0).elapsed_timestamp_nanos()); } diff --git a/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp b/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp index 9d2ec88e2f9bd..12839e6d1fbe1 100644 --- a/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp +++ b/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp @@ -156,13 +156,13 @@ TEST(GaugeMetricProducerTest, TestPulledEventsNoCondition) { allData.push_back(makeLogEvent(tagId, bucket2StartTimeNs + 1, 10, "some value", 11)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); auto it = gaugeProducer.mCurrentSlicedBucket->begin()->second.front().mFields->begin(); EXPECT_EQ(INT, it->mValue.getType()); EXPECT_EQ(10, it->mValue.int_value); it++; EXPECT_EQ(11, it->mValue.int_value); - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets.size()); EXPECT_EQ(3, gaugeProducer.mPastBuckets.begin() ->second.back() .mGaugeAtoms.front() @@ -172,7 +172,7 @@ TEST(GaugeMetricProducerTest, TestPulledEventsNoCondition) { allData.clear(); allData.push_back(makeLogEvent(tagId, bucket3StartTimeNs + 10, 24, "some value", 25)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucket3StartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); it = gaugeProducer.mCurrentSlicedBucket->begin()->second.front().mFields->begin(); EXPECT_EQ(INT, it->mValue.getType()); EXPECT_EQ(24, it->mValue.int_value); @@ -180,8 +180,8 @@ TEST(GaugeMetricProducerTest, TestPulledEventsNoCondition) { EXPECT_EQ(INT, it->mValue.getType()); EXPECT_EQ(25, it->mValue.int_value); // One dimension. - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets.size()); - EXPECT_EQ(2UL, gaugeProducer.mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(2UL, gaugeProducer.mPastBuckets.begin()->second.size()); it = gaugeProducer.mPastBuckets.begin()->second.back().mGaugeAtoms.front().mFields->begin(); EXPECT_EQ(INT, it->mValue.getType()); EXPECT_EQ(10L, it->mValue.int_value); @@ -190,10 +190,10 @@ TEST(GaugeMetricProducerTest, TestPulledEventsNoCondition) { EXPECT_EQ(11L, it->mValue.int_value); gaugeProducer.flushIfNeededLocked(bucket4StartTimeNs); - EXPECT_EQ(0UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(0UL, gaugeProducer.mCurrentSlicedBucket->size()); // One dimension. - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets.size()); - EXPECT_EQ(3UL, gaugeProducer.mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(3UL, gaugeProducer.mPastBuckets.begin()->second.size()); it = gaugeProducer.mPastBuckets.begin()->second.back().mGaugeAtoms.front().mFields->begin(); EXPECT_EQ(INT, it->mValue.getType()); EXPECT_EQ(24L, it->mValue.int_value); @@ -247,7 +247,7 @@ TEST_P(GaugeMetricProducerTest_PartialBucket, TestPushedEvents) { break; } EXPECT_EQ(0UL, (*gaugeProducer.mCurrentSlicedBucket).count(DEFAULT_METRIC_DIMENSION_KEY)); - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(bucketStartTimeNs, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs); EXPECT_EQ(partialBucketSplitTimeNs, @@ -262,7 +262,7 @@ TEST_P(GaugeMetricProducerTest_PartialBucket, TestPushedEvents) { CreateTwoValueLogEvent(&event2, tagId, bucketStartTimeNs + 59 * NS_PER_SEC, 1, 10); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); EXPECT_EQ(0L, gaugeProducer.mCurrentBucketNum); - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(bucketStartTimeNs, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs); EXPECT_EQ(partialBucketSplitTimeNs, @@ -277,7 +277,7 @@ TEST_P(GaugeMetricProducerTest_PartialBucket, TestPushedEvents) { CreateTwoValueLogEvent(&event3, tagId, bucketStartTimeNs + 65 * NS_PER_SEC, 1, 10); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); EXPECT_EQ(1L, gaugeProducer.mCurrentBucketNum); - EXPECT_EQ(2UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(2UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ((int64_t)bucketStartTimeNs + bucketSizeNs, gaugeProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(1, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); @@ -286,7 +286,7 @@ TEST_P(GaugeMetricProducerTest_PartialBucket, TestPushedEvents) { CreateTwoValueLogEvent(&event4, tagId, bucketStartTimeNs + 125 * NS_PER_SEC, 1, 10); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, event4); EXPECT_EQ(2L, gaugeProducer.mCurrentBucketNum); - EXPECT_EQ(3UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(3UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(2, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); } @@ -329,7 +329,7 @@ TEST_P(GaugeMetricProducerTest_PartialBucket, TestPulled) { vector> allData; allData.push_back(CreateRepeatedValueLogEvent(tagId, bucketStartTimeNs + 1, 1)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucketStartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(1, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() @@ -343,14 +343,14 @@ TEST_P(GaugeMetricProducerTest_PartialBucket, TestPulled) { gaugeProducer.onStatsdInitCompleted(partialBucketSplitTimeNs); break; } - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(bucketStartTimeNs, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs); EXPECT_EQ(partialBucketSplitTimeNs, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketEndNs); EXPECT_EQ(0L, gaugeProducer.mCurrentBucketNum); EXPECT_EQ(partialBucketSplitTimeNs, gaugeProducer.mCurrentBucketStartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(2, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() @@ -359,8 +359,8 @@ TEST_P(GaugeMetricProducerTest_PartialBucket, TestPulled) { allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucketStartTimeNs + bucketSizeNs + 1, 3)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucketStartTimeNs + bucketSizeNs); - EXPECT_EQ(2UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(2UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(3, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() @@ -399,17 +399,17 @@ TEST(GaugeMetricProducerTest, TestPulledWithAppUpgradeDisabled) { vector> allData; allData.push_back(CreateRepeatedValueLogEvent(tagId, bucketStartTimeNs + 1, 1)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucketStartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(1, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() ->mValue.int_value); gaugeProducer.notifyAppUpgrade(partialBucketSplitTimeNs); - EXPECT_EQ(0UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(0UL, gaugeProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(0L, gaugeProducer.mCurrentBucketNum); EXPECT_EQ(bucketStartTimeNs, gaugeProducer.mCurrentBucketStartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(1, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() @@ -452,24 +452,24 @@ TEST(GaugeMetricProducerTest, TestPulledEventsWithCondition) { gaugeProducer.prepareFirstBucket(); gaugeProducer.onConditionChanged(true, bucketStartTimeNs + 8); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(100, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() ->mValue.int_value); - EXPECT_EQ(0UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, gaugeProducer.mPastBuckets.size()); vector> allData; allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket2StartTimeNs + 1, 110)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(110, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() ->mValue.int_value); - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets.size()); EXPECT_EQ(100, gaugeProducer.mPastBuckets.begin() ->second.back() .mGaugeAtoms.front() @@ -478,8 +478,8 @@ TEST(GaugeMetricProducerTest, TestPulledEventsWithCondition) { gaugeProducer.onConditionChanged(false, bucket2StartTimeNs + 10); gaugeProducer.flushIfNeededLocked(bucket3StartTimeNs + 10); - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets.size()); - EXPECT_EQ(2UL, gaugeProducer.mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(2UL, gaugeProducer.mPastBuckets.begin()->second.size()); EXPECT_EQ(110L, gaugeProducer.mPastBuckets.begin() ->second.back() .mGaugeAtoms.front() @@ -537,20 +537,20 @@ TEST(GaugeMetricProducerTest, TestPulledEventsWithSlicedCondition) { gaugeProducer.onSlicedConditionMayChange(true, bucketStartTimeNs + 8); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); const auto& key = gaugeProducer.mCurrentSlicedBucket->begin()->first; - EXPECT_EQ(1UL, key.getDimensionKeyInWhat().getValues().size()); + ASSERT_EQ(1UL, key.getDimensionKeyInWhat().getValues().size()); EXPECT_EQ(1000, key.getDimensionKeyInWhat().getValues()[0].mValue.int_value); - EXPECT_EQ(0UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(0UL, gaugeProducer.mPastBuckets.size()); vector> allData; allData.clear(); allData.push_back(CreateTwoValueLogEvent(tagId, bucket2StartTimeNs + 1, 1000, 110)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets.size()); } TEST(GaugeMetricProducerTest, TestPulledEventsAnomalyDetection) { @@ -596,7 +596,7 @@ TEST(GaugeMetricProducerTest, TestPulledEventsAnomalyDetection) { allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucketStartTimeNs + 1, 13)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucketStartTimeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(13L, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() @@ -609,7 +609,7 @@ TEST(GaugeMetricProducerTest, TestPulledEventsAnomalyDetection) { allData.clear(); allData.push_back(event2); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucketStartTimeNs + bucketSizeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(15L, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() @@ -621,7 +621,7 @@ TEST(GaugeMetricProducerTest, TestPulledEventsAnomalyDetection) { allData.push_back( CreateRepeatedValueLogEvent(tagId, bucketStartTimeNs + 2 * bucketSizeNs + 10, 26)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs + 2 * bucketSizeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_EQ(26L, gaugeProducer.mCurrentSlicedBucket->begin() ->second.front() .mFields->begin() @@ -633,7 +633,7 @@ TEST(GaugeMetricProducerTest, TestPulledEventsAnomalyDetection) { allData.clear(); allData.push_back(CreateNoValuesLogEvent(tagId, bucketStartTimeNs + 3 * bucketSizeNs + 10)); gaugeProducer.onDataPulled(allData, /** succeed */ true, bucketStartTimeNs + 3 * bucketSizeNs); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); EXPECT_TRUE(gaugeProducer.mCurrentSlicedBucket->begin()->second.front().mFields->empty()); } @@ -679,20 +679,20 @@ TEST(GaugeMetricProducerTest, TestPullOnTrigger) { tagId, bucketStartTimeNs, bucketStartTimeNs, pullerManager); gaugeProducer.prepareFirstBucket(); - EXPECT_EQ(0UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(0UL, gaugeProducer.mCurrentSlicedBucket->size()); LogEvent triggerEvent(/*uid=*/0, /*pid=*/0); CreateNoValuesLogEvent(&triggerEvent, triggerId, bucketStartTimeNs + 10); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, triggerEvent); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); triggerEvent.setElapsedTimestampNs(bucketStartTimeNs + 20); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, triggerEvent); - EXPECT_EQ(2UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); + ASSERT_EQ(2UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); triggerEvent.setElapsedTimestampNs(bucket2StartTimeNs + 1); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, triggerEvent); - EXPECT_EQ(1UL, gaugeProducer.mPastBuckets.size()); - EXPECT_EQ(2UL, gaugeProducer.mPastBuckets.begin()->second.back().mGaugeAtoms.size()); + ASSERT_EQ(1UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(2UL, gaugeProducer.mPastBuckets.begin()->second.back().mGaugeAtoms.size()); EXPECT_EQ(4, gaugeProducer.mPastBuckets.begin() ->second.back() .mGaugeAtoms[0] @@ -757,24 +757,24 @@ TEST(GaugeMetricProducerTest, TestRemoveDimensionInOutput) { LogEvent triggerEvent(/*uid=*/0, /*pid=*/0); CreateNoValuesLogEvent(&triggerEvent, triggerId, bucketStartTimeNs + 3); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, triggerEvent); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->size()); triggerEvent.setElapsedTimestampNs(bucketStartTimeNs + 10); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, triggerEvent); - EXPECT_EQ(2UL, gaugeProducer.mCurrentSlicedBucket->size()); - EXPECT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); + ASSERT_EQ(2UL, gaugeProducer.mCurrentSlicedBucket->size()); + ASSERT_EQ(1UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); triggerEvent.setElapsedTimestampNs(bucketStartTimeNs + 20); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, triggerEvent); - EXPECT_EQ(2UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); + ASSERT_EQ(2UL, gaugeProducer.mCurrentSlicedBucket->begin()->second.size()); triggerEvent.setElapsedTimestampNs(bucket2StartTimeNs + 1); gaugeProducer.onMatchedLogEvent(1 /*log matcher index*/, triggerEvent); - EXPECT_EQ(2UL, gaugeProducer.mPastBuckets.size()); + ASSERT_EQ(2UL, gaugeProducer.mPastBuckets.size()); auto bucketIt = gaugeProducer.mPastBuckets.begin(); - EXPECT_EQ(1UL, bucketIt->second.back().mGaugeAtoms.size()); + ASSERT_EQ(1UL, bucketIt->second.back().mGaugeAtoms.size()); EXPECT_EQ(3, bucketIt->first.getDimensionKeyInWhat().getValues().begin()->mValue.int_value); EXPECT_EQ(4, bucketIt->second.back().mGaugeAtoms[0].mFields->begin()->mValue.int_value); bucketIt++; - EXPECT_EQ(2UL, bucketIt->second.back().mGaugeAtoms.size()); + ASSERT_EQ(2UL, bucketIt->second.back().mGaugeAtoms.size()); EXPECT_EQ(4, bucketIt->first.getDimensionKeyInWhat().getValues().begin()->mValue.int_value); EXPECT_EQ(5, bucketIt->second.back().mGaugeAtoms[0].mFields->begin()->mValue.int_value); EXPECT_EQ(6, bucketIt->second.back().mGaugeAtoms[1].mFields->begin()->mValue.int_value); @@ -828,14 +828,14 @@ TEST(GaugeMetricProducerTest_BucketDrop, TestBucketDropWhenBucketTooSmall) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_gauge_metrics()); - EXPECT_EQ(0, report.gauge_metrics().data_size()); - EXPECT_EQ(1, report.gauge_metrics().skipped_size()); + ASSERT_EQ(0, report.gauge_metrics().data_size()); + ASSERT_EQ(1, report.gauge_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.gauge_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs + 9000000), report.gauge_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.gauge_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.gauge_metrics().skipped(0).drop_event_size()); auto dropEvent = report.gauge_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::BUCKET_TOO_SMALL, dropEvent.drop_reason()); diff --git a/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp b/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp index d2f0f57e0f546..fda3daaa56aac 100644 --- a/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp +++ b/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp @@ -77,7 +77,7 @@ TEST(MaxDurationTrackerTest, TestSimpleMaxDuration) { tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(20LL, buckets[eventKey][0].mDuration); } @@ -110,7 +110,7 @@ TEST(MaxDurationTrackerTest, TestStopAll) { tracker.flushIfNeeded(bucketStartTimeNs + 3 * bucketSizeNs + 40, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(bucketSizeNs + 40 - 1, buckets[eventKey][0].mDuration); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[eventKey][0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[eventKey][0].mBucketEndNs); @@ -149,7 +149,7 @@ TEST(MaxDurationTrackerTest, TestCrossBucketBoundary) { EXPECT_TRUE(buckets.find(eventKey) == buckets.end()); tracker.flushIfNeeded(bucketStartTimeNs + 4 * bucketSizeNs, &buckets); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ((3 * bucketSizeNs) + 20 - 1, buckets[eventKey][0].mDuration); EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, buckets[eventKey][0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + 4 * bucketSizeNs, buckets[eventKey][0].mBucketEndNs); @@ -187,7 +187,7 @@ TEST(MaxDurationTrackerTest, TestCrossBucketBoundary_nested) { bucketStartTimeNs + (2 * bucketSizeNs) + 5, false); tracker.flushIfNeeded(bucketStartTimeNs + (3 * bucketSizeNs) + 1, &buckets); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(2 * bucketSizeNs + 5 - 1, buckets[eventKey][0].mDuration); } @@ -223,15 +223,15 @@ TEST(MaxDurationTrackerTest, TestMaxDurationWithCondition) { tracker.noteConditionChanged(key1, false, conditionStops1); unordered_map> buckets; tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets); - EXPECT_EQ(0U, buckets.size()); + ASSERT_EQ(0U, buckets.size()); tracker.noteConditionChanged(key1, true, conditionStarts2); tracker.noteConditionChanged(key1, false, conditionStops2); tracker.noteStop(key1, eventStopTimeNs, false); tracker.flushIfNeeded(bucketStartTimeNs + 2 * bucketSizeNs + 1, &buckets); - EXPECT_EQ(1U, buckets.size()); + ASSERT_EQ(1U, buckets.size()); vector item = buckets.begin()->second; - EXPECT_EQ(1UL, item.size()); + ASSERT_EQ(1UL, item.size()); EXPECT_EQ((int64_t)(13LL * NS_PER_SEC), item[0].mDuration); } @@ -272,11 +272,11 @@ TEST(MaxDurationTrackerTest, TestAnomalyDetection) { // Remove the anomaly alarm when the duration is no longer fully met. tracker.noteConditionChanged(key1, false, eventStartTimeNs + 15 * NS_PER_SEC); - EXPECT_EQ(0U, anomalyTracker->mAlarms.size()); + ASSERT_EQ(0U, anomalyTracker->mAlarms.size()); // Since the condition was off for 10 seconds, the anomaly should trigger 10 sec later. tracker.noteConditionChanged(key1, true, eventStartTimeNs + 25 * NS_PER_SEC); - EXPECT_EQ(1U, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1U, anomalyTracker->mAlarms.size()); alarm = anomalyTracker->mAlarms.begin()->second; EXPECT_EQ((long long)(63ULL * NS_PER_SEC), (long long)(alarm->timestampSec * NS_PER_SEC)); } @@ -330,7 +330,7 @@ TEST(MaxDurationTrackerTest, TestAnomalyPredictedTimestamp) { tracker.noteConditionChanged(key1, false, conditionStops1); tracker.noteStart(key2, true, eventStartTimeNs2, conditionKey2); // Condition is on already. tracker.noteConditionChanged(key1, true, conditionStarts2); - EXPECT_EQ(1U, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1U, anomalyTracker->mAlarms.size()); auto alarm = anomalyTracker->mAlarms.begin()->second; int64_t anomalyFireTimeSec = alarm->timestampSec; EXPECT_EQ(conditionStarts2 + 36 * NS_PER_SEC, @@ -341,7 +341,7 @@ TEST(MaxDurationTrackerTest, TestAnomalyPredictedTimestamp) { // gets correctly taken into account in future predictAnomalyTimestampNs calculations. std::unordered_set, SpHash> firedAlarms({alarm}); anomalyTracker->informAlarmsFired(anomalyFireTimeSec * NS_PER_SEC, firedAlarms); - EXPECT_EQ(0u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(0u, anomalyTracker->mAlarms.size()); int64_t refractoryPeriodEndsSec = anomalyFireTimeSec + refPeriodSec; EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), refractoryPeriodEndsSec); @@ -352,7 +352,7 @@ TEST(MaxDurationTrackerTest, TestAnomalyPredictedTimestamp) { tracker.noteStop(key2, eventStopTimeNs, false); tracker.noteStart(key1, true, eventStopTimeNs + 1000000, conditionKey1); // Anomaly is ongoing, but we're still in the refractory period. - EXPECT_EQ(1U, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1U, anomalyTracker->mAlarms.size()); alarm = anomalyTracker->mAlarms.begin()->second; EXPECT_EQ(refractoryPeriodEndsSec, (long long)(alarm->timestampSec)); @@ -410,7 +410,7 @@ TEST(MaxDurationTrackerTest, TestAnomalyPredictedTimestamp_UpdatedOnStop) { tracker.noteStart(key1, true, eventStartTimeNs1, conditionKey1); tracker.noteStart(key2, true, eventStartTimeNs2, conditionKey2); tracker.noteStop(key1, eventStopTimeNs1, false); - EXPECT_EQ(1U, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1U, anomalyTracker->mAlarms.size()); auto alarm = anomalyTracker->mAlarms.begin()->second; EXPECT_EQ(eventStopTimeNs1 + 35 * NS_PER_SEC, (unsigned long long)(alarm->timestampSec * NS_PER_SEC)); diff --git a/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp b/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp index 39d3919dffd04..1d6f7de5e7e32 100644 --- a/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp +++ b/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp @@ -74,7 +74,7 @@ TEST(OringDurationTrackerTest, TestDurationOverlap) { tracker.flushIfNeeded(eventStartTimeNs + bucketSizeNs + 1, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(durationTimeNs, buckets[eventKey][0].mDuration); } @@ -103,7 +103,7 @@ TEST(OringDurationTrackerTest, TestDurationNested) { tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(2003LL, buckets[eventKey][0].mDuration); } @@ -133,7 +133,7 @@ TEST(OringDurationTrackerTest, TestStopAll) { tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(2003LL, buckets[eventKey][0].mDuration); } @@ -161,7 +161,7 @@ TEST(OringDurationTrackerTest, TestCrossBucketBoundary) { tracker.noteStart(kEventKey1, true, eventStartTimeNs + 2 * bucketSizeNs, ConditionKey()); EXPECT_EQ((long long)(bucketStartTimeNs + 2 * bucketSizeNs), tracker.mLastStartTime); - EXPECT_EQ(2u, buckets[eventKey].size()); + ASSERT_EQ(2u, buckets[eventKey].size()); EXPECT_EQ(bucketSizeNs - 1, buckets[eventKey][0].mDuration); EXPECT_EQ(bucketSizeNs, buckets[eventKey][1].mDuration); @@ -169,7 +169,7 @@ TEST(OringDurationTrackerTest, TestCrossBucketBoundary) { tracker.noteStop(kEventKey1, eventStartTimeNs + 2 * bucketSizeNs + 12, false); tracker.flushIfNeeded(eventStartTimeNs + 2 * bucketSizeNs + 12, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(2u, buckets[eventKey].size()); + ASSERT_EQ(2u, buckets[eventKey].size()); EXPECT_EQ(bucketSizeNs - 1, buckets[eventKey][0].mDuration); EXPECT_EQ(bucketSizeNs, buckets[eventKey][1].mDuration); } @@ -207,7 +207,7 @@ TEST(OringDurationTrackerTest, TestDurationConditionChange) { tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(5LL, buckets[eventKey][0].mDuration); } @@ -248,7 +248,7 @@ TEST(OringDurationTrackerTest, TestDurationConditionChange2) { tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(1005LL, buckets[eventKey][0].mDuration); } @@ -286,7 +286,7 @@ TEST(OringDurationTrackerTest, TestDurationConditionChangeNested) { tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(15LL, buckets[eventKey][0].mDuration); } @@ -322,7 +322,7 @@ TEST(OringDurationTrackerTest, TestPredictAnomalyTimestamp) { tracker.predictAnomalyTimestampNs(*anomalyTracker, eventStartTimeNs)); tracker.noteStop(DEFAULT_DIMENSION_KEY, eventStartTimeNs + 3, false); - EXPECT_EQ(0u, buckets[eventKey].size()); + ASSERT_EQ(0u, buckets[eventKey].size()); int64_t event1StartTimeNs = eventStartTimeNs + 10; tracker.noteStart(kEventKey1, true, event1StartTimeNs, ConditionKey()); @@ -335,7 +335,7 @@ TEST(OringDurationTrackerTest, TestPredictAnomalyTimestamp) { tracker.noteStop(kEventKey1, event1StopTimeNs, false); EXPECT_TRUE(buckets.find(eventKey) != buckets.end()); - EXPECT_EQ(1u, buckets[eventKey].size()); + ASSERT_EQ(1u, buckets[eventKey].size()); EXPECT_EQ(3LL + bucketStartTimeNs + bucketSizeNs - eventStartTimeNs - 10, buckets[eventKey][0].mDuration); @@ -486,10 +486,10 @@ TEST(OringDurationTrackerTest, TestAnomalyDetectionExpiredAlarm) { EXPECT_TRUE(tracker.mStarted.empty()); EXPECT_EQ(10LL, tracker.mStateKeyDurationMap[DEFAULT_DIMENSION_KEY].mDuration); // 10ns - EXPECT_EQ(0u, tracker.mStarted.size()); + ASSERT_EQ(0u, tracker.mStarted.size()); tracker.noteStart(kEventKey1, true, eventStartTimeNs + 20, ConditionKey()); - EXPECT_EQ(1u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1u, anomalyTracker->mAlarms.size()); EXPECT_EQ((long long)(52ULL * NS_PER_SEC), // (10s + 1s + 1ns + 20ns) - 10ns + 40s, rounded up (long long)(anomalyTracker->mAlarms.begin()->second->timestampSec * NS_PER_SEC)); // The alarm is set to fire at 52s, and when it does, an anomaly would be declared. However, @@ -530,29 +530,29 @@ TEST(OringDurationTrackerTest, TestAnomalyDetectionFiredAlarm) { false, {anomalyTracker}); tracker.noteStart(kEventKey1, true, 15 * NS_PER_SEC, conkey); // start key1 - EXPECT_EQ(1u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1u, anomalyTracker->mAlarms.size()); sp alarm = anomalyTracker->mAlarms.begin()->second; EXPECT_EQ((long long)(55ULL * NS_PER_SEC), (long long)(alarm->timestampSec * NS_PER_SEC)); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), 0U); tracker.noteStop(kEventKey1, 17 * NS_PER_SEC, false); // stop key1 (2 seconds later) - EXPECT_EQ(0u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(0u, anomalyTracker->mAlarms.size()); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), 0U); tracker.noteStart(kEventKey1, true, 22 * NS_PER_SEC, conkey); // start key1 again - EXPECT_EQ(1u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1u, anomalyTracker->mAlarms.size()); alarm = anomalyTracker->mAlarms.begin()->second; EXPECT_EQ((long long)(60ULL * NS_PER_SEC), (long long)(alarm->timestampSec * NS_PER_SEC)); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), 0U); tracker.noteStart(kEventKey2, true, 32 * NS_PER_SEC, conkey); // start key2 - EXPECT_EQ(1u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1u, anomalyTracker->mAlarms.size()); alarm = anomalyTracker->mAlarms.begin()->second; EXPECT_EQ((long long)(60ULL * NS_PER_SEC), (long long)(alarm->timestampSec * NS_PER_SEC)); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), 0U); tracker.noteStop(kEventKey1, 47 * NS_PER_SEC, false); // stop key1 - EXPECT_EQ(1u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(1u, anomalyTracker->mAlarms.size()); alarm = anomalyTracker->mAlarms.begin()->second; EXPECT_EQ((long long)(60ULL * NS_PER_SEC), (long long)(alarm->timestampSec * NS_PER_SEC)); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), 0U); @@ -560,11 +560,11 @@ TEST(OringDurationTrackerTest, TestAnomalyDetectionFiredAlarm) { // Now, at 60s, which is 38s after key1 started again, we have reached 40s of 'on' time. std::unordered_set, SpHash> firedAlarms({alarm}); anomalyTracker->informAlarmsFired(62 * NS_PER_SEC, firedAlarms); - EXPECT_EQ(0u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(0u, anomalyTracker->mAlarms.size()); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), 62U + refPeriodSec); tracker.noteStop(kEventKey2, 69 * NS_PER_SEC, false); // stop key2 - EXPECT_EQ(0u, anomalyTracker->mAlarms.size()); + ASSERT_EQ(0u, anomalyTracker->mAlarms.size()); EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(eventKey), 62U + refPeriodSec); } diff --git a/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp b/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp index f493cc4033ad3..be1b9ebb557c8 100644 --- a/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp +++ b/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp @@ -295,7 +295,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsNoCondition) { valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -304,7 +304,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsNoCondition) { EXPECT_EQ(11, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(8, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); EXPECT_EQ(8, valueProducer->mPastBuckets.begin()->second[0].values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second[0].mConditionTrueNs); @@ -312,7 +312,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsNoCondition) { allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket3StartTimeNs + 1, 23)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket3StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -320,8 +320,8 @@ TEST(ValueMetricProducerTest, TestPulledEventsNoCondition) { EXPECT_EQ(23, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(12, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); - EXPECT_EQ(2UL, valueProducer->mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mPastBuckets.begin()->second.size()); EXPECT_EQ(8, valueProducer->mPastBuckets.begin()->second[0].values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second[0].mConditionTrueNs); EXPECT_EQ(12, valueProducer->mPastBuckets.begin()->second.back().values[0].long_value); @@ -330,7 +330,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsNoCondition) { allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket4StartTimeNs + 1, 36)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket4StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -338,8 +338,8 @@ TEST(ValueMetricProducerTest, TestPulledEventsNoCondition) { EXPECT_EQ(36, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(13, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); - EXPECT_EQ(3UL, valueProducer->mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(3UL, valueProducer->mPastBuckets.begin()->second.size()); EXPECT_EQ(8, valueProducer->mPastBuckets.begin()->second[0].values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second[0].mConditionTrueNs); EXPECT_EQ(12, valueProducer->mPastBuckets.begin()->second[1].values[0].long_value); @@ -435,7 +435,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsWithFiltering) { valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -444,7 +444,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsWithFiltering) { EXPECT_EQ(11, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(8, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); EXPECT_EQ(8, valueProducer->mPastBuckets.begin()->second[0].values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second[0].mConditionTrueNs); @@ -452,20 +452,20 @@ TEST(ValueMetricProducerTest, TestPulledEventsWithFiltering) { allData.push_back(CreateTwoValueLogEvent(tagId, bucket3StartTimeNs + 1, 4, 23)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket3StartTimeNs); // No new data seen, so data has been cleared. - EXPECT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(11, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(8, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); EXPECT_EQ(8, valueProducer->mPastBuckets.begin()->second[0].values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second[0].mConditionTrueNs); allData.clear(); allData.push_back(CreateTwoValueLogEvent(tagId, bucket4StartTimeNs + 1, 3, 36)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket4StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -473,8 +473,8 @@ TEST(ValueMetricProducerTest, TestPulledEventsWithFiltering) { EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(36, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.begin()->second.size()); EXPECT_EQ(8, valueProducer->mPastBuckets.begin()->second.back().values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second.back().mConditionTrueNs); } @@ -497,7 +497,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsTakeAbsoluteValueOnReset) { valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -505,35 +505,35 @@ TEST(ValueMetricProducerTest, TestPulledEventsTakeAbsoluteValueOnReset) { EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(11, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket3StartTimeNs + 1, 10)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket3StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(10, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(10, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); EXPECT_EQ(10, valueProducer->mPastBuckets.begin()->second.back().values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second.back().mConditionTrueNs); allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket4StartTimeNs + 1, 36)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket4StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(36, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(26, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); - EXPECT_EQ(2UL, valueProducer->mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mPastBuckets.begin()->second.size()); EXPECT_EQ(10, valueProducer->mPastBuckets.begin()->second[0].values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second[0].mConditionTrueNs); EXPECT_EQ(26, valueProducer->mPastBuckets.begin()->second[1].values[0].long_value); @@ -556,7 +556,7 @@ TEST(ValueMetricProducerTest, TestPulledEventsTakeZeroOnReset) { valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -564,31 +564,31 @@ TEST(ValueMetricProducerTest, TestPulledEventsTakeZeroOnReset) { EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(11, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket3StartTimeNs + 1, 10)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket3StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(10, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket4StartTimeNs + 1, 36)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket4StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(36, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(26, curInterval.value.long_value); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); EXPECT_EQ(26, valueProducer->mPastBuckets.begin()->second[0].values[0].long_value); EXPECT_EQ(bucketSizeNs, valueProducer->mPastBuckets.begin()->second[0].mConditionTrueNs); } @@ -627,7 +627,7 @@ TEST(ValueMetricProducerTest, TestEventsWithNonSlicedCondition) { valueProducer->onConditionChanged(true, bucketStartTimeNs + 8); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -635,7 +635,7 @@ TEST(ValueMetricProducerTest, TestEventsWithNonSlicedCondition) { EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(100, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); vector> allData; allData.clear(); @@ -645,7 +645,7 @@ TEST(ValueMetricProducerTest, TestEventsWithNonSlicedCondition) { {bucketStartTimeNs}, {bucket2StartTimeNs}); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); @@ -658,7 +658,7 @@ TEST(ValueMetricProducerTest, TestEventsWithNonSlicedCondition) { {bucketStartTimeNs}, {bucket2StartTimeNs}); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curInterval.hasValue); @@ -690,7 +690,7 @@ TEST_P(ValueMetricProducerTest_PartialBucket, TestPushedEvents) { LogEvent event1(/*uid=*/0, /*pid=*/0); CreateRepeatedValueLogEvent(&event1, tagId, bucketStartTimeNs + 10, 10); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 150; switch (GetParam()) { @@ -764,7 +764,7 @@ TEST_P(ValueMetricProducerTest_PartialBucket, TestPulledValue) { allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket2StartTimeNs + 1, 100)); valueProducer.onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); switch (GetParam()) { case APP_UPGRADE: @@ -814,10 +814,10 @@ TEST(ValueMetricProducerTest, TestPulledWithAppUpgradeDisabled) { allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket2StartTimeNs + 1, 100)); valueProducer.onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); valueProducer.notifyAppUpgrade(bucket2StartTimeNs + 150); - EXPECT_EQ(0UL, valueProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); + ASSERT_EQ(0UL, valueProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(bucket2StartTimeNs, valueProducer.mCurrentBucketStartTimeNs); } @@ -888,7 +888,7 @@ TEST(ValueMetricProducerTest, TestPushedEventsWithoutCondition) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; @@ -898,7 +898,7 @@ TEST(ValueMetricProducerTest, TestPushedEventsWithoutCondition) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(30, curInterval.value.long_value); @@ -929,7 +929,7 @@ TEST(ValueMetricProducerTest, TestPushedEventsWithCondition) { CreateRepeatedValueLogEvent(&event1, tagId, bucketStartTimeNs + 10, 10); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has 1 slice - EXPECT_EQ(0UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(0UL, valueProducer.mCurrentSlicedBucket.size()); valueProducer.onConditionChangedLocked(true, bucketStartTimeNs + 15); @@ -938,7 +938,7 @@ TEST(ValueMetricProducerTest, TestPushedEventsWithCondition) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; @@ -949,7 +949,7 @@ TEST(ValueMetricProducerTest, TestPushedEventsWithCondition) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(50, curInterval.value.long_value); @@ -960,7 +960,7 @@ TEST(ValueMetricProducerTest, TestPushedEventsWithCondition) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event4); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(50, curInterval.value.long_value); @@ -1060,7 +1060,7 @@ TEST(ValueMetricProducerTest, TestBucketBoundaryNoCondition) { valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -1069,14 +1069,14 @@ TEST(ValueMetricProducerTest, TestBucketBoundaryNoCondition) { EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(11, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); // pull 2 at correct time allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket3StartTimeNs + 1, 23)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket3StartTimeNs); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; // tartUpdated:false sum:12 @@ -1093,7 +1093,7 @@ TEST(ValueMetricProducerTest, TestBucketBoundaryNoCondition) { allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket6StartTimeNs + 1, 36)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket6StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; // startUpdated:false sum:12 @@ -1140,14 +1140,14 @@ TEST(ValueMetricProducerTest, TestBucketBoundaryWithCondition) { valueProducer->onConditionChanged(true, bucketStartTimeNs + 8); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(100, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); // pull on bucket boundary come late, condition change happens before it valueProducer->onConditionChanged(false, bucket2StartTimeNs + 1); @@ -1208,7 +1208,7 @@ TEST(ValueMetricProducerTest, TestBucketBoundaryWithCondition2) { valueProducer->onConditionChanged(true, bucketStartTimeNs + 8); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -1216,13 +1216,13 @@ TEST(ValueMetricProducerTest, TestBucketBoundaryWithCondition2) { EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(100, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); // pull on bucket boundary come late, condition change happens before it valueProducer->onConditionChanged(false, bucket2StartTimeNs + 1); assertPastBucketValuesSingleKey(valueProducer->mPastBuckets, {20}, {bucketSizeNs - 8}, {bucketStartTimeNs}, {bucket2StartTimeNs}); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(false, curBaseInfo.hasBase); @@ -1287,7 +1287,7 @@ TEST(ValueMetricProducerTest, TestPushedAggregateMin) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(10, curInterval.value.long_value); @@ -1296,7 +1296,7 @@ TEST(ValueMetricProducerTest, TestPushedAggregateMin) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(10, curInterval.value.long_value); @@ -1328,7 +1328,7 @@ TEST(ValueMetricProducerTest, TestPushedAggregateMax) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(10, curInterval.value.long_value); @@ -1339,7 +1339,7 @@ TEST(ValueMetricProducerTest, TestPushedAggregateMax) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(20, curInterval.value.long_value); @@ -1373,7 +1373,7 @@ TEST(ValueMetricProducerTest, TestPushedAggregateAvg) { CreateRepeatedValueLogEvent(&event2, tagId, bucketStartTimeNs + 20, 15); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval; curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(10, curInterval.value.long_value); @@ -1383,14 +1383,14 @@ TEST(ValueMetricProducerTest, TestPushedAggregateAvg) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(25, curInterval.value.long_value); EXPECT_EQ(2, curInterval.sampleSize); valueProducer.flushIfNeededLocked(bucket2StartTimeNs); - EXPECT_EQ(1UL, valueProducer.mPastBuckets.size()); - EXPECT_EQ(1UL, valueProducer.mPastBuckets.begin()->second.size()); + ASSERT_EQ(1UL, valueProducer.mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer.mPastBuckets.begin()->second.size()); EXPECT_TRUE(std::abs(valueProducer.mPastBuckets.begin()->second.back().values[0].double_value - 12.5) < epsilon); @@ -1421,7 +1421,7 @@ TEST(ValueMetricProducerTest, TestPushedAggregateSum) { CreateRepeatedValueLogEvent(&event2, tagId, bucketStartTimeNs + 20, 15); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(10, curInterval.value.long_value); @@ -1430,7 +1430,7 @@ TEST(ValueMetricProducerTest, TestPushedAggregateSum) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(25, curInterval.value.long_value); @@ -1463,7 +1463,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutput) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; @@ -1476,7 +1476,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutput) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; EXPECT_EQ(true, curInterval.hasValue); EXPECT_EQ(5, curInterval.value.long_value); @@ -1486,7 +1486,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutput) { CreateRepeatedValueLogEvent(&event3, tagId, bucket2StartTimeNs + 10, 15); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); @@ -1497,7 +1497,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutput) { LogEvent event4(/*uid=*/0, /*pid=*/0); CreateRepeatedValueLogEvent(&event4, tagId, bucket2StartTimeNs + 15, 15); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event4); - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); @@ -1538,7 +1538,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutputMultiValue) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; @@ -1553,7 +1553,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutputMultiValue) { valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); // has one slice - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curInterval.hasValue); @@ -1568,7 +1568,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutputMultiValue) { CreateThreeValueLogEvent(&event3, tagId, bucket2StartTimeNs + 10, 1, 15, 25); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; @@ -1585,7 +1585,7 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutputMultiValue) { CreateThreeValueLogEvent(&event4, tagId, bucket2StartTimeNs + 15, 1, 15, 29); valueProducer.onMatchedLogEvent(1 /*log matcher index*/, event4); - EXPECT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer.mCurrentSlicedBucket.size()); curInterval = valueProducer.mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer.mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); @@ -1599,10 +1599,10 @@ TEST(ValueMetricProducerTest, TestSkipZeroDiffOutputMultiValue) { valueProducer.flushIfNeededLocked(bucket3StartTimeNs); - EXPECT_EQ(1UL, valueProducer.mPastBuckets.size()); - EXPECT_EQ(2UL, valueProducer.mPastBuckets.begin()->second.size()); - EXPECT_EQ(2UL, valueProducer.mPastBuckets.begin()->second[0].values.size()); - EXPECT_EQ(1UL, valueProducer.mPastBuckets.begin()->second[1].values.size()); + ASSERT_EQ(1UL, valueProducer.mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer.mPastBuckets.begin()->second.size()); + ASSERT_EQ(2UL, valueProducer.mPastBuckets.begin()->second[0].values.size()); + ASSERT_EQ(1UL, valueProducer.mPastBuckets.begin()->second[1].values.size()); EXPECT_EQ(bucketSizeNs, valueProducer.mPastBuckets.begin()->second[0].mConditionTrueNs); EXPECT_EQ(5, valueProducer.mPastBuckets.begin()->second[0].values[0].long_value); @@ -1636,7 +1636,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBase) { sp valueProducer = ValueMetricProducerTestHelper::createValueProducerNoConditions(pullerManager, metric); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); auto iter = valueProducer->mCurrentSlicedBucket.begin(); auto& interval1 = iter->second[0]; auto iterBase = valueProducer->mCurrentBaseInfo.begin(); @@ -1646,7 +1646,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBase) { EXPECT_EQ(3, baseInfo1.base.long_value); EXPECT_EQ(false, interval1.hasValue); EXPECT_EQ(true, valueProducer->mHasGlobalBase); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); vector> allData; allData.clear(); @@ -1654,7 +1654,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBase) { allData.push_back(CreateTwoValueLogEvent(tagId, bucket2StartTimeNs + 1, 1, 11)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); EXPECT_EQ(true, baseInfo1.hasBase); EXPECT_EQ(11, baseInfo1.base.long_value); EXPECT_EQ(false, interval1.hasValue); @@ -1682,7 +1682,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBase) { EXPECT_EQ(false, interval2.hasValue); EXPECT_EQ(4, interval2.value.long_value); - EXPECT_EQ(2UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mPastBuckets.size()); auto iterator = valueProducer->mPastBuckets.begin(); EXPECT_EQ(bucketSizeNs, iterator->second[0].mConditionTrueNs); EXPECT_EQ(8, iterator->second[0].values[0].long_value); @@ -1712,7 +1712,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBaseWithPullFailures) { sp valueProducer = ValueMetricProducerTestHelper::createValueProducerNoConditions(pullerManager, metric); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); const auto& it = valueProducer->mCurrentSlicedBucket.begin(); ValueMetricProducer::Interval& interval1 = it->second[0]; ValueMetricProducer::BaseInfo& baseInfo1 = @@ -1722,7 +1722,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBaseWithPullFailures) { EXPECT_EQ(3, baseInfo1.base.long_value); EXPECT_EQ(false, interval1.hasValue); EXPECT_EQ(true, valueProducer->mHasGlobalBase); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); vector> allData; allData.clear(); @@ -1730,7 +1730,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBaseWithPullFailures) { allData.push_back(CreateTwoValueLogEvent(tagId, bucket2StartTimeNs + 1, 1, 11)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); EXPECT_EQ(true, baseInfo1.hasBase); EXPECT_EQ(11, baseInfo1.base.long_value); EXPECT_EQ(false, interval1.hasValue); @@ -1751,31 +1751,31 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBaseWithPullFailures) { EXPECT_EQ(4, baseInfo2.base.long_value); EXPECT_EQ(false, interval2.hasValue); EXPECT_EQ(4, interval2.value.long_value); - EXPECT_EQ(2UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mPastBuckets.size()); // next pull somehow did not happen, skip to end of bucket 3 allData.clear(); allData.push_back(CreateTwoValueLogEvent(tagId, bucket4StartTimeNs + 1, 2, 5)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket4StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); EXPECT_EQ(true, baseInfo2.hasBase); EXPECT_EQ(5, baseInfo2.base.long_value); EXPECT_EQ(false, interval2.hasValue); EXPECT_EQ(true, valueProducer->mHasGlobalBase); - EXPECT_EQ(2UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mPastBuckets.size()); allData.clear(); allData.push_back(CreateTwoValueLogEvent(tagId, bucket5StartTimeNs + 1, 2, 13)); allData.push_back(CreateTwoValueLogEvent(tagId, bucket5StartTimeNs + 1, 1, 5)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket5StartTimeNs); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); // Get new references now that entries have been deleted from the map const auto& it3 = valueProducer->mCurrentSlicedBucket.begin(); const auto& it4 = std::next(valueProducer->mCurrentSlicedBucket.begin()); - EXPECT_EQ(it3->second.size(), 1); - EXPECT_EQ(it4->second.size(), 1); + ASSERT_EQ(it3->second.size(), 1); + ASSERT_EQ(it4->second.size(), 1); ValueMetricProducer::Interval& interval3 = it3->second[0]; ValueMetricProducer::Interval& interval4 = it4->second[0]; ValueMetricProducer::BaseInfo& baseInfo3 = @@ -1794,7 +1794,7 @@ TEST(ValueMetricProducerTest, TestUseZeroDefaultBaseWithPullFailures) { EXPECT_EQ(false, interval4.hasValue); EXPECT_EQ(8, interval4.value.long_value); - EXPECT_EQ(2UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mPastBuckets.size()); } /* @@ -1817,7 +1817,7 @@ TEST(ValueMetricProducerTest, TestTrimUnusedDimensionKey) { sp valueProducer = ValueMetricProducerTestHelper::createValueProducerNoConditions(pullerManager, metric); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); auto iter = valueProducer->mCurrentSlicedBucket.begin(); auto& interval1 = iter->second[0]; auto iterBase = valueProducer->mCurrentBaseInfo.begin(); @@ -1826,7 +1826,7 @@ TEST(ValueMetricProducerTest, TestTrimUnusedDimensionKey) { EXPECT_EQ(true, baseInfo1.hasBase); EXPECT_EQ(3, baseInfo1.base.long_value); EXPECT_EQ(false, interval1.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); vector> allData; allData.clear(); @@ -1834,7 +1834,7 @@ TEST(ValueMetricProducerTest, TestTrimUnusedDimensionKey) { allData.push_back(CreateTwoValueLogEvent(tagId, bucket2StartTimeNs + 1, 1, 11)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); EXPECT_EQ(true, baseInfo1.hasBase); EXPECT_EQ(11, baseInfo1.base.long_value); EXPECT_EQ(false, interval1.hasValue); @@ -1870,7 +1870,7 @@ TEST(ValueMetricProducerTest, TestTrimUnusedDimensionKey) { allData.push_back(CreateTwoValueLogEvent(tagId, bucket4StartTimeNs + 1, 2, 5)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket4StartTimeNs); // Only one interval left. One was trimmed. - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); interval2 = valueProducer->mCurrentSlicedBucket.begin()->second[0]; baseInfo2 = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(2, it->first.getDimensionKeyInWhat().getValues()[0].mValue.int_value); @@ -1922,7 +1922,7 @@ TEST(ValueMetricProducerTest, TestResetBaseOnPullFailAfterConditionChange_EndOfB valueProducer->onConditionChanged(true, bucketStartTimeNs + 8); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo& curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -1932,7 +1932,7 @@ TEST(ValueMetricProducerTest, TestResetBaseOnPullFailAfterConditionChange_EndOfB vector> allData; valueProducer->onDataPulled(allData, /** succeed */ false, bucket2StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); EXPECT_EQ(false, curBaseInfo.hasBase); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(false, valueProducer->mHasGlobalBase); @@ -1957,19 +1957,19 @@ TEST(ValueMetricProducerTest, TestResetBaseOnPullFailAfterConditionChange) { valueProducer->onConditionChanged(true, bucketStartTimeNs + 8); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo& curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curBaseInfo.hasBase); EXPECT_EQ(100, curBaseInfo.base.long_value); EXPECT_EQ(false, curInterval.hasValue); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); valueProducer->onConditionChanged(false, bucketStartTimeNs + 20); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(false, curBaseInfo.hasBase); EXPECT_EQ(false, valueProducer->mHasGlobalBase); @@ -2001,10 +2001,10 @@ TEST(ValueMetricProducerTest, TestResetBaseOnPullFailBeforeConditionChange) { // valueProducer->mCondition = ConditionState::kTrue; valueProducer->onConditionChanged(true, bucketStartTimeNs); - EXPECT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); valueProducer->onConditionChanged(false, bucketStartTimeNs + 1); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -2034,7 +2034,7 @@ TEST(ValueMetricProducerTest, TestResetBaseOnPullDelayExceeded) { // Max delay is set to 0 so pull will exceed max delay. valueProducer->onConditionChanged(true, bucketStartTimeNs + 1); - EXPECT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); } TEST(ValueMetricProducerTest, TestResetBaseOnPullTooLate) { @@ -2060,7 +2060,7 @@ TEST(ValueMetricProducerTest, TestResetBaseOnPullTooLate) { // Event should be skipped since it is from previous bucket. // Pull should not be called. valueProducer.onConditionChanged(true, bucketStartTimeNs); - EXPECT_EQ(0UL, valueProducer.mCurrentSlicedBucket.size()); + ASSERT_EQ(0UL, valueProducer.mCurrentSlicedBucket.size()); } TEST(ValueMetricProducerTest, TestBaseSetOnConditionChange) { @@ -2083,7 +2083,7 @@ TEST(ValueMetricProducerTest, TestBaseSetOnConditionChange) { valueProducer->onConditionChanged(true, bucketStartTimeNs + 1); valueProducer->mHasGlobalBase = true; - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -2134,9 +2134,9 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenOneConditionFailed valueProducer->flushIfNeededLocked(bucket2StartTimeNs + 1); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); // Contains base from last pull which was successful. - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -2153,14 +2153,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenOneConditionFailed StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::PULL_FAILED, dropEvent.drop_reason()); @@ -2193,8 +2193,8 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenGuardRailHit) { valueProducer->onConditionChanged(true, bucketStartTimeNs + 2); EXPECT_EQ(true, valueProducer->mCurrentBucketIsInvalid); - EXPECT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); - EXPECT_EQ(0UL, valueProducer->mSkippedBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(0UL, valueProducer->mSkippedBuckets.size()); // Bucket 2 start. vector> allData; @@ -2203,7 +2203,7 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenGuardRailHit) { valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); // First bucket added to mSkippedBuckets after flush. - EXPECT_EQ(1UL, valueProducer->mSkippedBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mSkippedBuckets.size()); // Check dump report. ProtoOutputStream output; @@ -2213,14 +2213,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenGuardRailHit) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::DIMENSION_GUARDRAIL_REACHED, dropEvent.drop_reason()); @@ -2271,9 +2271,9 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenInitialPullFailed) valueProducer->flushIfNeededLocked(bucket2StartTimeNs + 1); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); // Contains base from last pull which was successful. - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -2290,14 +2290,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenInitialPullFailed) StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::PULL_FAILED, dropEvent.drop_reason()); @@ -2349,9 +2349,9 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenLastPullFailed) { valueProducer->flushIfNeededLocked(bucket2StartTimeNs + 1); - EXPECT_EQ(0UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mPastBuckets.size()); // Last pull failed so base has been reset. - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -2367,14 +2367,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenLastPullFailed) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::PULL_FAILED, dropEvent.drop_reason()); @@ -2401,16 +2401,16 @@ TEST(ValueMetricProducerTest, TestEmptyDataResetsBase_onDataPulled) { allData.clear(); allData.push_back(CreateRepeatedValueLogEvent(tagId, bucket2StartTimeNs + 1, 110)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); // Bucket 3 empty. allData.clear(); allData.push_back(CreateNoValuesLogEvent(tagId, bucket3StartTimeNs + 1)); valueProducer->onDataPulled(allData, /** succeed */ true, bucket3StartTimeNs); // Data has been trimmed. - EXPECT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(0UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); } TEST(ValueMetricProducerTest, TestEmptyDataResetsBase_onConditionChanged) { @@ -2435,7 +2435,7 @@ TEST(ValueMetricProducerTest, TestEmptyDataResetsBase_onConditionChanged) { ValueMetricProducerTestHelper::createValueProducerWithCondition(pullerManager, metric); valueProducer->onConditionChanged(true, bucketStartTimeNs + 10); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -2445,7 +2445,7 @@ TEST(ValueMetricProducerTest, TestEmptyDataResetsBase_onConditionChanged) { // Empty pull. valueProducer->onConditionChanged(false, bucketStartTimeNs + 10); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(false, curBaseInfo.hasBase); @@ -2484,7 +2484,7 @@ TEST(ValueMetricProducerTest, TestEmptyDataResetsBase_onBucketBoundary) { valueProducer->onConditionChanged(true, bucketStartTimeNs + 10); valueProducer->onConditionChanged(false, bucketStartTimeNs + 11); valueProducer->onConditionChanged(true, bucketStartTimeNs + 12); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval& curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -2496,7 +2496,7 @@ TEST(ValueMetricProducerTest, TestEmptyDataResetsBase_onBucketBoundary) { vector> allData; allData.clear(); valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; // Data is empty, base should be reset. @@ -2505,7 +2505,7 @@ TEST(ValueMetricProducerTest, TestEmptyDataResetsBase_onBucketBoundary) { EXPECT_EQ(false, curInterval.hasValue); EXPECT_EQ(true, valueProducer->mHasGlobalBase); - EXPECT_EQ(1UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(1UL, valueProducer->mPastBuckets.size()); assertPastBucketValuesSingleKey(valueProducer->mPastBuckets, {1}, {bucketSizeNs - 12 + 1}, {bucketStartTimeNs}, {bucket2StartTimeNs}); } @@ -2530,7 +2530,7 @@ TEST(ValueMetricProducerTest, TestPartialResetOnBucketBoundaries) { ValueMetricProducerTestHelper::createValueProducerWithCondition(pullerManager, metric); valueProducer->onConditionChanged(true, bucketStartTimeNs + 10); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); // End of bucket vector> allData; @@ -2539,7 +2539,7 @@ TEST(ValueMetricProducerTest, TestPartialResetOnBucketBoundaries) { valueProducer->onDataPulled(allData, /** succeed */ true, bucket2StartTimeNs); // Key 1 should be reset since in not present in the most pull. - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); auto iterator = valueProducer->mCurrentSlicedBucket.begin(); auto baseInfoIter = valueProducer->mCurrentBaseInfo.begin(); EXPECT_EQ(true, baseInfoIter->second[0].hasBase); @@ -2769,7 +2769,7 @@ TEST(ValueMetricProducerTest, TestDataIsNotUpdatedWhenNoConditionChanged) { valueProducer->onConditionChanged(false, bucketStartTimeNs + 10); valueProducer->onConditionChanged(false, bucketStartTimeNs + 12); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); auto curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; auto curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; EXPECT_EQ(true, curInterval.hasValue); @@ -2869,7 +2869,7 @@ TEST(ValueMetricProducerTest, TestPullNeededFastDump) { StatsLogReport report = outputStreamToProto(&output); // Bucket is invalid since we did not pull when dump report was called. - EXPECT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); } TEST(ValueMetricProducerTest, TestFastDumpWithoutCurrentBucket) { @@ -2912,7 +2912,7 @@ TEST(ValueMetricProducerTest, TestFastDumpWithoutCurrentBucket) { StatsLogReport report = outputStreamToProto(&output); // Previous bucket is part of the report. - EXPECT_EQ(1, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().data_size()); EXPECT_EQ(0, report.value_metrics().data(0).bucket_info(0).bucket_num()); } @@ -2957,8 +2957,8 @@ TEST(ValueMetricProducerTest, TestPullNeededNoTimeConstraints) { NO_TIME_CONSTRAINTS, &strSet, &output); StatsLogReport report = outputStreamToProto(&output); - EXPECT_EQ(1, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().data(0).bucket_info_size()); + ASSERT_EQ(1, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().data(0).bucket_info_size()); EXPECT_EQ(2, report.value_metrics().data(0).bucket_info(0).values(0).value_long()); } @@ -3006,7 +3006,7 @@ TEST(ValueMetricProducerTest, TestPulledData_noDiff_withMultipleConditionChanges valueProducer->onConditionChanged(true, bucketStartTimeNs + 8); valueProducer->onConditionChanged(false, bucketStartTimeNs + 50); // has one slice - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); ValueMetricProducer::Interval curInterval = valueProducer->mCurrentSlicedBucket.begin()->second[0]; ValueMetricProducer::BaseInfo curBaseInfo = valueProducer->mCurrentBaseInfo.begin()->second[0]; @@ -3145,14 +3145,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenDumpReportRequeste StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs + 40), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::DUMP_REPORT_REQUESTED, dropEvent.drop_reason()); @@ -3198,14 +3198,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenConditionEventWron StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(1, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(1, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs + 100), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::EVENT_IN_WRONG_BUCKET, dropEvent.drop_reason()); @@ -3261,14 +3261,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenAccumulateEventWro StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(1, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(1, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs + 100), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::EVENT_IN_WRONG_BUCKET, dropEvent.drop_reason()); @@ -3315,14 +3315,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenConditionUnknown) StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(dumpReportTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::CONDITION_UNKNOWN, dropEvent.drop_reason()); @@ -3363,14 +3363,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenPullFailed) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(dumpReportTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::PULL_FAILED, dropEvent.drop_reason()); @@ -3418,14 +3418,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestInvalidBucketWhenMultipleBucketsSki StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(bucket2StartTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::MULTIPLE_BUCKETS_SKIPPED, dropEvent.drop_reason()); @@ -3473,14 +3473,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestBucketDropWhenBucketTooSmall) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(dumpReportTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(1, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::BUCKET_TOO_SMALL, dropEvent.drop_reason()); @@ -3519,14 +3519,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestMultipleBucketDropEvents) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(dumpReportTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(2, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(2, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::CONDITION_UNKNOWN, dropEvent.drop_reason()); @@ -3602,14 +3602,14 @@ TEST(ValueMetricProducerTest_BucketDrop, TestMaxBucketDropEvents) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(0, report.value_metrics().data_size()); - EXPECT_EQ(1, report.value_metrics().skipped_size()); + ASSERT_EQ(0, report.value_metrics().data_size()); + ASSERT_EQ(1, report.value_metrics().skipped_size()); EXPECT_EQ(NanoToMillis(bucketStartTimeNs), report.value_metrics().skipped(0).start_bucket_elapsed_millis()); EXPECT_EQ(NanoToMillis(dumpReportTimeNs), report.value_metrics().skipped(0).end_bucket_elapsed_millis()); - EXPECT_EQ(10, report.value_metrics().skipped(0).drop_event_size()); + ASSERT_EQ(10, report.value_metrics().skipped(0).drop_event_size()); auto dropEvent = report.value_metrics().skipped(0).drop_event(0); EXPECT_EQ(BucketDropReason::CONDITION_UNKNOWN, dropEvent.drop_reason()); @@ -3710,7 +3710,7 @@ TEST(ValueMetricProducerTest, TestSlicedState) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(SCREEN_STATE_ATOM_ID)); // Bucket status after metric initialized. - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} auto it = valueProducer->mCurrentSlicedBucket.begin(); auto itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3723,7 +3723,7 @@ TEST(ValueMetricProducerTest, TestSlicedState) { auto screenEvent = CreateScreenStateChangedEvent( bucketStartTimeNs + 5, android::view::DisplayStateEnum::DISPLAY_STATE_ON); StateManager::getInstance().onLogEvent(*screenEvent); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} it = valueProducer->mCurrentSlicedBucket.begin(); itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3737,7 +3737,7 @@ TEST(ValueMetricProducerTest, TestSlicedState) { screenEvent = CreateScreenStateChangedEvent(bucketStartTimeNs + 10, android::view::DisplayStateEnum::DISPLAY_STATE_OFF); StateManager::getInstance().onLogEvent(*screenEvent); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} it = valueProducer->mCurrentSlicedBucket.begin(); itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3757,7 +3757,7 @@ TEST(ValueMetricProducerTest, TestSlicedState) { screenEvent = CreateScreenStateChangedEvent(bucketStartTimeNs + 15, android::view::DisplayStateEnum::DISPLAY_STATE_ON); StateManager::getInstance().onLogEvent(*screenEvent); - EXPECT_EQ(3UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(3UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} it = valueProducer->mCurrentSlicedBucket.begin(); itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3787,21 +3787,21 @@ TEST(ValueMetricProducerTest, TestSlicedState) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(3, report.value_metrics().data_size()); + ASSERT_EQ(3, report.value_metrics().data_size()); auto data = report.value_metrics().data(0); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(2, report.value_metrics().data(0).bucket_info(0).values(0).value_long()); data = report.value_metrics().data(1); - EXPECT_EQ(1, report.value_metrics().data(1).bucket_info_size()); + ASSERT_EQ(1, report.value_metrics().data(1).bucket_info_size()); EXPECT_EQ(13, report.value_metrics().data(1).bucket_info(0).values(0).value_long()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, data.slice_by_state(0).value()); data = report.value_metrics().data(2); - EXPECT_EQ(1, report.value_metrics().data(2).bucket_info_size()); + ASSERT_EQ(1, report.value_metrics().data(2).bucket_info_size()); EXPECT_EQ(12, report.value_metrics().data(2).bucket_info(0).values(0).value_long()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); @@ -3878,7 +3878,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithMap) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(SCREEN_STATE_ATOM_ID)); // Bucket status after metric initialized. - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} auto it = valueProducer->mCurrentSlicedBucket.begin(); auto itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3891,7 +3891,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithMap) { auto screenEvent = CreateScreenStateChangedEvent( bucketStartTimeNs + 5, android::view::DisplayStateEnum::DISPLAY_STATE_ON); StateManager::getInstance().onLogEvent(*screenEvent); - EXPECT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(1UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} it = valueProducer->mCurrentSlicedBucket.begin(); itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3905,7 +3905,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithMap) { screenEvent = CreateScreenStateChangedEvent(bucketStartTimeNs + 10, android::view::DisplayStateEnum::DISPLAY_STATE_VR); StateManager::getInstance().onLogEvent(*screenEvent); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} it = valueProducer->mCurrentSlicedBucket.begin(); itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3925,7 +3925,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithMap) { screenEvent = CreateScreenStateChangedEvent(bucketStartTimeNs + 15, android::view::DisplayStateEnum::DISPLAY_STATE_OFF); StateManager::getInstance().onLogEvent(*screenEvent); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {} it = valueProducer->mCurrentSlicedBucket.begin(); itBase = valueProducer->mCurrentBaseInfo.find(it->first.getDimensionKeyInWhat()); @@ -3949,21 +3949,21 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithMap) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(3, report.value_metrics().data_size()); + ASSERT_EQ(3, report.value_metrics().data_size()); auto data = report.value_metrics().data(0); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(2, report.value_metrics().data(0).bucket_info(0).values(0).value_long()); data = report.value_metrics().data(1); - EXPECT_EQ(1, report.value_metrics().data(1).bucket_info_size()); + ASSERT_EQ(1, report.value_metrics().data(1).bucket_info_size()); EXPECT_EQ(16, report.value_metrics().data(1).bucket_info(0).values(0).value_long()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); EXPECT_EQ(screenOnGroup.group_id(), data.slice_by_state(0).group_id()); data = report.value_metrics().data(2); - EXPECT_EQ(1, report.value_metrics().data(2).bucket_info_size()); + ASSERT_EQ(1, report.value_metrics().data(2).bucket_info_size()); EXPECT_EQ(9, report.value_metrics().data(2).bucket_info(0).values(0).value_long()); EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_group_id()); @@ -4069,7 +4069,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { EXPECT_EQ(1, StateManager::getInstance().getListenersCount(UID_PROCESS_STATE_ATOM_ID)); // Bucket status after metric initialized. - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {uid 1}. auto it = valueProducer->mCurrentSlicedBucket.begin(); EXPECT_EQ(1, it->first.getDimensionKeyInWhat().getValues()[0].mValue.int_value); @@ -4094,7 +4094,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { auto uidProcessEvent = CreateUidProcessStateChangedEvent( bucketStartTimeNs + 20, 1 /* uid */, android::app::PROCESS_STATE_IMPORTANT_FOREGROUND); StateManager::getInstance().onLogEvent(*uidProcessEvent); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {uid 1}. it = valueProducer->mCurrentSlicedBucket.begin(); EXPECT_EQ(1, it->first.getDimensionKeyInWhat().getValues()[0].mValue.int_value); @@ -4121,7 +4121,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { uidProcessEvent = CreateUidProcessStateChangedEvent( bucketStartTimeNs + 40, 2 /* uid */, android::app::PROCESS_STATE_IMPORTANT_BACKGROUND); StateManager::getInstance().onLogEvent(*uidProcessEvent); - EXPECT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentSlicedBucket.size()); // Base for dimension key {uid 1}. it = valueProducer->mCurrentSlicedBucket.begin(); EXPECT_EQ(1, it->first.getDimensionKeyInWhat().getValues()[0].mValue.int_value); @@ -4151,9 +4151,9 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { // Buckets flushed after end of first bucket. // None of the buckets should have a value. - EXPECT_EQ(4UL, valueProducer->mCurrentSlicedBucket.size()); - EXPECT_EQ(4UL, valueProducer->mPastBuckets.size()); - EXPECT_EQ(2UL, valueProducer->mCurrentBaseInfo.size()); + ASSERT_EQ(4UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(4UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentBaseInfo.size()); // Base for dimension key {uid 2}. it = valueProducer->mCurrentSlicedBucket.begin(); EXPECT_EQ(2, it->first.getDimensionKeyInWhat().getValues()[0].mValue.int_value); @@ -4161,7 +4161,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { EXPECT_EQ(true, itBase->second[0].hasBase); EXPECT_EQ(15, itBase->second[0].base.long_value); // Value for key {uid 2, BACKGROUND}. - EXPECT_EQ(1, it->first.getStateValuesKey().getValues().size()); + ASSERT_EQ(1, it->first.getStateValuesKey().getValues().size()); EXPECT_EQ(1006, it->first.getStateValuesKey().getValues()[0].mValue.int_value); EXPECT_EQ(false, it->second[0].hasValue); @@ -4172,13 +4172,13 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { EXPECT_EQ(true, itBase->second[0].hasBase); EXPECT_EQ(10, itBase->second[0].base.long_value); // Value for key {uid 1, kStateUnknown} - EXPECT_EQ(0, it->first.getStateValuesKey().getValues().size()); + ASSERT_EQ(0, it->first.getStateValuesKey().getValues().size()); // EXPECT_EQ(-1, it->first.getStateValuesKey().getValues()[0].mValue.int_value); EXPECT_EQ(false, it->second[0].hasValue); // Value for key {uid 1, FOREGROUND} it++; - EXPECT_EQ(1, it->first.getStateValuesKey().getValues().size()); + ASSERT_EQ(1, it->first.getStateValuesKey().getValues().size()); EXPECT_EQ(1005, it->first.getStateValuesKey().getValues()[0].mValue.int_value); EXPECT_EQ(false, it->second[0].hasValue); @@ -4191,9 +4191,9 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { bucket2StartTimeNs + 20, 1 /* uid */, android::app::PROCESS_STATE_IMPORTANT_BACKGROUND); StateManager::getInstance().onLogEvent(*uidProcessEvent); - EXPECT_EQ(4UL, valueProducer->mCurrentSlicedBucket.size()); - EXPECT_EQ(4UL, valueProducer->mPastBuckets.size()); - EXPECT_EQ(2UL, valueProducer->mCurrentBaseInfo.size()); + ASSERT_EQ(4UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(4UL, valueProducer->mPastBuckets.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentBaseInfo.size()); // Base for dimension key {uid 2}. it = valueProducer->mCurrentSlicedBucket.begin(); EXPECT_EQ(2, it->first.getDimensionKeyInWhat().getValues()[0].mValue.int_value); @@ -4225,8 +4225,8 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { bucket2StartTimeNs + 40, 1 /* uid */, android::app::PROCESS_STATE_IMPORTANT_FOREGROUND); StateManager::getInstance().onLogEvent(*uidProcessEvent); - EXPECT_EQ(5UL, valueProducer->mCurrentSlicedBucket.size()); - EXPECT_EQ(2UL, valueProducer->mCurrentBaseInfo.size()); + ASSERT_EQ(5UL, valueProducer->mCurrentSlicedBucket.size()); + ASSERT_EQ(2UL, valueProducer->mCurrentBaseInfo.size()); // Base for dimension key {uid 2} it = valueProducer->mCurrentSlicedBucket.begin(); EXPECT_EQ(2, it->first.getDimensionKeyInWhat().getValues()[0].mValue.int_value); @@ -4261,10 +4261,10 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { StatsLogReport report = outputStreamToProto(&output); EXPECT_TRUE(report.has_value_metrics()); - EXPECT_EQ(5, report.value_metrics().data_size()); + ASSERT_EQ(5, report.value_metrics().data_size()); auto data = report.value_metrics().data(0); - EXPECT_EQ(1, data.bucket_info_size()); + ASSERT_EQ(1, data.bucket_info_size()); EXPECT_EQ(4, report.value_metrics().data(0).bucket_info(0).values(0).value_long()); EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id()); EXPECT_TRUE(data.slice_by_state(0).has_value()); @@ -4272,7 +4272,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { data.slice_by_state(0).value()); data = report.value_metrics().data(1); - EXPECT_EQ(1, report.value_metrics().data(1).bucket_info_size()); + ASSERT_EQ(1, report.value_metrics().data(1).bucket_info_size()); EXPECT_EQ(2, report.value_metrics().data(1).bucket_info(0).values(0).value_long()); data = report.value_metrics().data(2); @@ -4280,12 +4280,12 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND, data.slice_by_state(0).value()); - EXPECT_EQ(2, report.value_metrics().data(2).bucket_info_size()); + ASSERT_EQ(2, report.value_metrics().data(2).bucket_info_size()); EXPECT_EQ(4, report.value_metrics().data(2).bucket_info(0).values(0).value_long()); EXPECT_EQ(7, report.value_metrics().data(2).bucket_info(1).values(0).value_long()); data = report.value_metrics().data(3); - EXPECT_EQ(1, report.value_metrics().data(3).bucket_info_size()); + ASSERT_EQ(1, report.value_metrics().data(3).bucket_info_size()); EXPECT_EQ(3, report.value_metrics().data(3).bucket_info(0).values(0).value_long()); data = report.value_metrics().data(4); @@ -4293,7 +4293,7 @@ TEST(ValueMetricProducerTest, TestSlicedStateWithPrimaryField_WithDimensions) { EXPECT_TRUE(data.slice_by_state(0).has_value()); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND, data.slice_by_state(0).value()); - EXPECT_EQ(2, report.value_metrics().data(4).bucket_info_size()); + ASSERT_EQ(2, report.value_metrics().data(4).bucket_info_size()); EXPECT_EQ(6, report.value_metrics().data(4).bucket_info(0).values(0).value_long()); EXPECT_EQ(5, report.value_metrics().data(4).bucket_info(1).values(0).value_long()); } diff --git a/cmds/statsd/tests/state/StateTracker_test.cpp b/cmds/statsd/tests/state/StateTracker_test.cpp index ba2a4cfbe8fde..13e8f5c343f24 100644 --- a/cmds/statsd/tests/state/StateTracker_test.cpp +++ b/cmds/statsd/tests/state/StateTracker_test.cpp @@ -205,7 +205,7 @@ TEST(StateTrackerTest, TestStateChangeNested) { std::unique_ptr event1 = CreateAcquireWakelockEvent(timestampNs, attributionUids1, attributionTags1, "wakelockName"); mgr.onLogEvent(*event1); - EXPECT_EQ(1, listener->updates.size()); + ASSERT_EQ(1, listener->updates.size()); EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(1, listener->updates[0].mState); listener->updates.clear(); @@ -213,17 +213,17 @@ TEST(StateTrackerTest, TestStateChangeNested) { std::unique_ptr event2 = CreateAcquireWakelockEvent( timestampNs + 1000, attributionUids1, attributionTags1, "wakelockName"); mgr.onLogEvent(*event2); - EXPECT_EQ(0, listener->updates.size()); + ASSERT_EQ(0, listener->updates.size()); std::unique_ptr event3 = CreateReleaseWakelockEvent( timestampNs + 2000, attributionUids1, attributionTags1, "wakelockName"); mgr.onLogEvent(*event3); - EXPECT_EQ(0, listener->updates.size()); + ASSERT_EQ(0, listener->updates.size()); std::unique_ptr event4 = CreateReleaseWakelockEvent( timestampNs + 3000, attributionUids1, attributionTags1, "wakelockName"); mgr.onLogEvent(*event4); - EXPECT_EQ(1, listener->updates.size()); + ASSERT_EQ(1, listener->updates.size()); EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(0, listener->updates[0].mState); } @@ -247,7 +247,7 @@ TEST(StateTrackerTest, TestStateChangeReset) { CreateBleScanStateChangedEvent(timestampNs, attributionUids1, attributionTags1, BleScanStateChanged::ON, false, false, false); mgr.onLogEvent(*event1); - EXPECT_EQ(1, listener->updates.size()); + ASSERT_EQ(1, listener->updates.size()); EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState); FieldValue stateFieldValue; @@ -259,7 +259,7 @@ TEST(StateTrackerTest, TestStateChangeReset) { CreateBleScanStateChangedEvent(timestampNs + 1000, attributionUids2, attributionTags1, BleScanStateChanged::ON, false, false, false); mgr.onLogEvent(*event2); - EXPECT_EQ(1, listener->updates.size()); + ASSERT_EQ(1, listener->updates.size()); EXPECT_EQ(2000, listener->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState); mgr.getStateValue(util::BLE_SCAN_STATE_CHANGED, listener->updates[0].mKey, &stateFieldValue); @@ -270,7 +270,7 @@ TEST(StateTrackerTest, TestStateChangeReset) { CreateBleScanStateChangedEvent(timestampNs + 2000, attributionUids2, attributionTags1, BleScanStateChanged::RESET, false, false, false); mgr.onLogEvent(*event3); - EXPECT_EQ(2, listener->updates.size()); + ASSERT_EQ(2, listener->updates.size()); for (const TestStateListener::Update& update : listener->updates) { EXPECT_EQ(BleScanStateChanged::OFF, update.mState); @@ -294,7 +294,7 @@ TEST(StateTrackerTest, TestStateChangeNoPrimaryFields) { mgr.onLogEvent(*event); // check listener was updated - EXPECT_EQ(1, listener1->updates.size()); + ASSERT_EQ(1, listener1->updates.size()); EXPECT_EQ(DEFAULT_DIMENSION_KEY, listener1->updates[0].mKey); EXPECT_EQ(2, listener1->updates[0].mState); @@ -319,7 +319,7 @@ TEST(StateTrackerTest, TestStateChangeOnePrimaryField) { mgr.onLogEvent(*event); // check listener was updated - EXPECT_EQ(1, listener1->updates.size()); + ASSERT_EQ(1, listener1->updates.size()); EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(1002, listener1->updates[0].mState); @@ -346,8 +346,8 @@ TEST(StateTrackerTest, TestStateChangePrimaryFieldAttrChain) { EXPECT_EQ(1, mgr.getListenersCount(util::WAKELOCK_STATE_CHANGED)); // Check listener was updated. - EXPECT_EQ(1, listener1->updates.size()); - EXPECT_EQ(3, listener1->updates[0].mKey.getValues().size()); + ASSERT_EQ(1, listener1->updates.size()); + ASSERT_EQ(3, listener1->updates[0].mKey.getValues().size()); EXPECT_EQ(1001, listener1->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(1, listener1->updates[0].mKey.getValues()[1].mValue.int_value); EXPECT_EQ("wakelockName", listener1->updates[0].mKey.getValues()[2].mValue.str_value); @@ -388,7 +388,7 @@ TEST(StateTrackerTest, TestStateChangeMultiplePrimaryFields) { mgr.onLogEvent(*event); // check listener was updated - EXPECT_EQ(1, listener1->updates.size()); + ASSERT_EQ(1, listener1->updates.size()); EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(1, listener1->updates[0].mState); @@ -416,9 +416,9 @@ TEST(StateTrackerTest, TestStateChangeEventError) { // check listener was updated mgr.onLogEvent(*event1); - EXPECT_EQ(0, listener1->updates.size()); + ASSERT_EQ(0, listener1->updates.size()); mgr.onLogEvent(*event2); - EXPECT_EQ(0, listener1->updates.size()); + ASSERT_EQ(0, listener1->updates.size()); } TEST(StateTrackerTest, TestStateQuery) { diff --git a/cmds/statsd/tests/statsd_test_util.cpp b/cmds/statsd/tests/statsd_test_util.cpp index 2315fd7243bc7..fae56f09c1dfc 100644 --- a/cmds/statsd/tests/statsd_test_util.cpp +++ b/cmds/statsd/tests/statsd_test_util.cpp @@ -956,11 +956,11 @@ int64_t StringToId(const string& str) { void ValidateWakelockAttributionUidAndTagDimension(const DimensionsValue& value, const int atomId, const int uid, const string& tag) { EXPECT_EQ(value.field(), atomId); - EXPECT_EQ(value.value_tuple().dimensions_value_size(), 2); + ASSERT_EQ(value.value_tuple().dimensions_value_size(), 2); // Attribution field. EXPECT_EQ(value.value_tuple().dimensions_value(0).field(), 1); // Uid field. - EXPECT_EQ(value.value_tuple().dimensions_value(0).value_tuple().dimensions_value_size(), 1); + ASSERT_EQ(value.value_tuple().dimensions_value(0).value_tuple().dimensions_value_size(), 1); EXPECT_EQ(value.value_tuple().dimensions_value(0).value_tuple().dimensions_value(0).field(), 1); EXPECT_EQ(value.value_tuple().dimensions_value(0).value_tuple().dimensions_value(0).value_int(), uid); @@ -971,7 +971,7 @@ void ValidateWakelockAttributionUidAndTagDimension(const DimensionsValue& value, void ValidateAttributionUidDimension(const DimensionsValue& value, int atomId, int uid) { EXPECT_EQ(value.field(), atomId); - EXPECT_EQ(value.value_tuple().dimensions_value_size(), 1); + ASSERT_EQ(value.value_tuple().dimensions_value_size(), 1); // Attribution field. EXPECT_EQ(value.value_tuple().dimensions_value(0).field(), 1); // Uid only. @@ -985,7 +985,7 @@ void ValidateAttributionUidDimension(const DimensionsValue& value, int atomId, i void ValidateUidDimension(const DimensionsValue& value, int node_idx, int atomId, int uid) { EXPECT_EQ(value.field(), atomId); - EXPECT_GT(value.value_tuple().dimensions_value_size(), node_idx); + ASSERT_GT(value.value_tuple().dimensions_value_size(), node_idx); // Attribution field. EXPECT_EQ(value.value_tuple().dimensions_value(node_idx).field(), 1); EXPECT_EQ(value.value_tuple().dimensions_value(node_idx) @@ -997,7 +997,7 @@ void ValidateUidDimension(const DimensionsValue& value, int node_idx, int atomId void ValidateAttributionUidAndTagDimension( const DimensionsValue& value, int node_idx, int atomId, int uid, const std::string& tag) { EXPECT_EQ(value.field(), atomId); - EXPECT_GT(value.value_tuple().dimensions_value_size(), node_idx); + ASSERT_GT(value.value_tuple().dimensions_value_size(), node_idx); // Attribution field. EXPECT_EQ(1, value.value_tuple().dimensions_value(node_idx).field()); // Uid only. @@ -1016,7 +1016,7 @@ void ValidateAttributionUidAndTagDimension( void ValidateAttributionUidAndTagDimension( const DimensionsValue& value, int atomId, int uid, const std::string& tag) { EXPECT_EQ(value.field(), atomId); - EXPECT_EQ(1, value.value_tuple().dimensions_value_size()); + ASSERT_EQ(1, value.value_tuple().dimensions_value_size()); // Attribution field. EXPECT_EQ(1, value.value_tuple().dimensions_value(0).field()); // Uid only. diff --git a/cmds/statsd/tests/storage/StorageManager_test.cpp b/cmds/statsd/tests/storage/StorageManager_test.cpp index 27a86e4230d8d..74eafbf56d667 100644 --- a/cmds/statsd/tests/storage/StorageManager_test.cpp +++ b/cmds/statsd/tests/storage/StorageManager_test.cpp @@ -49,10 +49,10 @@ TEST(StorageManagerTest, TrainInfoReadWriteTest) { EXPECT_TRUE(result); EXPECT_EQ(trainInfo.trainVersionCode, trainInfoResult.trainVersionCode); - EXPECT_EQ(trainInfo.trainName.size(), trainInfoResult.trainName.size()); + ASSERT_EQ(trainInfo.trainName.size(), trainInfoResult.trainName.size()); EXPECT_EQ(trainInfo.trainName, trainInfoResult.trainName); EXPECT_EQ(trainInfo.status, trainInfoResult.status); - EXPECT_EQ(trainInfo.experimentIds.size(), trainInfoResult.experimentIds.size()); + ASSERT_EQ(trainInfo.experimentIds.size(), trainInfoResult.experimentIds.size()); EXPECT_EQ(trainInfo.experimentIds, trainInfoResult.experimentIds); } @@ -75,10 +75,10 @@ TEST(StorageManagerTest, TrainInfoReadWriteTrainNameSizeOneTest) { EXPECT_TRUE(result); EXPECT_EQ(trainInfo.trainVersionCode, trainInfoResult.trainVersionCode); - EXPECT_EQ(trainInfo.trainName.size(), trainInfoResult.trainName.size()); + ASSERT_EQ(trainInfo.trainName.size(), trainInfoResult.trainName.size()); EXPECT_EQ(trainInfo.trainName, trainInfoResult.trainName); EXPECT_EQ(trainInfo.status, trainInfoResult.status); - EXPECT_EQ(trainInfo.experimentIds.size(), trainInfoResult.experimentIds.size()); + ASSERT_EQ(trainInfo.experimentIds.size(), trainInfoResult.experimentIds.size()); EXPECT_EQ(trainInfo.experimentIds, trainInfoResult.experimentIds); }