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