1 /*
2  * Copyright (C) 2019, The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "state/StateTracker.h"
17 
18 #include <gtest/gtest.h>
19 #include <private/android_filesystem_config.h>
20 
21 #include "state/StateListener.h"
22 #include "state/StateManager.h"
23 #include "state/StateTracker.h"
24 #include "stats_event.h"
25 #include "tests/statsd_test_util.h"
26 
27 #ifdef __ANDROID__
28 
29 namespace android {
30 namespace os {
31 namespace statsd {
32 
33 const int32_t timestampNs = 1000;
34 const int32_t kStateUnknown = -1;
35 
36 /**
37  * Mock StateListener class for testing.
38  * Stores primary key and state pairs.
39  */
40 class TestStateListener : public virtual StateListener {
41 public:
TestStateListener()42     TestStateListener(){};
43 
~TestStateListener()44     virtual ~TestStateListener(){};
45 
46     struct Update {
Updateandroid::os::statsd::TestStateListener::Update47         Update(const HashableDimensionKey& key, int state) : mKey(key), mState(state){};
48         HashableDimensionKey mKey;
49         int mState;
50     };
51 
52     std::vector<Update> updates;
53 
onStateChanged(const int64_t eventTimeNs,const int32_t atomId,const HashableDimensionKey & primaryKey,const FieldValue & oldState,const FieldValue & newState)54     void onStateChanged(const int64_t eventTimeNs, const int32_t atomId,
55                         const HashableDimensionKey& primaryKey, const FieldValue& oldState,
56                         const FieldValue& newState) {
57         updates.emplace_back(primaryKey, newState.mValue.int_value);
58     }
59 };
60 
getStateInt(StateManager & mgr,int atomId,const HashableDimensionKey & queryKey)61 int getStateInt(StateManager& mgr, int atomId, const HashableDimensionKey& queryKey) {
62     FieldValue output;
63     mgr.getStateValue(atomId, queryKey, &output);
64     return output.mValue.int_value;
65 }
66 
67 // START: build event functions.
68 // Incorrect event - missing fields
buildIncorrectOverlayEvent(int uid,const std::string & packageName,int state)69 std::unique_ptr<LogEvent> buildIncorrectOverlayEvent(int uid, const std::string& packageName,
70                                                      int state) {
71     AStatsEvent* statsEvent = AStatsEvent_obtain();
72     AStatsEvent_setAtomId(statsEvent, util::OVERLAY_STATE_CHANGED);
73     AStatsEvent_overwriteTimestamp(statsEvent, 1000);
74 
75     AStatsEvent_writeInt32(statsEvent, uid);
76     AStatsEvent_writeString(statsEvent, packageName.c_str());
77     // Missing field 3 - using_alert_window.
78     AStatsEvent_writeInt32(statsEvent, state);
79 
80     std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
81     parseStatsEventToLogEvent(statsEvent, logEvent.get());
82     return logEvent;
83 }
84 
85 // Incorrect event - exclusive state has wrong type
buildOverlayEventBadStateType(int uid,const std::string & packageName)86 std::unique_ptr<LogEvent> buildOverlayEventBadStateType(int uid, const std::string& packageName) {
87     AStatsEvent* statsEvent = AStatsEvent_obtain();
88     AStatsEvent_setAtomId(statsEvent, util::OVERLAY_STATE_CHANGED);
89     AStatsEvent_overwriteTimestamp(statsEvent, 1000);
90 
91     AStatsEvent_writeInt32(statsEvent, uid);
92     AStatsEvent_writeString(statsEvent, packageName.c_str());
93     AStatsEvent_writeInt32(statsEvent, true);       // using_alert_window
94     AStatsEvent_writeString(statsEvent, "string");  // exclusive state: string instead of int
95 
96     std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
97     parseStatsEventToLogEvent(statsEvent, logEvent.get());
98     return logEvent;
99 }
100 // END: build event functions.
101 
TEST(StateListenerTest,TestStateListenerWeakPointer)102 TEST(StateListenerTest, TestStateListenerWeakPointer) {
103     sp<TestStateListener> listener = new TestStateListener();
104     wp<TestStateListener> wListener = listener;
105     listener = nullptr;  // let go of listener
106     EXPECT_TRUE(wListener.promote() == nullptr);
107 }
108 
TEST(StateManagerTest,TestStateManagerGetInstance)109 TEST(StateManagerTest, TestStateManagerGetInstance) {
110     sp<TestStateListener> listener1 = new TestStateListener();
111     StateManager& mgr = StateManager::getInstance();
112     mgr.clear();
113 
114     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
115     EXPECT_EQ(1, mgr.getStateTrackersCount());
116     EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
117     mgr.unregisterListener(util::SCREEN_STATE_CHANGED, listener1);
118 }
119 
TEST(StateManagerTest,TestOnLogEvent)120 TEST(StateManagerTest, TestOnLogEvent) {
121     sp<MockUidMap> uidMap = makeMockUidMapForPackage("com.android.systemui", {10111});
122     sp<TestStateListener> listener1 = new TestStateListener();
123     StateManager mgr;
124     mgr.updateLogSources(uidMap);
125     // Add StateTracker by registering a listener.
126     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
127 
128     // log event using AID_ROOT
129     std::unique_ptr<LogEvent> event = CreateScreenStateChangedEvent(
130             timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
131     mgr.onLogEvent(*event);
132 
133     // check StateTracker was updated by querying for state
134     HashableDimensionKey queryKey = DEFAULT_DIMENSION_KEY;
135     EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
136               getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));
137 
138     // log event using mocked uid
139     event = CreateScreenStateChangedEvent(
140             timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_OFF, 10111);
141     mgr.onLogEvent(*event);
142 
143     // check StateTracker was updated by querying for state
144     queryKey = DEFAULT_DIMENSION_KEY;
145     EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF,
146               getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));
147 
148     // log event using non-whitelisted uid
149     event = CreateScreenStateChangedEvent(timestampNs,
150                                           android::view::DisplayStateEnum::DISPLAY_STATE_ON, 10112);
151     mgr.onLogEvent(*event);
152 
153     // check StateTracker was NOT updated by querying for state
154     queryKey = DEFAULT_DIMENSION_KEY;
155     EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF,
156               getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));
157 
158     // log event using AID_SYSTEM
159     event = CreateScreenStateChangedEvent(
160             timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_ON, AID_SYSTEM);
161     mgr.onLogEvent(*event);
162 
163     // check StateTracker was updated by querying for state
164     queryKey = DEFAULT_DIMENSION_KEY;
165     EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
166               getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));
167 }
168 
169 /**
170  * Test registering listeners to StateTrackers
171  *
172  * - StateManager will create a new StateTracker if it doesn't already exist
173  * and then register the listener to the StateTracker.
174  * - If a listener is already registered to a StateTracker, it is not added again.
175  * - StateTrackers are only created for atoms that are state atoms.
176  */
TEST(StateTrackerTest,TestRegisterListener)177 TEST(StateTrackerTest, TestRegisterListener) {
178     sp<TestStateListener> listener1 = new TestStateListener();
179     sp<TestStateListener> listener2 = new TestStateListener();
180     StateManager mgr;
181 
182     // Register listener to non-existing StateTracker
183     EXPECT_EQ(0, mgr.getStateTrackersCount());
184     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
185     EXPECT_EQ(1, mgr.getStateTrackersCount());
186     EXPECT_EQ(1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
187 
188     // Register listener to existing StateTracker
189     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener2);
190     EXPECT_EQ(1, mgr.getStateTrackersCount());
191     EXPECT_EQ(2, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
192 
193     // Register already registered listener to existing StateTracker
194     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener2);
195     EXPECT_EQ(1, mgr.getStateTrackersCount());
196     EXPECT_EQ(2, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
197 
198     // Register listener to non-state atom
199     mgr.registerListener(util::BATTERY_LEVEL_CHANGED, listener2);
200     EXPECT_EQ(2, mgr.getStateTrackersCount());
201 }
202 
203 /**
204  * Test unregistering listeners from StateTrackers
205  *
206  * - StateManager will unregister listeners from a StateTracker only if the
207  * StateTracker exists and the listener is registered to the StateTracker.
208  * - Once all listeners are removed from a StateTracker, the StateTracker
209  * is also removed.
210  */
TEST(StateTrackerTest,TestUnregisterListener)211 TEST(StateTrackerTest, TestUnregisterListener) {
212     sp<TestStateListener> listener1 = new TestStateListener();
213     sp<TestStateListener> listener2 = new TestStateListener();
214     StateManager mgr;
215 
216     // Unregister listener from non-existing StateTracker
217     EXPECT_EQ(0, mgr.getStateTrackersCount());
218     mgr.unregisterListener(util::SCREEN_STATE_CHANGED, listener1);
219     EXPECT_EQ(0, mgr.getStateTrackersCount());
220     EXPECT_EQ(-1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
221 
222     // Unregister non-registered listener from existing StateTracker
223     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
224     EXPECT_EQ(1, mgr.getStateTrackersCount());
225     EXPECT_EQ(1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
226     mgr.unregisterListener(util::SCREEN_STATE_CHANGED, listener2);
227     EXPECT_EQ(1, mgr.getStateTrackersCount());
228     EXPECT_EQ(1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
229 
230     // Unregister second-to-last listener from StateTracker
231     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener2);
232     mgr.unregisterListener(util::SCREEN_STATE_CHANGED, listener1);
233     EXPECT_EQ(1, mgr.getStateTrackersCount());
234     EXPECT_EQ(1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
235 
236     // Unregister last listener from StateTracker
237     mgr.unregisterListener(util::SCREEN_STATE_CHANGED, listener2);
238     EXPECT_EQ(0, mgr.getStateTrackersCount());
239     EXPECT_EQ(-1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
240 }
241 
242 /**
243  * Test a binary state atom with nested counting.
244  *
245  * To go from an "ON" state to an "OFF" state with nested counting, we must see
246  * an equal number of "OFF" events as "ON" events.
247  * For example, ACQUIRE, ACQUIRE, RELEASE will still be in the ACQUIRE state.
248  * ACQUIRE, ACQUIRE, RELEASE, RELEASE will be in the RELEASE state.
249  */
TEST(StateTrackerTest,TestStateChangeNested)250 TEST(StateTrackerTest, TestStateChangeNested) {
251     sp<TestStateListener> listener = new TestStateListener();
252     StateManager mgr;
253     mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener);
254 
255     std::vector<int> attributionUids1 = {1000};
256     std::vector<string> attributionTags1 = {"tag"};
257 
258     std::unique_ptr<LogEvent> event1 = CreateAcquireWakelockEvent(timestampNs, attributionUids1,
259                                                                   attributionTags1, "wakelockName");
260     mgr.onLogEvent(*event1);
261     ASSERT_EQ(1, listener->updates.size());
262     EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
263     EXPECT_EQ(1, listener->updates[0].mState);
264     listener->updates.clear();
265 
266     std::unique_ptr<LogEvent> event2 = CreateAcquireWakelockEvent(
267             timestampNs + 1000, attributionUids1, attributionTags1, "wakelockName");
268     mgr.onLogEvent(*event2);
269     ASSERT_EQ(0, listener->updates.size());
270 
271     std::unique_ptr<LogEvent> event3 = CreateReleaseWakelockEvent(
272             timestampNs + 2000, attributionUids1, attributionTags1, "wakelockName");
273     mgr.onLogEvent(*event3);
274     ASSERT_EQ(0, listener->updates.size());
275 
276     std::unique_ptr<LogEvent> event4 = CreateReleaseWakelockEvent(
277             timestampNs + 3000, attributionUids1, attributionTags1, "wakelockName");
278     mgr.onLogEvent(*event4);
279     ASSERT_EQ(1, listener->updates.size());
280     EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
281     EXPECT_EQ(0, listener->updates[0].mState);
282 }
283 
284 /**
285  * Test a state atom with a reset state.
286  *
287  * If the reset state value is seen, every state in the map is set to the default
288  * state and every listener is notified.
289  */
TEST(StateTrackerTest,TestStateChangeReset)290 TEST(StateTrackerTest, TestStateChangeReset) {
291     sp<TestStateListener> listener = new TestStateListener();
292     StateManager mgr;
293     mgr.registerListener(util::BLE_SCAN_STATE_CHANGED, listener);
294 
295     std::vector<int> attributionUids1 = {1000};
296     std::vector<string> attributionTags1 = {"tag1"};
297     std::vector<int> attributionUids2 = {2000};
298 
299     std::unique_ptr<LogEvent> event1 =
300             CreateBleScanStateChangedEvent(timestampNs, attributionUids1, attributionTags1,
301                                            BleScanStateChanged::ON, false, false, false);
302     mgr.onLogEvent(*event1);
303     ASSERT_EQ(1, listener->updates.size());
304     EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
305     EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState);
306     FieldValue stateFieldValue;
307     mgr.getStateValue(util::BLE_SCAN_STATE_CHANGED, listener->updates[0].mKey, &stateFieldValue);
308     EXPECT_EQ(BleScanStateChanged::ON, stateFieldValue.mValue.int_value);
309     listener->updates.clear();
310 
311     std::unique_ptr<LogEvent> event2 =
312             CreateBleScanStateChangedEvent(timestampNs + 1000, attributionUids2, attributionTags1,
313                                            BleScanStateChanged::ON, false, false, false);
314     mgr.onLogEvent(*event2);
315     ASSERT_EQ(1, listener->updates.size());
316     EXPECT_EQ(2000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
317     EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState);
318     mgr.getStateValue(util::BLE_SCAN_STATE_CHANGED, listener->updates[0].mKey, &stateFieldValue);
319     EXPECT_EQ(BleScanStateChanged::ON, stateFieldValue.mValue.int_value);
320     listener->updates.clear();
321 
322     std::unique_ptr<LogEvent> event3 =
323             CreateBleScanStateChangedEvent(timestampNs + 2000, attributionUids2, attributionTags1,
324                                            BleScanStateChanged::RESET, false, false, false);
325     mgr.onLogEvent(*event3);
326     ASSERT_EQ(2, listener->updates.size());
327     for (const TestStateListener::Update& update : listener->updates) {
328         EXPECT_EQ(BleScanStateChanged::OFF, update.mState);
329 
330         mgr.getStateValue(util::BLE_SCAN_STATE_CHANGED, update.mKey, &stateFieldValue);
331         EXPECT_EQ(BleScanStateChanged::OFF, stateFieldValue.mValue.int_value);
332     }
333 }
334 
335 /**
336  * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
337  * updates listener for states without primary keys.
338  */
TEST(StateTrackerTest,TestStateChangeNoPrimaryFields)339 TEST(StateTrackerTest, TestStateChangeNoPrimaryFields) {
340     sp<TestStateListener> listener1 = new TestStateListener();
341     StateManager mgr;
342     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
343 
344     // log event
345     std::unique_ptr<LogEvent> event = CreateScreenStateChangedEvent(
346             timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
347     mgr.onLogEvent(*event);
348 
349     // check listener was updated
350     ASSERT_EQ(1, listener1->updates.size());
351     EXPECT_EQ(DEFAULT_DIMENSION_KEY, listener1->updates[0].mKey);
352     EXPECT_EQ(2, listener1->updates[0].mState);
353 
354     // check StateTracker was updated by querying for state
355     HashableDimensionKey queryKey = DEFAULT_DIMENSION_KEY;
356     EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
357               getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));
358 }
359 
360 /**
361  * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
362  * updates listener for states with one primary key.
363  */
TEST(StateTrackerTest,TestStateChangeOnePrimaryField)364 TEST(StateTrackerTest, TestStateChangeOnePrimaryField) {
365     sp<TestStateListener> listener1 = new TestStateListener();
366     StateManager mgr;
367     mgr.registerListener(util::UID_PROCESS_STATE_CHANGED, listener1);
368 
369     // log event
370     std::unique_ptr<LogEvent> event = CreateUidProcessStateChangedEvent(
371             timestampNs, 1000 /*uid*/, android::app::ProcessStateEnum::PROCESS_STATE_TOP);
372     mgr.onLogEvent(*event);
373 
374     // check listener was updated
375     ASSERT_EQ(1, listener1->updates.size());
376     EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
377     EXPECT_EQ(1002, listener1->updates[0].mState);
378 
379     // check StateTracker was updated by querying for state
380     HashableDimensionKey queryKey;
381     getUidProcessKey(1000 /* uid */, &queryKey);
382     EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_TOP,
383               getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey));
384 }
385 
TEST(StateTrackerTest,TestStateChangePrimaryFieldAttrChain)386 TEST(StateTrackerTest, TestStateChangePrimaryFieldAttrChain) {
387     sp<TestStateListener> listener1 = new TestStateListener();
388     StateManager mgr;
389     mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener1);
390 
391     // Log event.
392     std::vector<int> attributionUids = {1001};
393     std::vector<string> attributionTags = {"tag1"};
394 
395     std::unique_ptr<LogEvent> event = CreateAcquireWakelockEvent(timestampNs, attributionUids,
396                                                                  attributionTags, "wakelockName");
397     mgr.onLogEvent(*event);
398     EXPECT_EQ(1, mgr.getStateTrackersCount());
399     EXPECT_EQ(1, mgr.getListenersCount(util::WAKELOCK_STATE_CHANGED));
400 
401     // Check listener was updated.
402     ASSERT_EQ(1, listener1->updates.size());
403     ASSERT_EQ(3, listener1->updates[0].mKey.getValues().size());
404     EXPECT_EQ(1001, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
405     EXPECT_EQ(1, listener1->updates[0].mKey.getValues()[1].mValue.int_value);
406     EXPECT_EQ("wakelockName", listener1->updates[0].mKey.getValues()[2].mValue.str_value);
407     EXPECT_EQ(WakelockStateChanged::ACQUIRE, listener1->updates[0].mState);
408 
409     // Check StateTracker was updated by querying for state.
410     HashableDimensionKey queryKey;
411     getPartialWakelockKey(1001 /* uid */, "wakelockName", &queryKey);
412     EXPECT_EQ(WakelockStateChanged::ACQUIRE,
413               getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey));
414 
415     // No state stored for this query key.
416     HashableDimensionKey queryKey2;
417     getPartialWakelockKey(1002 /* uid */, "tag1", &queryKey2);
418     EXPECT_EQ(-1 /*StateTracker::kStateUnknown*/,
419               getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey2));
420 
421     // Partial query fails.
422     HashableDimensionKey queryKey3;
423     getPartialWakelockKey(1001 /* uid */, &queryKey3);
424     EXPECT_EQ(-1 /*StateTracker::kStateUnknown*/,
425               getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey3));
426 }
427 
428 /**
429  * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
430  * updates listener for states with multiple primary keys.
431  */
TEST(StateTrackerTest,TestStateChangeMultiplePrimaryFields)432 TEST(StateTrackerTest, TestStateChangeMultiplePrimaryFields) {
433     sp<TestStateListener> listener1 = new TestStateListener();
434     StateManager mgr;
435     mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener1);
436 
437     // log event
438     std::unique_ptr<LogEvent> event = CreateOverlayStateChangedEvent(
439             timestampNs, 1000 /* uid */, "package1", true /*using_alert_window*/,
440             OverlayStateChanged::ENTERED);
441     mgr.onLogEvent(*event);
442 
443     // check listener was updated
444     ASSERT_EQ(1, listener1->updates.size());
445     EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
446     EXPECT_EQ(1, listener1->updates[0].mState);
447 
448     // check StateTracker was updated by querying for state
449     HashableDimensionKey queryKey;
450     getOverlayKey(1000 /* uid */, "package1", &queryKey);
451     EXPECT_EQ(OverlayStateChanged::ENTERED,
452               getStateInt(mgr, util::OVERLAY_STATE_CHANGED, queryKey));
453 }
454 
TEST(StateTrackerTest,TestStateQuery)455 TEST(StateTrackerTest, TestStateQuery) {
456     sp<TestStateListener> listener1 = new TestStateListener();
457     sp<TestStateListener> listener2 = new TestStateListener();
458     sp<TestStateListener> listener3 = new TestStateListener();
459     sp<TestStateListener> listener4 = new TestStateListener();
460     StateManager mgr;
461     mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
462     mgr.registerListener(util::UID_PROCESS_STATE_CHANGED, listener2);
463     mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener3);
464     mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener4);
465 
466     std::unique_ptr<LogEvent> event1 = CreateUidProcessStateChangedEvent(
467             timestampNs, 1000 /*uid*/,
468             android::app::ProcessStateEnum::PROCESS_STATE_TOP);  //  state value: 1002
469     std::unique_ptr<LogEvent> event2 = CreateUidProcessStateChangedEvent(
470             timestampNs + 1000, 1001 /*uid*/,
471             android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE);  //  state value:
472                                                                                 //  1003
473     std::unique_ptr<LogEvent> event3 = CreateUidProcessStateChangedEvent(
474             timestampNs + 2000, 1002 /*uid*/,
475             android::app::ProcessStateEnum::PROCESS_STATE_PERSISTENT);  //  state value: 1000
476     std::unique_ptr<LogEvent> event4 = CreateUidProcessStateChangedEvent(
477             timestampNs + 3000, 1001 /*uid*/,
478             android::app::ProcessStateEnum::PROCESS_STATE_TOP);  //  state value: 1002
479     std::unique_ptr<LogEvent> event5 = CreateScreenStateChangedEvent(
480             timestampNs + 4000, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
481     std::unique_ptr<LogEvent> event6 = CreateOverlayStateChangedEvent(
482             timestampNs + 5000, 1000 /*uid*/, "package1", true /*using_alert_window*/,
483             OverlayStateChanged::ENTERED);
484     std::unique_ptr<LogEvent> event7 = CreateOverlayStateChangedEvent(
485             timestampNs + 6000, 1000 /*uid*/, "package2", true /*using_alert_window*/,
486             OverlayStateChanged::EXITED);
487 
488     std::vector<int> attributionUids = {1005};
489     std::vector<string> attributionTags = {"tag"};
490 
491     std::unique_ptr<LogEvent> event8 = CreateAcquireWakelockEvent(
492             timestampNs + 7000, attributionUids, attributionTags, "wakelock1");
493     std::unique_ptr<LogEvent> event9 = CreateReleaseWakelockEvent(
494             timestampNs + 8000, attributionUids, attributionTags, "wakelock2");
495 
496     mgr.onLogEvent(*event1);
497     mgr.onLogEvent(*event2);
498     mgr.onLogEvent(*event3);
499     mgr.onLogEvent(*event5);
500     mgr.onLogEvent(*event5);
501     mgr.onLogEvent(*event6);
502     mgr.onLogEvent(*event7);
503     mgr.onLogEvent(*event8);
504     mgr.onLogEvent(*event9);
505 
506     // Query for UidProcessState of uid 1001
507     HashableDimensionKey queryKey1;
508     getUidProcessKey(1001, &queryKey1);
509     EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE,
510               getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey1));
511 
512     // Query for UidProcessState of uid 1004 - not in state map
513     HashableDimensionKey queryKey2;
514     getUidProcessKey(1004, &queryKey2);
515     EXPECT_EQ(-1, getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED,
516                               queryKey2));  // default state
517 
518     // Query for UidProcessState of uid 1001 - after change in state
519     mgr.onLogEvent(*event4);
520     EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_TOP,
521               getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey1));
522 
523     // Query for ScreenState
524     EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
525               getStateInt(mgr, util::SCREEN_STATE_CHANGED, DEFAULT_DIMENSION_KEY));
526 
527     // Query for OverlayState of uid 1000, package name "package2"
528     HashableDimensionKey queryKey3;
529     getOverlayKey(1000, "package2", &queryKey3);
530     EXPECT_EQ(OverlayStateChanged::EXITED,
531               getStateInt(mgr, util::OVERLAY_STATE_CHANGED, queryKey3));
532 
533     // Query for WakelockState of uid 1005, tag 2
534     HashableDimensionKey queryKey4;
535     getPartialWakelockKey(1005, "wakelock2", &queryKey4);
536     EXPECT_EQ(WakelockStateChanged::RELEASE,
537               getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey4));
538 
539     // Query for WakelockState of uid 1005, tag 1
540     HashableDimensionKey queryKey5;
541     getPartialWakelockKey(1005, "wakelock1", &queryKey5);
542     EXPECT_EQ(WakelockStateChanged::ACQUIRE,
543               getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey5));
544 }
545 
546 /**
547  * Test StateManager's onLogEvent and StateListener's onStateChanged
548  * when there is an error extracting state from log event. Listener is not
549  * updated of state change.
550  */
TEST(StateTrackerTest,TestMalformedStateEvent_NoExistingStateValue)551 TEST(StateTrackerTest, TestMalformedStateEvent_NoExistingStateValue) {
552     sp<TestStateListener> listener1 = new TestStateListener();
553     StateManager mgr;
554     mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener1);
555 
556     // log event
557     std::shared_ptr<LogEvent> event1 =
558             buildIncorrectOverlayEvent(1000 /* uid */, "package1", 1 /* state */);
559     std::shared_ptr<LogEvent> event2 = buildOverlayEventBadStateType(1001 /* uid */, "package2");
560 
561     // check listener was not updated
562     mgr.onLogEvent(*event1);
563     ASSERT_EQ(0, listener1->updates.size());
564     mgr.onLogEvent(*event2);
565     ASSERT_EQ(0, listener1->updates.size());
566 }
567 
TEST(StateTrackerTest,TestMalformedStateEvent_ExistingStateValue)568 TEST(StateTrackerTest, TestMalformedStateEvent_ExistingStateValue) {
569     sp<TestStateListener> listener = new TestStateListener();
570     StateManager mgr;
571     mgr.registerListener(util::PLUGGED_STATE_CHANGED, listener);
572 
573     std::unique_ptr<LogEvent> event1 = CreateBatteryStateChangedEvent(
574             timestampNs, BatteryPluggedStateEnum::BATTERY_PLUGGED_USB);
575     mgr.onLogEvent(*event1);
576     ASSERT_EQ(1, listener->updates.size());
577     EXPECT_EQ(BatteryPluggedStateEnum::BATTERY_PLUGGED_USB, listener->updates[0].mState);
578     FieldValue stateFieldValue;
579     mgr.getStateValue(util::PLUGGED_STATE_CHANGED, listener->updates[0].mKey, &stateFieldValue);
580     EXPECT_EQ(BatteryPluggedStateEnum::BATTERY_PLUGGED_USB, stateFieldValue.mValue.int_value);
581     listener->updates.clear();
582 
583     // Malformed event.
584     std::unique_ptr<LogEvent> event2 = CreateMalformedBatteryStateChangedEvent(timestampNs + 1000);
585     mgr.onLogEvent(*event2);
586     ASSERT_EQ(1, listener->updates.size());
587     EXPECT_EQ(kStateUnknown, listener->updates[0].mState);
588     EXPECT_FALSE(mgr.getStateValue(util::PLUGGED_STATE_CHANGED, listener->updates[0].mKey,
589                                    &stateFieldValue));
590     EXPECT_EQ(kStateUnknown, stateFieldValue.mValue.int_value);
591     listener->updates.clear();
592 }
593 
594 }  // namespace statsd
595 }  // namespace os
596 }  // namespace android
597 #else
598 GTEST_LOG_(INFO) << "This test does nothing.\n";
599 #endif
600