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