1 /*
2  * Copyright 2018 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 
17 package com.android.server.wifi;
18 
19 import static junit.framework.Assert.assertEquals;
20 import static junit.framework.Assert.assertFalse;
21 import static junit.framework.Assert.assertNotNull;
22 import static junit.framework.Assert.assertNull;
23 import static junit.framework.Assert.assertTrue;
24 
25 import androidx.test.filters.SmallTest;
26 
27 import com.android.server.wifi.proto.nano.WifiMetricsProto.WifiWakeStats;
28 
29 import org.junit.Before;
30 import org.junit.Test;
31 
32 @SmallTest
33 public class WifiWakeMetricsTest extends WifiBaseTest {
34 
35     private WifiWakeMetrics mWifiWakeMetrics;
36 
37     @Before
setUp()38     public void setUp() {
39         mWifiWakeMetrics = new WifiWakeMetrics();
40     }
41 
42     @Test
buildsEmptyProto()43     public void buildsEmptyProto() {
44         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
45         assertNotNull(wifiWakeStats);
46         assertEquals(wifiWakeStats.numSessions, 0);
47         assertEquals(wifiWakeStats.numWakeups, 0);
48         assertEquals(wifiWakeStats.numIgnoredStarts, 0);
49         assertEquals(wifiWakeStats.sessions.length, 0);
50     }
51 
52     @Test
buildsMultiSessionProto_fewerThanMax()53     public void buildsMultiSessionProto_fewerThanMax() {
54         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
55         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
56 
57         mWifiWakeMetrics.recordStartEvent(1 /* numNetworks */);
58         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
59 
60         mWifiWakeMetrics.recordStartEvent(2 /* numNetworks */);
61         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
62 
63         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
64         assertNotNull(wifiWakeStats);
65         assertEquals(wifiWakeStats.numSessions, 3);
66         assertEquals(wifiWakeStats.numWakeups, 0);
67         assertEquals(wifiWakeStats.sessions.length, 3);
68     }
69 
70     @Test
buildsMultiSessionProto_greaterThanMax()71     public void buildsMultiSessionProto_greaterThanMax() {
72         int numSessions = WifiWakeMetrics.MAX_RECORDED_SESSIONS + 1;
73         for (int i = 0; i < numSessions; i++) {
74             mWifiWakeMetrics.recordStartEvent(i);
75             mWifiWakeMetrics.recordInitializeEvent(i, i);
76             mWifiWakeMetrics.recordUnlockEvent(i);
77             mWifiWakeMetrics.recordWakeupEvent(i);
78             mWifiWakeMetrics.recordResetEvent(i);
79         }
80 
81         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
82         assertNotNull(wifiWakeStats);
83         assertEquals(wifiWakeStats.numSessions, numSessions);
84         assertEquals(wifiWakeStats.numWakeups, numSessions);
85         assertEquals(wifiWakeStats.sessions.length, WifiWakeMetrics.MAX_RECORDED_SESSIONS);
86 
87         // ensure that the first (not last) MAX_RECORDED_SESSIONS are recorded
88         for (int i = 0; i < WifiWakeMetrics.MAX_RECORDED_SESSIONS; i++) {
89             WifiWakeStats.Session session = wifiWakeStats.sessions[i];
90             assertNotNull(session);
91             assertEquals(session.lockedNetworksAtStart, i);
92             assertEquals(session.lockedNetworksAtInitialize, i);
93         }
94     }
95 
96     @Test
buildProtoCountsWakes()97     public void buildProtoCountsWakes() {
98         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
99         mWifiWakeMetrics.recordWakeupEvent(3 /* numScans */);
100         mWifiWakeMetrics.recordResetEvent(3 /* numScans */);
101 
102         mWifiWakeMetrics.recordStartEvent(1 /* numNetworks */);
103         mWifiWakeMetrics.recordWakeupEvent(3 /* numScans */);
104         mWifiWakeMetrics.recordResetEvent(3 /* numScans */);
105 
106         mWifiWakeMetrics.recordStartEvent(2 /* numNetworks */);
107         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
108 
109         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
110         assertNotNull(wifiWakeStats);
111         assertEquals(wifiWakeStats.numSessions, 3);
112         assertEquals(wifiWakeStats.numWakeups, 2);
113         assertEquals(wifiWakeStats.sessions.length, 3);
114     }
115 
116     @Test
buildProtoDoesNotCountWakeInCurrentSession()117     public void buildProtoDoesNotCountWakeInCurrentSession() {
118         mWifiWakeMetrics.recordStartEvent(1 /* numNetworks */);
119         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
120 
121         mWifiWakeMetrics.recordStartEvent(2 /* numNetworks */);
122         mWifiWakeMetrics.recordWakeupEvent(3 /* numScans */);
123 
124         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
125         assertNotNull(wifiWakeStats);
126         assertEquals(wifiWakeStats.numSessions, 1);
127         assertEquals(wifiWakeStats.numWakeups, 0);
128         assertEquals(wifiWakeStats.sessions.length, 1);
129     }
130 
131     @Test
buildProtoCountsIgnoredStarts()132     public void buildProtoCountsIgnoredStarts() {
133         mWifiWakeMetrics.recordIgnoredStart();
134         mWifiWakeMetrics.recordIgnoredStart();
135         mWifiWakeMetrics.recordIgnoredStart();
136 
137         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
138         assertNotNull(wifiWakeStats);
139         assertEquals(wifiWakeStats.numIgnoredStarts, 3);
140     }
141 
142     @Test
buildProtoDoesNotIncludeCurrentSession()143     public void buildProtoDoesNotIncludeCurrentSession() {
144         mWifiWakeMetrics.recordStartEvent(1 /* numNetworks */);
145         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
146 
147         mWifiWakeMetrics.recordStartEvent(2 /* numNetworks */);
148 
149         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
150         assertNotNull(wifiWakeStats);
151         assertEquals(wifiWakeStats.numSessions, 1);
152         assertEquals(wifiWakeStats.sessions.length, 1);
153         assertEquals(wifiWakeStats.sessions[0].lockedNetworksAtStart, 1);
154     }
155 
156     @Test
ignoresEventsIfStartNotCalled()157     public void ignoresEventsIfStartNotCalled() {
158         mWifiWakeMetrics.recordUnlockEvent(1 /* numScans */);
159         mWifiWakeMetrics.recordWakeupEvent(1 /* numScans */);
160         mWifiWakeMetrics.recordResetEvent(1 /* numScans */);
161 
162         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
163         assertNotNull(wifiWakeStats);
164         assertEquals(wifiWakeStats.numSessions, 0);
165         assertEquals(wifiWakeStats.sessions.length, 0);
166     }
167 
168     @Test
ignoresEventsAfterResetAndBeforeStartCalled()169     public void ignoresEventsAfterResetAndBeforeStartCalled() {
170         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
171         mWifiWakeMetrics.recordWakeupEvent(1 /* numScans */);
172         mWifiWakeMetrics.recordResetEvent(1 /* numScans */);
173 
174         mWifiWakeMetrics.recordWakeupEvent(10 /* numScans */);
175 
176         // verify only 1 session
177         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
178         assertNotNull(wifiWakeStats);
179         assertEquals(wifiWakeStats.numSessions, 1);
180         assertEquals(wifiWakeStats.sessions.length, 1);
181 
182         // verify it didn't overwrite session
183         WifiWakeStats.Session session = wifiWakeStats.sessions[0];
184         assertNotNull(session.wakeupEvent);
185         assertEquals(session.wakeupEvent.elapsedScans, 1);
186     }
187 
188     @Test
clearRemovesSessions()189     public void clearRemovesSessions() {
190         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
191         mWifiWakeMetrics.recordWakeupEvent(3 /* numScans */);
192         mWifiWakeMetrics.recordResetEvent(3 /* numScans */);
193 
194         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
195         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
196 
197         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
198         mWifiWakeMetrics.recordIgnoredStart();
199         mWifiWakeMetrics.recordIgnoredStart();
200         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
201 
202         // verify sessions
203         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
204         assertNotNull(wifiWakeStats);
205         assertEquals(wifiWakeStats.numSessions, 3);
206         assertEquals(wifiWakeStats.numWakeups, 1);
207         assertEquals(wifiWakeStats.numIgnoredStarts, 2);
208         assertEquals(wifiWakeStats.sessions.length, 3);
209 
210         mWifiWakeMetrics.clear();
211         wifiWakeStats = mWifiWakeMetrics.buildProto();
212         assertNotNull(wifiWakeStats);
213         assertEquals(wifiWakeStats.numSessions, 0);
214         assertEquals(wifiWakeStats.numWakeups, 0);
215         assertEquals(wifiWakeStats.numIgnoredStarts, 0);
216         assertEquals(wifiWakeStats.sessions.length, 0);
217     }
218 
219     @Test
clearDoesNotInterruptCurrentSession()220     public void clearDoesNotInterruptCurrentSession() {
221         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
222         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
223         mWifiWakeMetrics.recordStartEvent(0 /* numNetworks */);
224         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
225 
226         mWifiWakeMetrics.recordStartEvent(1 /* numNetworks */);
227         mWifiWakeMetrics.clear();
228         mWifiWakeMetrics.recordResetEvent(0 /* numScans */);
229 
230         // keeps the current session
231         WifiWakeStats wifiWakeStats = mWifiWakeMetrics.buildProto();
232         assertNotNull(wifiWakeStats);
233         assertEquals(wifiWakeStats.numSessions, 1);
234         assertEquals(wifiWakeStats.sessions.length, 1);
235     }
236 
237     @Test
session_buildsEmptyProto()238     public void session_buildsEmptyProto() {
239         WifiWakeMetrics.Session session =
240                 new WifiWakeMetrics.Session(1 /* numNetworks */, 1000 /* timestamp */);
241 
242         WifiWakeStats.Session sessionProto = session.buildProto();
243         assertNotNull(sessionProto);
244         assertEquals(sessionProto.lockedNetworksAtStart, 1);
245         assertEquals(sessionProto.startTimeMillis, 1000);
246         assertNull(sessionProto.unlockEvent);
247         assertNull(sessionProto.wakeupEvent);
248         assertNull(sessionProto.resetEvent);
249     }
250 
251     @Test
session_recordsEvents()252     public void session_recordsEvents() {
253         WifiWakeMetrics.Session session =
254                 new WifiWakeMetrics.Session(1 /* numNetworks */, 1000 /* timestamp */);
255 
256         session.recordUnlockEvent(1 /* numScans */, 1100 /* timestamp */);
257         assertNotNull(session.mUnlockEvent);
258         assertEquals(session.mUnlockEvent.mNumScans, 1);
259         assertEquals(session.mUnlockEvent.mElapsedTime, 100);
260 
261         session.recordWakeupEvent(2 /* numScans */, 1200 /* timestamp */);
262         assertNotNull(session.mWakeupEvent);
263         assertEquals(session.mWakeupEvent.mNumScans, 2);
264         assertEquals(session.mWakeupEvent.mElapsedTime, 200);
265 
266         session.recordResetEvent(3 /* numScans */, 1300 /* timestamp */);
267         assertNotNull(session.mResetEvent);
268         assertEquals(session.mResetEvent.mNumScans, 3);
269         assertEquals(session.mResetEvent.mElapsedTime, 300);
270     }
271 
272     @Test
session_buildProto()273     public void session_buildProto() {
274         WifiWakeMetrics.Session session =
275                 new WifiWakeMetrics.Session(1 /* numNetworks */, 1000 /* timestamp */);
276 
277         session.recordInitializeEvent(1 /* numScans */, 2 /* numNetworks */, 1100 /* timestamp */);
278         session.recordUnlockEvent(2 /* numScans */, 1200 /* timestamp */);
279         session.recordWakeupEvent(3 /* numScans */, 1300 /* timestamp */);
280         session.recordResetEvent(4 /* numScans */, 1400 /* timestamp */);
281 
282         WifiWakeStats.Session sessionProto = session.buildProto();
283         assertNotNull(sessionProto);
284         assertEquals(sessionProto.lockedNetworksAtStart, 1);
285         assertEquals(sessionProto.lockedNetworksAtInitialize, 2);
286         assertEquals(sessionProto.startTimeMillis, 1000);
287 
288         verifyEventProto(sessionProto.initializeEvent, 1, 100);
289         verifyEventProto(sessionProto.unlockEvent, 2, 200);
290         verifyEventProto(sessionProto.wakeupEvent, 3, 300);
291         verifyEventProto(sessionProto.resetEvent, 4, 400);
292     }
293 
294     @Test
session_ignoresRepeatedEvents()295     public void session_ignoresRepeatedEvents() {
296         WifiWakeMetrics.Session session =
297                 new WifiWakeMetrics.Session(1 /* numNetworks */, 1000 /* timestamp */);
298 
299         session.recordResetEvent(1 /* numScans */, 1100 /* timestamp */);
300         assertNotNull(session.mResetEvent);
301         assertEquals(session.mResetEvent.mNumScans, 1);
302         assertEquals(session.mResetEvent.mElapsedTime, 100);
303 
304         session.recordResetEvent(2 /* numScans */, 1200 /* timestamp */);
305         assertEquals(session.mResetEvent.mNumScans, 1);
306         assertEquals(session.mResetEvent.mElapsedTime, 100);
307     }
308 
309     @Test
session_hasWakeupTriggered()310     public void session_hasWakeupTriggered() {
311         WifiWakeMetrics.Session session =
312                 new WifiWakeMetrics.Session(0 /* numNetworks */, 1000 /* timestamp */);
313         assertFalse(session.hasWakeupTriggered());
314 
315         session.recordInitializeEvent(3 /* numScans */, 0 /* numNetworks */, 1100 /* timestamp */);
316         assertFalse(session.hasWakeupTriggered());
317 
318         session.recordWakeupEvent(3 /* numScans */, 1100 /* timestamp */);
319         assertTrue(session.hasWakeupTriggered());
320 
321         session.recordResetEvent(3 /* numScans */, 1100 /* timestamp */);
322         assertTrue(session.hasWakeupTriggered());
323     }
324 
325     @Test
event_buildsProto()326     public void event_buildsProto() {
327         WifiWakeMetrics.Event event =
328                 new WifiWakeMetrics.Event(1 /* numScans */, 1000 /* elapsedTime */);
329 
330         verifyEventProto(event.buildProto(), 1, 1000);
331     }
332 
verifyEventProto(WifiWakeStats.Session.Event event, int scans, int elapsedTime)333     private void verifyEventProto(WifiWakeStats.Session.Event event, int scans, int elapsedTime) {
334         assertNotNull(event);
335         assertEquals(event.elapsedScans, scans);
336         assertEquals(event.elapsedTimeMillis, elapsedTime);
337     }
338 }
339