cmds/statsd/tests/StatsLogProcessor_test.cpp - platform/frameworks/base - Gitiles

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

 #include "StatsLogProcessor.h"
 #include "config/ConfigKey.h"
 #include "frameworks/base/cmds/statsd/src/stats_log.pb.h"
 #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
 #include "guardrail/StatsdStats.h"
 #include "logd/LogEvent.h"
 #include "packages/UidMap.h"
 #include "statslog.h"

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include "tests/statsd_test_util.h"

 #include <stdio.h>

 using namespace android;
 using namespace testing;

 namespace android {
 namespace os {
 namespace statsd {

 using android::util::ProtoOutputStream;

 #ifdef __ANDROID__

 /**
  * Mock MetricsManager (ByteSize() is called).
  */
 class MockMetricsManager : public MetricsManager {
 public:
     MockMetricsManager() : MetricsManager(
         ConfigKey(1, 12345), StatsdConfig(), 1000, 1000,
         new UidMap(),
         new AlarmMonitor(10, [](const sp<IStatsCompanionService>&, int64_t){},
                          [](const sp<IStatsCompanionService>&){}),
         new AlarmMonitor(10, [](const sp<IStatsCompanionService>&, int64_t){},
                          [](const sp<IStatsCompanionService>&){})) {
     }

     MOCK_METHOD0(byteSize, size_t());

     MOCK_METHOD1(dropData, void(const int64_t dropTimeNs));
 };

 TEST(StatsLogProcessorTest, TestRateLimitByteSize) {
     sp<UidMap> m = new UidMap();
     sp<AlarmMonitor> anomalyAlarmMonitor;
     sp<AlarmMonitor> periodicAlarmMonitor;
     // Construct the processor with a dummy sendBroadcast function that does nothing.
     StatsLogProcessor p(m, anomalyAlarmMonitor, periodicAlarmMonitor, 0,
         [](const ConfigKey& key) {return true;});

     MockMetricsManager mockMetricsManager;

     ConfigKey key(100, 12345);
     // Expect only the first flush to trigger a check for byte size since the last two are
     // rate-limited.
     EXPECT_CALL(mockMetricsManager, byteSize()).Times(1);
     p.flushIfNecessaryLocked(99, key, mockMetricsManager);
     p.flushIfNecessaryLocked(100, key, mockMetricsManager);
     p.flushIfNecessaryLocked(101, key, mockMetricsManager);
 }

 TEST(StatsLogProcessorTest, TestRateLimitBroadcast) {
     sp<UidMap> m = new UidMap();
     sp<AlarmMonitor> anomalyAlarmMonitor;
     sp<AlarmMonitor> subscriberAlarmMonitor;
     int broadcastCount = 0;
     StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
                         [&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});

     MockMetricsManager mockMetricsManager;

     ConfigKey key(100, 12345);
     EXPECT_CALL(mockMetricsManager, byteSize())
             .Times(1)
             .WillRepeatedly(Return(int(StatsdStats::kMaxMetricsBytesPerConfig * .95)));

     // Expect only one broadcast despite always returning a size that should trigger broadcast.
     p.flushIfNecessaryLocked(1, key, mockMetricsManager);
     EXPECT_EQ(1, broadcastCount);

     // b/73089712
     // This next call to flush should not trigger a broadcast.
     // p.mLastByteSizeTimes.clear();  // Force another check for byte size.
     // p.flushIfNecessaryLocked(2, key, mockMetricsManager);
     // EXPECT_EQ(1, broadcastCount);
 }

 TEST(StatsLogProcessorTest, TestDropWhenByteSizeTooLarge) {
     sp<UidMap> m = new UidMap();
     sp<AlarmMonitor> anomalyAlarmMonitor;
     sp<AlarmMonitor> subscriberAlarmMonitor;
     int broadcastCount = 0;
     StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
                         [&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});

     MockMetricsManager mockMetricsManager;

     ConfigKey key(100, 12345);
     EXPECT_CALL(mockMetricsManager, byteSize())
             .Times(1)
             .WillRepeatedly(Return(int(StatsdStats::kMaxMetricsBytesPerConfig * 1.2)));

     EXPECT_CALL(mockMetricsManager, dropData(_)).Times(1);

     // Expect to call the onDumpReport and skip the broadcast.
     p.flushIfNecessaryLocked(1, key, mockMetricsManager);
     EXPECT_EQ(0, broadcastCount);
 }

 StatsdConfig MakeConfig(bool includeMetric) {
     StatsdConfig config;
     config.add_allowed_log_source("AID_ROOT");  // LogEvent defaults to UID of root.

     if (includeMetric) {
         auto appCrashMatcher = CreateProcessCrashAtomMatcher();
         *config.add_atom_matcher() = appCrashMatcher;
         auto countMetric = config.add_count_metric();
         countMetric->set_id(StringToId("AppCrashes"));
         countMetric->set_what(appCrashMatcher.id());
         countMetric->set_bucket(FIVE_MINUTES);
     }
     return config;
 }

 TEST(StatsLogProcessorTest, TestUidMapHasSnapshot) {
     // Setup simple config key corresponding to empty config.
     sp<UidMap> m = new UidMap();
     m->updateMap(1, {1, 2}, {1, 2}, {String16("p1"), String16("p2")});
     sp<AlarmMonitor> anomalyAlarmMonitor;
     sp<AlarmMonitor> subscriberAlarmMonitor;
     int broadcastCount = 0;
     StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
                         [&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});
     ConfigKey key(3, 4);
     StatsdConfig config = MakeConfig(true);
     p.OnConfigUpdated(0, key, config);

     // Expect to get no metrics, but snapshot specified above in uidmap.
     vector<uint8_t> bytes;
     p.onDumpReport(key, 1, false, ADB_DUMP, &bytes);

     ConfigMetricsReportList output;
     output.ParseFromArray(bytes.data(), bytes.size());
     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());
 }

 TEST(StatsLogProcessorTest, TestEmptyConfigHasNoUidMap) {
     // Setup simple config key corresponding to empty config.
     sp<UidMap> m = new UidMap();
     m->updateMap(1, {1, 2}, {1, 2}, {String16("p1"), String16("p2")});
     sp<AlarmMonitor> anomalyAlarmMonitor;
     sp<AlarmMonitor> subscriberAlarmMonitor;
     int broadcastCount = 0;
     StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
                         [&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});
     ConfigKey key(3, 4);
     StatsdConfig config = MakeConfig(false);
     p.OnConfigUpdated(0, key, config);

     // Expect to get no metrics, but snapshot specified above in uidmap.
     vector<uint8_t> bytes;
     p.onDumpReport(key, 1, false, ADB_DUMP, &bytes);

     ConfigMetricsReportList output;
     output.ParseFromArray(bytes.data(), bytes.size());
     EXPECT_TRUE(output.reports_size() > 0);
     EXPECT_FALSE(output.reports(0).has_uid_map());
 }

 TEST(StatsLogProcessorTest, TestReportIncludesSubConfig) {
     // Setup simple config key corresponding to empty config.
     sp<UidMap> m = new UidMap();
     sp<AlarmMonitor> anomalyAlarmMonitor;
     sp<AlarmMonitor> subscriberAlarmMonitor;
     int broadcastCount = 0;
     StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
                         [&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});
     ConfigKey key(3, 4);
     StatsdConfig config;
     auto annotation = config.add_annotation();
     annotation->set_field_int64(1);
     annotation->set_field_int32(2);
     config.add_allowed_log_source("AID_ROOT");
     p.OnConfigUpdated(1, key, config);

     // Expect to get no metrics, but snapshot specified above in uidmap.
     vector<uint8_t> bytes;
     p.onDumpReport(key, 1, false, ADB_DUMP, &bytes);

     ConfigMetricsReportList output;
     output.ParseFromArray(bytes.data(), bytes.size());
     EXPECT_TRUE(output.reports_size() > 0);
     auto report = output.reports(0);
     EXPECT_EQ(1, report.annotation_size());
     EXPECT_EQ(1, report.annotation(0).field_int64());
     EXPECT_EQ(2, report.annotation(0).field_int32());
 }

 TEST(StatsLogProcessorTest, TestOutOfOrderLogs) {
     // Setup simple config key corresponding to empty config.
     sp<UidMap> m = new UidMap();
     sp<AlarmMonitor> anomalyAlarmMonitor;
     sp<AlarmMonitor> subscriberAlarmMonitor;
     int broadcastCount = 0;
     StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
                         [&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});

     LogEvent event1(0, 1 /*logd timestamp*/, 1001 /*elapsedRealtime*/);
     event1.init();

     LogEvent event2(0, 2, 1002);
     event2.init();

     LogEvent event3(0, 3, 1005);
     event3.init();

     LogEvent event4(0, 4, 1004);
     event4.init();

     // <----- Reconnection happens

     LogEvent event5(0, 5, 999);
     event5.init();

     LogEvent event6(0, 6, 2000);
     event6.init();

     // <----- Reconnection happens

     LogEvent event7(0, 7, 3000);
     event7.init();

     // first event ever
     p.OnLogEvent(&event1, true);
     EXPECT_EQ(1UL, p.mLogCount);
     EXPECT_EQ(1001LL, p.mLargestTimestampSeen);
     EXPECT_EQ(1001LL, p.mLastTimestampSeen);

     p.OnLogEvent(&event2, false);
     EXPECT_EQ(2UL, p.mLogCount);
     EXPECT_EQ(1002LL, p.mLargestTimestampSeen);
     EXPECT_EQ(1002LL, p.mLastTimestampSeen);

     p.OnLogEvent(&event3, false);
     EXPECT_EQ(3UL, p.mLogCount);
     EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
     EXPECT_EQ(1005LL, p.mLastTimestampSeen);

     p.OnLogEvent(&event4, false);
     EXPECT_EQ(4UL, p.mLogCount);
     EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
     EXPECT_EQ(1004LL, p.mLastTimestampSeen);
     EXPECT_FALSE(p.mInReconnection);

     // Reconnect happens, event1 out of buffer. Read event2
     p.OnLogEvent(&event2, true);
     EXPECT_EQ(4UL, p.mLogCount);
     EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
     EXPECT_EQ(1004LL, p.mLastTimestampSeen);
     EXPECT_TRUE(p.mInReconnection);

     p.OnLogEvent(&event3, false);
     EXPECT_EQ(4UL, p.mLogCount);
     EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
     EXPECT_EQ(1004LL, p.mLastTimestampSeen);
     EXPECT_TRUE(p.mInReconnection);

     p.OnLogEvent(&event4, false);
     EXPECT_EQ(4UL, p.mLogCount);
     EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
     EXPECT_EQ(1004LL, p.mLastTimestampSeen);
     EXPECT_FALSE(p.mInReconnection);

     // Fresh event comes.
     p.OnLogEvent(&event5, false);
     EXPECT_EQ(5UL, p.mLogCount);
     EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
     EXPECT_EQ(999LL, p.mLastTimestampSeen);

     p.OnLogEvent(&event6, false);
     EXPECT_EQ(6UL, p.mLogCount);
     EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
     EXPECT_EQ(2000LL, p.mLastTimestampSeen);

     // Reconnect happens, read from event4
     p.OnLogEvent(&event4, true);
     EXPECT_EQ(6UL, p.mLogCount);
     EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
     EXPECT_EQ(2000LL, p.mLastTimestampSeen);
     EXPECT_TRUE(p.mInReconnection);

     p.OnLogEvent(&event5, false);
     EXPECT_EQ(6UL, p.mLogCount);
     EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
     EXPECT_EQ(2000LL, p.mLastTimestampSeen);
     EXPECT_TRUE(p.mInReconnection);

     // Before we get out of reconnection state, it reconnects again.
     p.OnLogEvent(&event5, true);
     EXPECT_EQ(6UL, p.mLogCount);
     EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
     EXPECT_EQ(2000LL, p.mLastTimestampSeen);
     EXPECT_TRUE(p.mInReconnection);

     p.OnLogEvent(&event6, false);
     EXPECT_EQ(6UL, p.mLogCount);
     EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
     EXPECT_EQ(2000LL, p.mLastTimestampSeen);
     EXPECT_FALSE(p.mInReconnection);
     EXPECT_EQ(0, p.mLogLossCount);

     // it reconnects again. All old events are gone. We lose CP.
     p.OnLogEvent(&event7, true);
     EXPECT_EQ(7UL, p.mLogCount);
     EXPECT_EQ(3000LL, p.mLargestTimestampSeen);
     EXPECT_EQ(3000LL, p.mLastTimestampSeen);
     EXPECT_EQ(1, p.mLogLossCount);
     EXPECT_FALSE(p.mInReconnection);
 }

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

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

	#include "StatsLogProcessor.h"
	#include "config/ConfigKey.h"
	#include "frameworks/base/cmds/statsd/src/stats_log.pb.h"
	#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
	#include "guardrail/StatsdStats.h"
	#include "logd/LogEvent.h"
	#include "packages/UidMap.h"
	#include "statslog.h"

	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include "tests/statsd_test_util.h"

	#include <stdio.h>

	using namespace android;
	using namespace testing;

	namespace android {
	namespace os {
	namespace statsd {

	using android::util::ProtoOutputStream;

	#ifdef __ANDROID__

	/**
	* Mock MetricsManager (ByteSize() is called).
	*/
	class MockMetricsManager : public MetricsManager {
	public:
	MockMetricsManager() : MetricsManager(
	ConfigKey(1, 12345), StatsdConfig(), 1000, 1000,
	new UidMap(),
	new AlarmMonitor(10, [](const sp<IStatsCompanionService>&, int64_t){},
	[](const sp<IStatsCompanionService>&){}),
	new AlarmMonitor(10, [](const sp<IStatsCompanionService>&, int64_t){},
	[](const sp<IStatsCompanionService>&){})) {
	}

	MOCK_METHOD0(byteSize, size_t());

	MOCK_METHOD1(dropData, void(const int64_t dropTimeNs));
	};

	TEST(StatsLogProcessorTest, TestRateLimitByteSize) {
	sp<UidMap> m = new UidMap();
	sp<AlarmMonitor> anomalyAlarmMonitor;
	sp<AlarmMonitor> periodicAlarmMonitor;
	// Construct the processor with a dummy sendBroadcast function that does nothing.
	StatsLogProcessor p(m, anomalyAlarmMonitor, periodicAlarmMonitor, 0,
	[](const ConfigKey& key) {return true;});

	MockMetricsManager mockMetricsManager;

	ConfigKey key(100, 12345);
	// Expect only the first flush to trigger a check for byte size since the last two are
	// rate-limited.
	EXPECT_CALL(mockMetricsManager, byteSize()).Times(1);
	p.flushIfNecessaryLocked(99, key, mockMetricsManager);
	p.flushIfNecessaryLocked(100, key, mockMetricsManager);
	p.flushIfNecessaryLocked(101, key, mockMetricsManager);
	}

	TEST(StatsLogProcessorTest, TestRateLimitBroadcast) {
	sp<UidMap> m = new UidMap();
	sp<AlarmMonitor> anomalyAlarmMonitor;
	sp<AlarmMonitor> subscriberAlarmMonitor;
	int broadcastCount = 0;
	StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
	[&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});

	MockMetricsManager mockMetricsManager;

	ConfigKey key(100, 12345);
	EXPECT_CALL(mockMetricsManager, byteSize())
	.Times(1)
	.WillRepeatedly(Return(int(StatsdStats::kMaxMetricsBytesPerConfig * .95)));

	// Expect only one broadcast despite always returning a size that should trigger broadcast.
	p.flushIfNecessaryLocked(1, key, mockMetricsManager);
	EXPECT_EQ(1, broadcastCount);

	// b/73089712
	// This next call to flush should not trigger a broadcast.
	// p.mLastByteSizeTimes.clear(); // Force another check for byte size.
	// p.flushIfNecessaryLocked(2, key, mockMetricsManager);
	// EXPECT_EQ(1, broadcastCount);
	}

	TEST(StatsLogProcessorTest, TestDropWhenByteSizeTooLarge) {
	sp<UidMap> m = new UidMap();
	sp<AlarmMonitor> anomalyAlarmMonitor;
	sp<AlarmMonitor> subscriberAlarmMonitor;
	int broadcastCount = 0;
	StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
	[&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});

	MockMetricsManager mockMetricsManager;

	ConfigKey key(100, 12345);
	EXPECT_CALL(mockMetricsManager, byteSize())
	.Times(1)
	.WillRepeatedly(Return(int(StatsdStats::kMaxMetricsBytesPerConfig * 1.2)));

	EXPECT_CALL(mockMetricsManager, dropData(_)).Times(1);

	// Expect to call the onDumpReport and skip the broadcast.
	p.flushIfNecessaryLocked(1, key, mockMetricsManager);
	EXPECT_EQ(0, broadcastCount);
	}

	StatsdConfig MakeConfig(bool includeMetric) {
	StatsdConfig config;
	config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.

	if (includeMetric) {
	auto appCrashMatcher = CreateProcessCrashAtomMatcher();
	*config.add_atom_matcher() = appCrashMatcher;
	auto countMetric = config.add_count_metric();
	countMetric->set_id(StringToId("AppCrashes"));
	countMetric->set_what(appCrashMatcher.id());
	countMetric->set_bucket(FIVE_MINUTES);
	}
	return config;
	}

	TEST(StatsLogProcessorTest, TestUidMapHasSnapshot) {
	// Setup simple config key corresponding to empty config.
	sp<UidMap> m = new UidMap();
	m->updateMap(1, {1, 2}, {1, 2}, {String16("p1"), String16("p2")});
	sp<AlarmMonitor> anomalyAlarmMonitor;
	sp<AlarmMonitor> subscriberAlarmMonitor;
	int broadcastCount = 0;
	StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
	[&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});
	ConfigKey key(3, 4);
	StatsdConfig config = MakeConfig(true);
	p.OnConfigUpdated(0, key, config);

	// Expect to get no metrics, but snapshot specified above in uidmap.
	vector<uint8_t> bytes;
	p.onDumpReport(key, 1, false, ADB_DUMP, &bytes);

	ConfigMetricsReportList output;
	output.ParseFromArray(bytes.data(), bytes.size());
	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());
	}

	TEST(StatsLogProcessorTest, TestEmptyConfigHasNoUidMap) {
	// Setup simple config key corresponding to empty config.
	sp<UidMap> m = new UidMap();
	m->updateMap(1, {1, 2}, {1, 2}, {String16("p1"), String16("p2")});
	sp<AlarmMonitor> anomalyAlarmMonitor;
	sp<AlarmMonitor> subscriberAlarmMonitor;
	int broadcastCount = 0;
	StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
	[&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});
	ConfigKey key(3, 4);
	StatsdConfig config = MakeConfig(false);
	p.OnConfigUpdated(0, key, config);

	// Expect to get no metrics, but snapshot specified above in uidmap.
	vector<uint8_t> bytes;
	p.onDumpReport(key, 1, false, ADB_DUMP, &bytes);

	ConfigMetricsReportList output;
	output.ParseFromArray(bytes.data(), bytes.size());
	EXPECT_TRUE(output.reports_size() > 0);
	EXPECT_FALSE(output.reports(0).has_uid_map());
	}

	TEST(StatsLogProcessorTest, TestReportIncludesSubConfig) {
	// Setup simple config key corresponding to empty config.
	sp<UidMap> m = new UidMap();
	sp<AlarmMonitor> anomalyAlarmMonitor;
	sp<AlarmMonitor> subscriberAlarmMonitor;
	int broadcastCount = 0;
	StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
	[&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});
	ConfigKey key(3, 4);
	StatsdConfig config;
	auto annotation = config.add_annotation();
	annotation->set_field_int64(1);
	annotation->set_field_int32(2);
	config.add_allowed_log_source("AID_ROOT");
	p.OnConfigUpdated(1, key, config);

	// Expect to get no metrics, but snapshot specified above in uidmap.
	vector<uint8_t> bytes;
	p.onDumpReport(key, 1, false, ADB_DUMP, &bytes);

	ConfigMetricsReportList output;
	output.ParseFromArray(bytes.data(), bytes.size());
	EXPECT_TRUE(output.reports_size() > 0);
	auto report = output.reports(0);
	EXPECT_EQ(1, report.annotation_size());
	EXPECT_EQ(1, report.annotation(0).field_int64());
	EXPECT_EQ(2, report.annotation(0).field_int32());
	}

	TEST(StatsLogProcessorTest, TestOutOfOrderLogs) {
	// Setup simple config key corresponding to empty config.
	sp<UidMap> m = new UidMap();
	sp<AlarmMonitor> anomalyAlarmMonitor;
	sp<AlarmMonitor> subscriberAlarmMonitor;
	int broadcastCount = 0;
	StatsLogProcessor p(m, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
	[&broadcastCount](const ConfigKey& key) { broadcastCount++; return true;});

	LogEvent event1(0, 1 /logd timestamp/, 1001 /elapsedRealtime/);
	event1.init();

	LogEvent event2(0, 2, 1002);
	event2.init();

	LogEvent event3(0, 3, 1005);
	event3.init();

	LogEvent event4(0, 4, 1004);
	event4.init();

	// <----- Reconnection happens

	LogEvent event5(0, 5, 999);
	event5.init();

	LogEvent event6(0, 6, 2000);
	event6.init();

	// <----- Reconnection happens

	LogEvent event7(0, 7, 3000);
	event7.init();

	// first event ever
	p.OnLogEvent(&event1, true);
	EXPECT_EQ(1UL, p.mLogCount);
	EXPECT_EQ(1001LL, p.mLargestTimestampSeen);
	EXPECT_EQ(1001LL, p.mLastTimestampSeen);

	p.OnLogEvent(&event2, false);
	EXPECT_EQ(2UL, p.mLogCount);
	EXPECT_EQ(1002LL, p.mLargestTimestampSeen);
	EXPECT_EQ(1002LL, p.mLastTimestampSeen);

	p.OnLogEvent(&event3, false);
	EXPECT_EQ(3UL, p.mLogCount);
	EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
	EXPECT_EQ(1005LL, p.mLastTimestampSeen);

	p.OnLogEvent(&event4, false);
	EXPECT_EQ(4UL, p.mLogCount);
	EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
	EXPECT_EQ(1004LL, p.mLastTimestampSeen);
	EXPECT_FALSE(p.mInReconnection);

	// Reconnect happens, event1 out of buffer. Read event2
	p.OnLogEvent(&event2, true);
	EXPECT_EQ(4UL, p.mLogCount);
	EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
	EXPECT_EQ(1004LL, p.mLastTimestampSeen);
	EXPECT_TRUE(p.mInReconnection);

	p.OnLogEvent(&event3, false);
	EXPECT_EQ(4UL, p.mLogCount);
	EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
	EXPECT_EQ(1004LL, p.mLastTimestampSeen);
	EXPECT_TRUE(p.mInReconnection);

	p.OnLogEvent(&event4, false);
	EXPECT_EQ(4UL, p.mLogCount);
	EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
	EXPECT_EQ(1004LL, p.mLastTimestampSeen);
	EXPECT_FALSE(p.mInReconnection);

	// Fresh event comes.
	p.OnLogEvent(&event5, false);
	EXPECT_EQ(5UL, p.mLogCount);
	EXPECT_EQ(1005LL, p.mLargestTimestampSeen);
	EXPECT_EQ(999LL, p.mLastTimestampSeen);

	p.OnLogEvent(&event6, false);
	EXPECT_EQ(6UL, p.mLogCount);
	EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
	EXPECT_EQ(2000LL, p.mLastTimestampSeen);

	// Reconnect happens, read from event4
	p.OnLogEvent(&event4, true);
	EXPECT_EQ(6UL, p.mLogCount);
	EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
	EXPECT_EQ(2000LL, p.mLastTimestampSeen);
	EXPECT_TRUE(p.mInReconnection);

	p.OnLogEvent(&event5, false);
	EXPECT_EQ(6UL, p.mLogCount);
	EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
	EXPECT_EQ(2000LL, p.mLastTimestampSeen);
	EXPECT_TRUE(p.mInReconnection);

	// Before we get out of reconnection state, it reconnects again.
	p.OnLogEvent(&event5, true);
	EXPECT_EQ(6UL, p.mLogCount);
	EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
	EXPECT_EQ(2000LL, p.mLastTimestampSeen);
	EXPECT_TRUE(p.mInReconnection);

	p.OnLogEvent(&event6, false);
	EXPECT_EQ(6UL, p.mLogCount);
	EXPECT_EQ(2000LL, p.mLargestTimestampSeen);
	EXPECT_EQ(2000LL, p.mLastTimestampSeen);
	EXPECT_FALSE(p.mInReconnection);
	EXPECT_EQ(0, p.mLogLossCount);

	// it reconnects again. All old events are gone. We lose CP.
	p.OnLogEvent(&event7, true);
	EXPECT_EQ(7UL, p.mLogCount);
	EXPECT_EQ(3000LL, p.mLargestTimestampSeen);
	EXPECT_EQ(3000LL, p.mLastTimestampSeen);
	EXPECT_EQ(1, p.mLogLossCount);
	EXPECT_FALSE(p.mInReconnection);
	}

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

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