WifiMonitorTest.java revision 35c9c7f7a2f83d81b8d61da834b3960f5b9ffe19 
1/*
2 * Copyright (C) 2017 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
17package com.android.server.wifi;
18
19import static org.junit.Assert.assertArrayEquals;
20import static org.junit.Assert.assertEquals;
21import static org.junit.Assert.assertNull;
22import static org.mockito.Mockito.mock;
23import static org.mockito.Mockito.spy;
24import static org.mockito.Mockito.verify;
25
26import android.hardware.wifi.supplicant.V1_0.ISupplicantStaIfaceCallback.WpsConfigError;
27import android.hardware.wifi.supplicant.V1_0.ISupplicantStaIfaceCallback.WpsErrorIndication;
28import android.net.wifi.SupplicantState;
29import android.net.wifi.WifiEnterpriseConfig;
30import android.net.wifi.WifiManager;
31import android.net.wifi.WifiSsid;
32import android.os.Handler;
33import android.os.Message;
34import android.os.test.TestLooper;
35import android.test.suitebuilder.annotation.SmallTest;
36
37import com.android.server.wifi.hotspot2.AnqpEvent;
38import com.android.server.wifi.hotspot2.IconEvent;
39import com.android.server.wifi.util.TelephonyUtil;
40
41import org.junit.Before;
42import org.junit.Test;
43import org.mockito.ArgumentCaptor;
44
45/**
46 * Unit tests for {@link com.android.server.wifi.WifiMonitor}.
47 */
48@SmallTest
49public class WifiMonitorTest {
50    private static final String WLAN_IFACE_NAME = "wlan0";
51    private static final String[] GSM_AUTH_DATA = { "45adbc", "fead45", "0x3452"};
52    private static final String[] UMTS_AUTH_DATA = { "fead45", "0x3452"};
53    private static final String BSSID = "fe:45:23:12:12:0a";
54    private static final int NETWORK_ID = 5;
55    private static final String SSID = "\"test124\"";
56    private WifiMonitor mWifiMonitor;
57    private TestLooper mLooper;
58    private Handler mHandlerSpy;
59
60    @Before
61    public void setUp() throws Exception {
62        mWifiMonitor = new WifiMonitor(mock(WifiInjector.class));
63        mLooper = new TestLooper();
64        mHandlerSpy = spy(new Handler(mLooper.getLooper()));
65        mWifiMonitor.setMonitoring(WLAN_IFACE_NAME, true);
66    }
67
68    /**
69     * Broadcast WPS failure event test.
70     */
71    @Test
72    public void testBroadcastWpsEventFailDueToErrorTkipOnlyProhibhited() {
73        mWifiMonitor.registerHandler(
74                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
75        mWifiMonitor.broadcastWpsFailEvent(
76                WLAN_IFACE_NAME, WpsConfigError.NO_ERROR,
77                WpsErrorIndication.SECURITY_TKIP_ONLY_PROHIBITED);
78        mLooper.dispatchAll();
79
80        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
81        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
82        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
83        assertEquals(WifiManager.WPS_TKIP_ONLY_PROHIBITED, messageCaptor.getValue().arg1);
84    }
85
86    /**
87     * Broadcast WPS failure event test.
88     */
89    @Test
90    public void testBroadcastWpsEventFailDueToErrorWepProhibhited() {
91        mWifiMonitor.registerHandler(
92                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
93        mWifiMonitor.broadcastWpsFailEvent(
94                WLAN_IFACE_NAME, WpsConfigError.NO_ERROR,
95                WpsErrorIndication.SECURITY_WEP_PROHIBITED);
96        mLooper.dispatchAll();
97
98        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
99        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
100        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
101        assertEquals(WifiManager.WPS_WEP_PROHIBITED, messageCaptor.getValue().arg1);
102    }
103
104    /**
105     * Broadcast WPS failure event test.
106     */
107    @Test
108    public void testBroadcastWpsEventFailDueToConfigAuthError() {
109        mWifiMonitor.registerHandler(
110                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
111        mWifiMonitor.broadcastWpsFailEvent(
112                WLAN_IFACE_NAME, WpsConfigError.DEV_PASSWORD_AUTH_FAILURE,
113                WpsErrorIndication.NO_ERROR);
114
115        mLooper.dispatchAll();
116        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
117        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
118        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
119        assertEquals(WifiManager.WPS_AUTH_FAILURE, messageCaptor.getValue().arg1);
120    }
121
122    /**
123     * Broadcast WPS failure event test.
124     */
125    @Test
126    public void testBroadcastWpsEventFailDueToConfigPbcOverlapError() {
127        mWifiMonitor.registerHandler(
128                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
129        mWifiMonitor.broadcastWpsFailEvent(
130                WLAN_IFACE_NAME, WpsConfigError.MULTIPLE_PBC_DETECTED,
131                WpsErrorIndication.NO_ERROR);
132        mLooper.dispatchAll();
133
134        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
135        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
136        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
137        assertEquals(WifiManager.WPS_OVERLAP_ERROR, messageCaptor.getValue().arg1);
138    }
139
140    /**
141     * Broadcast WPS failure event test.
142     */
143    @Test
144    public void testBroadcastWpsEventFailDueToConfigError() {
145        mWifiMonitor.registerHandler(
146                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
147        mWifiMonitor.broadcastWpsFailEvent(
148                WLAN_IFACE_NAME, WpsConfigError.MSG_TIMEOUT,
149                WpsErrorIndication.NO_ERROR);
150        mLooper.dispatchAll();
151
152        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
153        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
154        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
155        assertEquals(WifiManager.ERROR, messageCaptor.getValue().arg1);
156        assertEquals(WpsConfigError.MSG_TIMEOUT, messageCaptor.getValue().arg2);
157    }
158
159    /**
160     * Broadcast WPS success event test.
161     */
162    @Test
163    public void testBroadcastWpsEventSuccess() {
164        mWifiMonitor.registerHandler(
165                WLAN_IFACE_NAME, WifiMonitor.WPS_SUCCESS_EVENT, mHandlerSpy);
166        mWifiMonitor.broadcastWpsSuccessEvent(WLAN_IFACE_NAME);
167        mLooper.dispatchAll();
168
169        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
170        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
171        assertEquals(WifiMonitor.WPS_SUCCESS_EVENT, messageCaptor.getValue().what);
172    }
173
174    /**
175     * Broadcast WPS overlap event test.
176     */
177    @Test
178    public void testBroadcastWpsEventOverlap() {
179        mWifiMonitor.registerHandler(
180                WLAN_IFACE_NAME, WifiMonitor.WPS_OVERLAP_EVENT, mHandlerSpy);
181        mWifiMonitor.broadcastWpsOverlapEvent(WLAN_IFACE_NAME);
182        mLooper.dispatchAll();
183
184        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
185        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
186        assertEquals(WifiMonitor.WPS_OVERLAP_EVENT, messageCaptor.getValue().what);
187    }
188
189    /**
190     * Broadcast WPS timeout event test.
191     */
192    @Test
193    public void testBroadcastWpsEventTimeout() {
194        mWifiMonitor.registerHandler(
195                WLAN_IFACE_NAME, WifiMonitor.WPS_TIMEOUT_EVENT, mHandlerSpy);
196        mWifiMonitor.broadcastWpsTimeoutEvent(WLAN_IFACE_NAME);
197        mLooper.dispatchAll();
198
199        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
200        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
201        assertEquals(WifiMonitor.WPS_TIMEOUT_EVENT, messageCaptor.getValue().what);
202    }
203
204    /**
205     * Broadcast ANQP done event test.
206     */
207    @Test
208    public void testBroadcastAnqpDoneEvent() {
209        mWifiMonitor.registerHandler(
210                WLAN_IFACE_NAME, WifiMonitor.ANQP_DONE_EVENT, mHandlerSpy);
211        long bssid = 5;
212        mWifiMonitor.broadcastAnqpDoneEvent(WLAN_IFACE_NAME, new AnqpEvent(bssid, null));
213        mLooper.dispatchAll();
214
215        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
216        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
217        assertEquals(WifiMonitor.ANQP_DONE_EVENT, messageCaptor.getValue().what);
218        assertEquals(bssid, ((AnqpEvent) messageCaptor.getValue().obj).getBssid());
219        assertNull(((AnqpEvent) messageCaptor.getValue().obj).getElements());
220    }
221
222    /**
223     * Broadcast Icon event test.
224     */
225    @Test
226    public void testBroadcastIconDoneEvent() {
227        mWifiMonitor.registerHandler(
228                WLAN_IFACE_NAME, WifiMonitor.RX_HS20_ANQP_ICON_EVENT, mHandlerSpy);
229        long bssid = 5;
230        String fileName = "test";
231        int fileSize = 0;
232        mWifiMonitor.broadcastIconDoneEvent(
233                WLAN_IFACE_NAME, new IconEvent(bssid, fileName, fileSize, null));
234        mLooper.dispatchAll();
235
236        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
237        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
238        assertEquals(WifiMonitor.RX_HS20_ANQP_ICON_EVENT, messageCaptor.getValue().what);
239        assertEquals(bssid, ((IconEvent) messageCaptor.getValue().obj).getBSSID());
240        assertEquals(fileName, ((IconEvent) messageCaptor.getValue().obj).getFileName());
241        assertEquals(fileSize, ((IconEvent) messageCaptor.getValue().obj).getSize());
242        assertNull(((IconEvent) messageCaptor.getValue().obj).getData());
243    }
244
245    /**
246     * Broadcast network Gsm auth request test.
247     */
248    @Test
249    public void testBroadcastNetworkGsmAuthRequestEvent() {
250        mWifiMonitor.registerHandler(
251                WLAN_IFACE_NAME, WifiMonitor.SUP_REQUEST_SIM_AUTH, mHandlerSpy);
252        int networkId = NETWORK_ID;
253        String ssid = SSID;
254        String[] data = GSM_AUTH_DATA;
255        mWifiMonitor.broadcastNetworkGsmAuthRequestEvent(WLAN_IFACE_NAME, networkId, ssid, data);
256        mLooper.dispatchAll();
257
258        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
259        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
260        assertEquals(WifiMonitor.SUP_REQUEST_SIM_AUTH, messageCaptor.getValue().what);
261        TelephonyUtil.SimAuthRequestData authData =
262                (TelephonyUtil.SimAuthRequestData) messageCaptor.getValue().obj;
263        assertEquals(networkId, authData.networkId);
264        assertEquals(ssid, authData.ssid);
265        assertEquals(WifiEnterpriseConfig.Eap.SIM, authData.protocol);
266        assertArrayEquals(data, authData.data);
267    }
268
269    /**
270     * Broadcast network Umts auth request test.
271     */
272    @Test
273    public void testBroadcastNetworkUmtsAuthRequestEvent() {
274        mWifiMonitor.registerHandler(
275                WLAN_IFACE_NAME, WifiMonitor.SUP_REQUEST_SIM_AUTH, mHandlerSpy);
276        int networkId = NETWORK_ID;
277        String ssid = SSID;
278        String[] data = UMTS_AUTH_DATA;
279        mWifiMonitor.broadcastNetworkUmtsAuthRequestEvent(WLAN_IFACE_NAME, networkId, ssid, data);
280        mLooper.dispatchAll();
281
282        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
283        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
284        assertEquals(WifiMonitor.SUP_REQUEST_SIM_AUTH, messageCaptor.getValue().what);
285        TelephonyUtil.SimAuthRequestData authData =
286                (TelephonyUtil.SimAuthRequestData) messageCaptor.getValue().obj;
287        assertEquals(networkId, authData.networkId);
288        assertEquals(ssid, authData.ssid);
289        assertEquals(WifiEnterpriseConfig.Eap.AKA, authData.protocol);
290        assertArrayEquals(data, authData.data);
291    }
292
293    /**
294     * Broadcast Scan results event test.
295     */
296    @Test
297    public void testBroadcastScanResultsEvent() {
298        mWifiMonitor.registerHandler(
299                WLAN_IFACE_NAME, WifiMonitor.SCAN_RESULTS_EVENT, mHandlerSpy);
300        mWifiMonitor.broadcastScanResultEvent(WLAN_IFACE_NAME);
301        mLooper.dispatchAll();
302
303        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
304        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
305        assertEquals(WifiMonitor.SCAN_RESULTS_EVENT, messageCaptor.getValue().what);
306    }
307
308    /**
309     * Broadcast Scan failed event test.
310     */
311    @Test
312    public void testBroadcastScanFailedEvent() {
313        mWifiMonitor.registerHandler(
314                WLAN_IFACE_NAME, WifiMonitor.SCAN_FAILED_EVENT, mHandlerSpy);
315        mWifiMonitor.broadcastScanFailedEvent(WLAN_IFACE_NAME);
316        mLooper.dispatchAll();
317
318        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
319        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
320
321        assertEquals(WifiMonitor.SCAN_FAILED_EVENT, messageCaptor.getValue().what);
322    }
323
324    /**
325     * Broadcast authentication failure test.
326     */
327    @Test
328    public void testBroadcastAuthenticationFailureEvent() {
329        mWifiMonitor.registerHandler(
330                WLAN_IFACE_NAME, WifiMonitor.AUTHENTICATION_FAILURE_EVENT, mHandlerSpy);
331        int reason = WifiMonitor.AUTHENTICATION_FAILURE_REASON_WRONG_PSWD;
332        mWifiMonitor.broadcastAuthenticationFailureEvent(WLAN_IFACE_NAME, reason);
333        mLooper.dispatchAll();
334
335        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
336        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
337        assertEquals(WifiMonitor.AUTHENTICATION_FAILURE_EVENT, messageCaptor.getValue().what);
338        assertEquals(reason, messageCaptor.getValue().arg2);
339
340    }
341
342
343    /**
344     * Broadcast association rejection test.
345     */
346    @Test
347    public void testBroadcastAssociationRejectionEvent() {
348        mWifiMonitor.registerHandler(
349                WLAN_IFACE_NAME, WifiMonitor.ASSOCIATION_REJECTION_EVENT, mHandlerSpy);
350        int status = 5;
351        String bssid = BSSID;
352        mWifiMonitor.broadcastAssociationRejectionEvent(WLAN_IFACE_NAME, status, false, bssid);
353        mLooper.dispatchAll();
354
355        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
356        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
357        assertEquals(WifiMonitor.ASSOCIATION_REJECTION_EVENT, messageCaptor.getValue().what);
358        assertEquals(0, messageCaptor.getValue().arg1);
359        assertEquals(status, messageCaptor.getValue().arg2);
360        assertEquals(bssid, (String) messageCaptor.getValue().obj);
361    }
362
363    /**
364     * Broadcast associated bssid test.
365     */
366    @Test
367    public void testBroadcastAssociatedBssidEvent() {
368        mWifiMonitor.registerHandler(
369                WLAN_IFACE_NAME, WifiStateMachine.CMD_ASSOCIATED_BSSID, mHandlerSpy);
370        String bssid = BSSID;
371        mWifiMonitor.broadcastAssociatedBssidEvent(WLAN_IFACE_NAME, bssid);
372        mLooper.dispatchAll();
373
374        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
375        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
376        assertEquals(WifiStateMachine.CMD_ASSOCIATED_BSSID, messageCaptor.getValue().what);
377        assertEquals(bssid, (String) messageCaptor.getValue().obj);
378    }
379
380    /**
381     * Broadcast network connection test.
382     */
383    @Test
384    public void testBroadcastNetworkConnectionEvent() {
385        mWifiMonitor.registerHandler(
386                WLAN_IFACE_NAME, WifiMonitor.NETWORK_CONNECTION_EVENT, mHandlerSpy);
387        int networkId = NETWORK_ID;
388        String bssid = BSSID;
389        mWifiMonitor.broadcastNetworkConnectionEvent(WLAN_IFACE_NAME, networkId, bssid);
390        mLooper.dispatchAll();
391
392        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
393        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
394        assertEquals(WifiMonitor.NETWORK_CONNECTION_EVENT, messageCaptor.getValue().what);
395        assertEquals(networkId, messageCaptor.getValue().arg1);
396        assertEquals(bssid, (String) messageCaptor.getValue().obj);
397    }
398
399    /**
400     * Broadcast network disconnection test.
401     */
402    @Test
403    public void testBroadcastNetworkDisconnectionEvent() {
404        mWifiMonitor.registerHandler(
405                WLAN_IFACE_NAME, WifiMonitor.NETWORK_DISCONNECTION_EVENT, mHandlerSpy);
406        int local = 1;
407        int reason  = 5;
408        String bssid = BSSID;
409        mWifiMonitor.broadcastNetworkDisconnectionEvent(WLAN_IFACE_NAME, local, reason, bssid);
410        mLooper.dispatchAll();
411
412        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
413        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
414        assertEquals(WifiMonitor.NETWORK_DISCONNECTION_EVENT, messageCaptor.getValue().what);
415        assertEquals(local, messageCaptor.getValue().arg1);
416        assertEquals(reason, messageCaptor.getValue().arg2);
417        assertEquals(bssid, (String) messageCaptor.getValue().obj);
418    }
419
420    /**
421     * Broadcast supplicant state change test.
422     */
423    @Test
424    public void testBroadcastSupplicantStateChangeEvent() {
425        mWifiMonitor.registerHandler(
426                WLAN_IFACE_NAME, WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT, mHandlerSpy);
427        int networkId = NETWORK_ID;
428        WifiSsid wifiSsid = WifiSsid.createFromAsciiEncoded(SSID);
429        String bssid = BSSID;
430        SupplicantState newState = SupplicantState.ASSOCIATED;
431        mWifiMonitor.broadcastSupplicantStateChangeEvent(
432                WLAN_IFACE_NAME, networkId, wifiSsid, bssid, newState);
433        mLooper.dispatchAll();
434
435        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
436        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
437        assertEquals(WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT, messageCaptor.getValue().what);
438        StateChangeResult result = (StateChangeResult) messageCaptor.getValue().obj;
439        assertEquals(networkId, result.networkId);
440        assertEquals(wifiSsid, result.wifiSsid);
441        assertEquals(bssid, result.BSSID);
442        assertEquals(newState, result.state);
443    }
444
445    /**
446     * Broadcast supplicant connection test.
447     */
448    @Test
449    public void testBroadcastSupplicantConnectionEvent() {
450        mWifiMonitor.registerHandler(
451                WLAN_IFACE_NAME, WifiMonitor.SUP_CONNECTION_EVENT, mHandlerSpy);
452        mWifiMonitor.broadcastSupplicantConnectionEvent(WLAN_IFACE_NAME);
453        mLooper.dispatchAll();
454
455        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
456        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
457        assertEquals(WifiMonitor.SUP_CONNECTION_EVENT, messageCaptor.getValue().what);
458    }
459    /**
460     * Broadcast supplicant disconnection test.
461     */
462    @Test
463    public void testBroadcastSupplicantDisconnectionEvent() {
464        mWifiMonitor.registerHandler(
465                WLAN_IFACE_NAME, WifiMonitor.SUP_DISCONNECTION_EVENT, mHandlerSpy);
466        mWifiMonitor.broadcastSupplicantDisconnectionEvent(WLAN_IFACE_NAME);
467        mLooper.dispatchAll();
468
469        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
470        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
471        assertEquals(WifiMonitor.SUP_DISCONNECTION_EVENT, messageCaptor.getValue().what);
472    }
473}
474