cmds/statsd/tests/state/StateTracker_test.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2019, 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 <gtest/gtest.h>
 #include "state/StateManager.h"
 #include "state/StateTracker.h"
 #include "state/StateListener.h"

 #include "tests/statsd_test_util.h"

 #ifdef __ANDROID__

 namespace android {
 namespace os {
 namespace statsd {

 /**
  * Mock StateListener class for testing.
  * Stores primary key and state pairs.
  */
 class TestStateListener : public virtual StateListener {
 public:
     TestStateListener(){};

     virtual ~TestStateListener(){};

     struct Update {
         Update(const HashableDimensionKey& key, int state) : mKey(key), mState(state){};
         HashableDimensionKey mKey;
         int mState;
     };

     std::vector<Update> updates;

     void onStateChanged(int atomId, const HashableDimensionKey& primaryKey, int oldState,
                         int newState) {
         updates.emplace_back(primaryKey, newState);
     }
 };

 int getStateInt(StateManager& mgr, int atomId, const HashableDimensionKey& queryKey) {
     FieldValue output;
     mgr.getStateValue(atomId, queryKey, &output);
     return output.mValue.int_value;
 }

 // START: build event functions.
 // State with no primary fields - ScreenStateChanged
 std::shared_ptr<LogEvent> buildScreenEvent(int state) {
     std::shared_ptr<LogEvent> event =
             std::make_shared<LogEvent>(android::util::SCREEN_STATE_CHANGED, 1000 /*timestamp*/);
     event->write((int32_t)state);
     event->init();
     return event;
 }

 // State with one primary field - UidProcessStateChanged
 std::shared_ptr<LogEvent> buildUidProcessEvent(int uid, int state) {
     std::shared_ptr<LogEvent> event =
             std::make_shared<LogEvent>(android::util::UID_PROCESS_STATE_CHANGED, 1000 /*timestamp*/);
     event->write((int32_t)uid);
     event->write((int32_t)state);
     event->init();
     return event;
 }

 // State with multiple primary fields - OverlayStateChanged
 std::shared_ptr<LogEvent> buildOverlayEvent(int uid, const std::string& packageName, int state) {
     std::shared_ptr<LogEvent> event =
             std::make_shared<LogEvent>(android::util::OVERLAY_STATE_CHANGED, 1000 /*timestamp*/);
     event->write((int32_t)uid);
     event->write(packageName);
     event->write(true);  // using_alert_window
     event->write((int32_t)state);
     event->init();
     return event;
 }

 // Incorrect event - missing fields
 std::shared_ptr<LogEvent> buildIncorrectOverlayEvent(int uid, const std::string& packageName, int state) {
     std::shared_ptr<LogEvent> event =
             std::make_shared<LogEvent>(android::util::OVERLAY_STATE_CHANGED, 1000 /*timestamp*/);
     event->write((int32_t)uid);
     event->write(packageName);
     event->write((int32_t)state);
     event->init();
     return event;
 }

 // Incorrect event - exclusive state has wrong type
 std::shared_ptr<LogEvent> buildOverlayEventBadStateType(int uid, const std::string& packageName) {
     std::shared_ptr<LogEvent> event =
             std::make_shared<LogEvent>(android::util::OVERLAY_STATE_CHANGED, 1000 /*timestamp*/);
     event->write((int32_t)uid);
     event->write(packageName);
     event->write(true);
     event->write("string");  // exclusive state: string instead of int
     event->init();
     return event;
 }
 // END: build event functions.

 // START: get primary key functions
 void getUidProcessKey(int uid, HashableDimensionKey* key) {
     int pos1[] = {1, 0, 0};
     Field field1(27 /* atom id */, pos1, 0 /* depth */);
     Value value1((int32_t)uid);

     key->addValue(FieldValue(field1, value1));
 }

 void getOverlayKey(int uid, string packageName, HashableDimensionKey* key) {
     int pos1[] = {1, 0, 0};
     int pos2[] = {2, 0, 0};

     Field field1(59 /* atom id */, pos1, 0 /* depth */);
     Field field2(59 /* atom id */, pos2, 0 /* depth */);

     Value value1((int32_t)uid);
     Value value2(packageName);

     key->addValue(FieldValue(field1, value1));
     key->addValue(FieldValue(field2, value2));
 }
 // END: get primary key functions

 TEST(StateListenerTest, TestStateListenerWeakPointer) {
     sp<TestStateListener> listener = new TestStateListener();
     wp<TestStateListener> wListener = listener;
     listener = nullptr;  // let go of listener
     EXPECT_TRUE(wListener.promote() == nullptr);
 }

 TEST(StateManagerTest, TestStateManagerGetInstance) {
     sp<TestStateListener> listener1 = new TestStateListener();
     StateManager& mgr = StateManager::getInstance();

     mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);
     EXPECT_EQ(1, mgr.getStateTrackersCount());
     EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
 }

 /**
  * Test registering listeners to StateTrackers
  *
  * - StateManager will create a new StateTracker if it doesn't already exist
  * and then register the listener to the StateTracker.
  * - If a listener is already registered to a StateTracker, it is not added again.
  * - StateTrackers are only created for atoms that are state atoms.
  */
 TEST(StateTrackerTest, TestRegisterListener) {
     sp<TestStateListener> listener1 = new TestStateListener();
     sp<TestStateListener> listener2 = new TestStateListener();
     StateManager mgr;

     // Register listener to non-existing StateTracker
     EXPECT_EQ(0, mgr.getStateTrackersCount());
     EXPECT_TRUE(mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1));
     EXPECT_EQ(1, mgr.getStateTrackersCount());
     EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

     // Register listener to existing StateTracker
     EXPECT_TRUE(mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener2));
     EXPECT_EQ(1, mgr.getStateTrackersCount());
     EXPECT_EQ(2, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

     // Register already registered listener to existing StateTracker
     EXPECT_TRUE(mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener2));
     EXPECT_EQ(1, mgr.getStateTrackersCount());
     EXPECT_EQ(2, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

     // Register listener to non-state atom
     EXPECT_FALSE(mgr.registerListener(android::util::BATTERY_LEVEL_CHANGED, listener2));
     EXPECT_EQ(1, mgr.getStateTrackersCount());
 }

 /**
  * Test unregistering listeners from StateTrackers
  *
  * - StateManager will unregister listeners from a StateTracker only if the
  * StateTracker exists and the listener is registered to the StateTracker.
  * - Once all listeners are removed from a StateTracker, the StateTracker
  * is also removed.
  */
 TEST(StateTrackerTest, TestUnregisterListener) {
     sp<TestStateListener> listener1 = new TestStateListener();
     sp<TestStateListener> listener2 = new TestStateListener();
     StateManager mgr;

     // Unregister listener from non-existing StateTracker
     EXPECT_EQ(0, mgr.getStateTrackersCount());
     mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener1);
     EXPECT_EQ(0, mgr.getStateTrackersCount());
     EXPECT_EQ(-1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

     // Unregister non-registered listener from existing StateTracker
     mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);
     EXPECT_EQ(1, mgr.getStateTrackersCount());
     EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));
     mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener2);
     EXPECT_EQ(1, mgr.getStateTrackersCount());
     EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

     // Unregister second-to-last listener from StateTracker
     mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener2);
     mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener1);
     EXPECT_EQ(1, mgr.getStateTrackersCount());
     EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

     // Unregister last listener from StateTracker
     mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener2);
     EXPECT_EQ(0, mgr.getStateTrackersCount());
     EXPECT_EQ(-1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));
 }

 /**
  * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
  * updates listener for states without primary keys.
  */
 TEST(StateTrackerTest, TestStateChangeNoPrimaryFields) {
     sp<TestStateListener> listener1 = new TestStateListener();
     StateManager mgr;
     mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);

     // log event
     std::shared_ptr<LogEvent> event =
             buildScreenEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON);
     mgr.onLogEvent(*event);

     // check listener was updated
     EXPECT_EQ(1, listener1->updates.size());
     EXPECT_EQ(DEFAULT_DIMENSION_KEY, listener1->updates[0].mKey);
     EXPECT_EQ(2, listener1->updates[0].mState);

     // check StateTracker was updated by querying for state
     HashableDimensionKey queryKey = DEFAULT_DIMENSION_KEY;
     EXPECT_EQ(2, getStateInt(mgr, android::util::SCREEN_STATE_CHANGED, queryKey));
 }

 /**
  * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
  * updates listener for states with one primary key.
  */
 TEST(StateTrackerTest, TestStateChangeOnePrimaryField) {
     sp<TestStateListener> listener1 = new TestStateListener();
     StateManager mgr;
     mgr.registerListener(android::util::UID_PROCESS_STATE_CHANGED, listener1);

     // log event
     std::shared_ptr<LogEvent> event =
             buildUidProcessEvent(1000 /* uid */, android::app::ProcessStateEnum::PROCESS_STATE_TOP);
     mgr.onLogEvent(*event);

     // check listener was updated
     EXPECT_EQ(1, listener1->updates.size());
     EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
     EXPECT_EQ(1002, listener1->updates[0].mState);

     // check StateTracker was updated by querying for state
     HashableDimensionKey queryKey;
     getUidProcessKey(1000 /* uid */, &queryKey);
     EXPECT_EQ(1002, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED, queryKey));
 }

 /**
  * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
  * updates listener for states with multiple primary keys.
  */
 TEST(StateTrackerTest, TestStateChangeMultiplePrimaryFields) {
     sp<TestStateListener> listener1 = new TestStateListener();
     StateManager mgr;
     mgr.registerListener(android::util::OVERLAY_STATE_CHANGED, listener1);

     // log event
     std::shared_ptr<LogEvent> event =
             buildOverlayEvent(1000 /* uid */, "package1", 1);  // state: ENTERED
     mgr.onLogEvent(*event);

     // check listener was updated
     EXPECT_EQ(1, listener1->updates.size());
     EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
     EXPECT_EQ(1, listener1->updates[0].mState);

     // check StateTracker was updated by querying for state
     HashableDimensionKey queryKey;
     getOverlayKey(1000 /* uid */, "package1", &queryKey);
     EXPECT_EQ(1, getStateInt(mgr, android::util::OVERLAY_STATE_CHANGED, queryKey));
 }

 /**
  * Test StateManager's onLogEvent and StateListener's onStateChanged
  * when there is an error extracting state from log event. Listener is not
  * updated of state change.
  */
 TEST(StateTrackerTest, TestStateChangeEventError) {
     sp<TestStateListener> listener1 = new TestStateListener();
     StateManager mgr;
     mgr.registerListener(android::util::OVERLAY_STATE_CHANGED, listener1);

     // log event
     std::shared_ptr<LogEvent> event1 =
             buildIncorrectOverlayEvent(1000 /* uid */, "package1", 1 /* state */);
     std::shared_ptr<LogEvent> event2 = buildOverlayEventBadStateType(1001 /* uid */, "package2");

     // check listener was updated
     mgr.onLogEvent(*event1);
     EXPECT_EQ(0, listener1->updates.size());
     mgr.onLogEvent(*event2);
     EXPECT_EQ(0, listener1->updates.size());
 }

 TEST(StateTrackerTest, TestStateQuery) {
     sp<TestStateListener> listener1 = new TestStateListener();
     sp<TestStateListener> listener2 = new TestStateListener();
     sp<TestStateListener> listener3 = new TestStateListener();
     StateManager mgr;
     mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);
     mgr.registerListener(android::util::UID_PROCESS_STATE_CHANGED, listener2);
     mgr.registerListener(android::util::OVERLAY_STATE_CHANGED, listener3);

     std::shared_ptr<LogEvent> event1 = buildUidProcessEvent(
             1000,
             android::app::ProcessStateEnum::PROCESS_STATE_TOP);  //  state value: 1002
     std::shared_ptr<LogEvent> event2 = buildUidProcessEvent(
             1001,
             android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE);  //  state value:
                                                                                 //  1003
     std::shared_ptr<LogEvent> event3 = buildUidProcessEvent(
             1002,
             android::app::ProcessStateEnum::PROCESS_STATE_PERSISTENT);  //  state value: 1000
     std::shared_ptr<LogEvent> event4 = buildUidProcessEvent(
             1001,
             android::app::ProcessStateEnum::PROCESS_STATE_TOP);  //  state value: 1002
     std::shared_ptr<LogEvent> event5 =
             buildScreenEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON);
     std::shared_ptr<LogEvent> event6 = buildOverlayEvent(1000, "package1", 1);
     std::shared_ptr<LogEvent> event7 = buildOverlayEvent(1000, "package2", 2);

     mgr.onLogEvent(*event1);
     mgr.onLogEvent(*event2);
     mgr.onLogEvent(*event3);
     mgr.onLogEvent(*event5);
     mgr.onLogEvent(*event5);
     mgr.onLogEvent(*event6);
     mgr.onLogEvent(*event7);

     // Query for UidProcessState of uid 1001
     HashableDimensionKey queryKey1;
     getUidProcessKey(1001, &queryKey1);
     EXPECT_EQ(1003, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED, queryKey1));

     // Query for UidProcessState of uid 1004 - not in state map
     HashableDimensionKey queryKey2;
     getUidProcessKey(1004, &queryKey2);
     EXPECT_EQ(-1, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED,
                               queryKey2));  // default state

     // Query for UidProcessState of uid 1001 - after change in state
     mgr.onLogEvent(*event4);
     EXPECT_EQ(1002, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED, queryKey1));

     // Query for ScreenState
     EXPECT_EQ(2, getStateInt(mgr, android::util::SCREEN_STATE_CHANGED, DEFAULT_DIMENSION_KEY));

     // Query for OverlayState of uid 1000, package name "package2"
     HashableDimensionKey queryKey3;
     getOverlayKey(1000, "package2", &queryKey3);
     EXPECT_EQ(2, getStateInt(mgr, android::util::OVERLAY_STATE_CHANGED, queryKey3));
 }

 }  // namespace statsd
 }  // namespace os
 }  // namespace android
 #else
 GTEST_LOG_(INFO) << "This test does nothing.\n";
 #endif
	/*
	* Copyright (C) 2019, 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 <gtest/gtest.h>
	#include "state/StateManager.h"
	#include "state/StateTracker.h"
	#include "state/StateListener.h"

	#include "tests/statsd_test_util.h"

	#ifdef __ANDROID__

	namespace android {
	namespace os {
	namespace statsd {

	/**
	* Mock StateListener class for testing.
	* Stores primary key and state pairs.
	*/
	class TestStateListener : public virtual StateListener {
	public:
	TestStateListener(){};

	virtual ~TestStateListener(){};

	struct Update {
	Update(const HashableDimensionKey& key, int state) : mKey(key), mState(state){};
	HashableDimensionKey mKey;
	int mState;
	};

	std::vector<Update> updates;

	void onStateChanged(int atomId, const HashableDimensionKey& primaryKey, int oldState,
	int newState) {
	updates.emplace_back(primaryKey, newState);
	}
	};

	int getStateInt(StateManager& mgr, int atomId, const HashableDimensionKey& queryKey) {
	FieldValue output;
	mgr.getStateValue(atomId, queryKey, &output);
	return output.mValue.int_value;
	}

	// START: build event functions.
	// State with no primary fields - ScreenStateChanged
	std::shared_ptr<LogEvent> buildScreenEvent(int state) {
	std::shared_ptr<LogEvent> event =
	std::make_shared<LogEvent>(android::util::SCREEN_STATE_CHANGED, 1000 /timestamp/);
	event->write((int32_t)state);
	event->init();
	return event;
	}

	// State with one primary field - UidProcessStateChanged
	std::shared_ptr<LogEvent> buildUidProcessEvent(int uid, int state) {
	std::shared_ptr<LogEvent> event =
	std::make_shared<LogEvent>(android::util::UID_PROCESS_STATE_CHANGED, 1000 /timestamp/);
	event->write((int32_t)uid);
	event->write((int32_t)state);
	event->init();
	return event;
	}

	// State with multiple primary fields - OverlayStateChanged
	std::shared_ptr<LogEvent> buildOverlayEvent(int uid, const std::string& packageName, int state) {
	std::shared_ptr<LogEvent> event =
	std::make_shared<LogEvent>(android::util::OVERLAY_STATE_CHANGED, 1000 /timestamp/);
	event->write((int32_t)uid);
	event->write(packageName);
	event->write(true); // using_alert_window
	event->write((int32_t)state);
	event->init();
	return event;
	}

	// Incorrect event - missing fields
	std::shared_ptr<LogEvent> buildIncorrectOverlayEvent(int uid, const std::string& packageName, int state) {
	std::shared_ptr<LogEvent> event =
	std::make_shared<LogEvent>(android::util::OVERLAY_STATE_CHANGED, 1000 /timestamp/);
	event->write((int32_t)uid);
	event->write(packageName);
	event->write((int32_t)state);
	event->init();
	return event;
	}

	// Incorrect event - exclusive state has wrong type
	std::shared_ptr<LogEvent> buildOverlayEventBadStateType(int uid, const std::string& packageName) {
	std::shared_ptr<LogEvent> event =
	std::make_shared<LogEvent>(android::util::OVERLAY_STATE_CHANGED, 1000 /timestamp/);
	event->write((int32_t)uid);
	event->write(packageName);
	event->write(true);
	event->write("string"); // exclusive state: string instead of int
	event->init();
	return event;
	}
	// END: build event functions.

	// START: get primary key functions
	void getUidProcessKey(int uid, HashableDimensionKey* key) {
	int pos1[] = {1, 0, 0};
	Field field1(27 /* atom id /, pos1, 0 / depth */);
	Value value1((int32_t)uid);

	key->addValue(FieldValue(field1, value1));
	}

	void getOverlayKey(int uid, string packageName, HashableDimensionKey* key) {
	int pos1[] = {1, 0, 0};
	int pos2[] = {2, 0, 0};

	Field field1(59 /* atom id /, pos1, 0 / depth */);
	Field field2(59 /* atom id /, pos2, 0 / depth */);

	Value value1((int32_t)uid);
	Value value2(packageName);

	key->addValue(FieldValue(field1, value1));
	key->addValue(FieldValue(field2, value2));
	}
	// END: get primary key functions

	TEST(StateListenerTest, TestStateListenerWeakPointer) {
	sp<TestStateListener> listener = new TestStateListener();
	wp<TestStateListener> wListener = listener;
	listener = nullptr; // let go of listener
	EXPECT_TRUE(wListener.promote() == nullptr);
	}

	TEST(StateManagerTest, TestStateManagerGetInstance) {
	sp<TestStateListener> listener1 = new TestStateListener();
	StateManager& mgr = StateManager::getInstance();

	mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
	}

	/**
	* Test registering listeners to StateTrackers
	*
	* - StateManager will create a new StateTracker if it doesn't already exist
	* and then register the listener to the StateTracker.
	* - If a listener is already registered to a StateTracker, it is not added again.
	* - StateTrackers are only created for atoms that are state atoms.
	*/
	TEST(StateTrackerTest, TestRegisterListener) {
	sp<TestStateListener> listener1 = new TestStateListener();
	sp<TestStateListener> listener2 = new TestStateListener();
	StateManager mgr;

	// Register listener to non-existing StateTracker
	EXPECT_EQ(0, mgr.getStateTrackersCount());
	EXPECT_TRUE(mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1));
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

	// Register listener to existing StateTracker
	EXPECT_TRUE(mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener2));
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	EXPECT_EQ(2, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

	// Register already registered listener to existing StateTracker
	EXPECT_TRUE(mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener2));
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	EXPECT_EQ(2, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

	// Register listener to non-state atom
	EXPECT_FALSE(mgr.registerListener(android::util::BATTERY_LEVEL_CHANGED, listener2));
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	}

	/**
	* Test unregistering listeners from StateTrackers
	*
	* - StateManager will unregister listeners from a StateTracker only if the
	* StateTracker exists and the listener is registered to the StateTracker.
	* - Once all listeners are removed from a StateTracker, the StateTracker
	* is also removed.
	*/
	TEST(StateTrackerTest, TestUnregisterListener) {
	sp<TestStateListener> listener1 = new TestStateListener();
	sp<TestStateListener> listener2 = new TestStateListener();
	StateManager mgr;

	// Unregister listener from non-existing StateTracker
	EXPECT_EQ(0, mgr.getStateTrackersCount());
	mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener1);
	EXPECT_EQ(0, mgr.getStateTrackersCount());
	EXPECT_EQ(-1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

	// Unregister non-registered listener from existing StateTracker
	mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));
	mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener2);
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

	// Unregister second-to-last listener from StateTracker
	mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener2);
	mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener1);
	EXPECT_EQ(1, mgr.getStateTrackersCount());
	EXPECT_EQ(1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));

	// Unregister last listener from StateTracker
	mgr.unregisterListener(android::util::SCREEN_STATE_CHANGED, listener2);
	EXPECT_EQ(0, mgr.getStateTrackersCount());
	EXPECT_EQ(-1, mgr.getListenersCount(android::util::SCREEN_STATE_CHANGED));
	}

	/**
	* Test StateManager's onLogEvent and StateListener's onStateChanged correctly
	* updates listener for states without primary keys.
	*/
	TEST(StateTrackerTest, TestStateChangeNoPrimaryFields) {
	sp<TestStateListener> listener1 = new TestStateListener();
	StateManager mgr;
	mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);

	// log event
	std::shared_ptr<LogEvent> event =
	buildScreenEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON);
	mgr.onLogEvent(*event);

	// check listener was updated
	EXPECT_EQ(1, listener1->updates.size());
	EXPECT_EQ(DEFAULT_DIMENSION_KEY, listener1->updates[0].mKey);
	EXPECT_EQ(2, listener1->updates[0].mState);

	// check StateTracker was updated by querying for state
	HashableDimensionKey queryKey = DEFAULT_DIMENSION_KEY;
	EXPECT_EQ(2, getStateInt(mgr, android::util::SCREEN_STATE_CHANGED, queryKey));
	}

	/**
	* Test StateManager's onLogEvent and StateListener's onStateChanged correctly
	* updates listener for states with one primary key.
	*/
	TEST(StateTrackerTest, TestStateChangeOnePrimaryField) {
	sp<TestStateListener> listener1 = new TestStateListener();
	StateManager mgr;
	mgr.registerListener(android::util::UID_PROCESS_STATE_CHANGED, listener1);

	// log event
	std::shared_ptr<LogEvent> event =
	buildUidProcessEvent(1000 /* uid */, android::app::ProcessStateEnum::PROCESS_STATE_TOP);
	mgr.onLogEvent(*event);

	// check listener was updated
	EXPECT_EQ(1, listener1->updates.size());
	EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
	EXPECT_EQ(1002, listener1->updates[0].mState);

	// check StateTracker was updated by querying for state
	HashableDimensionKey queryKey;
	getUidProcessKey(1000 /* uid */, &queryKey);
	EXPECT_EQ(1002, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED, queryKey));
	}

	/**
	* Test StateManager's onLogEvent and StateListener's onStateChanged correctly
	* updates listener for states with multiple primary keys.
	*/
	TEST(StateTrackerTest, TestStateChangeMultiplePrimaryFields) {
	sp<TestStateListener> listener1 = new TestStateListener();
	StateManager mgr;
	mgr.registerListener(android::util::OVERLAY_STATE_CHANGED, listener1);

	// log event
	std::shared_ptr<LogEvent> event =
	buildOverlayEvent(1000 /* uid */, "package1", 1); // state: ENTERED
	mgr.onLogEvent(*event);

	// check listener was updated
	EXPECT_EQ(1, listener1->updates.size());
	EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
	EXPECT_EQ(1, listener1->updates[0].mState);

	// check StateTracker was updated by querying for state
	HashableDimensionKey queryKey;
	getOverlayKey(1000 /* uid */, "package1", &queryKey);
	EXPECT_EQ(1, getStateInt(mgr, android::util::OVERLAY_STATE_CHANGED, queryKey));
	}

	/**
	* Test StateManager's onLogEvent and StateListener's onStateChanged
	* when there is an error extracting state from log event. Listener is not
	* updated of state change.
	*/
	TEST(StateTrackerTest, TestStateChangeEventError) {
	sp<TestStateListener> listener1 = new TestStateListener();
	StateManager mgr;
	mgr.registerListener(android::util::OVERLAY_STATE_CHANGED, listener1);

	// log event
	std::shared_ptr<LogEvent> event1 =
	buildIncorrectOverlayEvent(1000 /* uid /, "package1", 1 / state */);
	std::shared_ptr<LogEvent> event2 = buildOverlayEventBadStateType(1001 /* uid */, "package2");

	// check listener was updated
	mgr.onLogEvent(*event1);
	EXPECT_EQ(0, listener1->updates.size());
	mgr.onLogEvent(*event2);
	EXPECT_EQ(0, listener1->updates.size());
	}

	TEST(StateTrackerTest, TestStateQuery) {
	sp<TestStateListener> listener1 = new TestStateListener();
	sp<TestStateListener> listener2 = new TestStateListener();
	sp<TestStateListener> listener3 = new TestStateListener();
	StateManager mgr;
	mgr.registerListener(android::util::SCREEN_STATE_CHANGED, listener1);
	mgr.registerListener(android::util::UID_PROCESS_STATE_CHANGED, listener2);
	mgr.registerListener(android::util::OVERLAY_STATE_CHANGED, listener3);

	std::shared_ptr<LogEvent> event1 = buildUidProcessEvent(
	1000,
	android::app::ProcessStateEnum::PROCESS_STATE_TOP); // state value: 1002
	std::shared_ptr<LogEvent> event2 = buildUidProcessEvent(
	1001,
	android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE); // state value:
	// 1003
	std::shared_ptr<LogEvent> event3 = buildUidProcessEvent(
	1002,
	android::app::ProcessStateEnum::PROCESS_STATE_PERSISTENT); // state value: 1000
	std::shared_ptr<LogEvent> event4 = buildUidProcessEvent(
	1001,
	android::app::ProcessStateEnum::PROCESS_STATE_TOP); // state value: 1002
	std::shared_ptr<LogEvent> event5 =
	buildScreenEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON);
	std::shared_ptr<LogEvent> event6 = buildOverlayEvent(1000, "package1", 1);
	std::shared_ptr<LogEvent> event7 = buildOverlayEvent(1000, "package2", 2);

	mgr.onLogEvent(*event1);
	mgr.onLogEvent(*event2);
	mgr.onLogEvent(*event3);
	mgr.onLogEvent(*event5);
	mgr.onLogEvent(*event5);
	mgr.onLogEvent(*event6);
	mgr.onLogEvent(*event7);

	// Query for UidProcessState of uid 1001
	HashableDimensionKey queryKey1;
	getUidProcessKey(1001, &queryKey1);
	EXPECT_EQ(1003, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED, queryKey1));

	// Query for UidProcessState of uid 1004 - not in state map
	HashableDimensionKey queryKey2;
	getUidProcessKey(1004, &queryKey2);
	EXPECT_EQ(-1, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED,
	queryKey2)); // default state

	// Query for UidProcessState of uid 1001 - after change in state
	mgr.onLogEvent(*event4);
	EXPECT_EQ(1002, getStateInt(mgr, android::util::UID_PROCESS_STATE_CHANGED, queryKey1));

	// Query for ScreenState
	EXPECT_EQ(2, getStateInt(mgr, android::util::SCREEN_STATE_CHANGED, DEFAULT_DIMENSION_KEY));

	// Query for OverlayState of uid 1000, package name "package2"
	HashableDimensionKey queryKey3;
	getOverlayKey(1000, "package2", &queryKey3);
	EXPECT_EQ(2, getStateInt(mgr, android::util::OVERLAY_STATE_CHANGED, queryKey3));
	}

	} // namespace statsd
	} // namespace os
	} // namespace android
	#else
	GTEST_LOG_(INFO) << "This test does nothing.\n";
	#endif