WifiMonitorTest.java revision 65d8ba5dd551cd132789e8feb270dfc7998dfbdc 
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.assertEquals;
20import static org.junit.Assert.assertNull;
21import static org.mockito.Mockito.spy;
22import static org.mockito.Mockito.verify;
23
24import android.hardware.wifi.supplicant.V1_0.ISupplicantStaIfaceCallback.WpsConfigError;
25import android.hardware.wifi.supplicant.V1_0.ISupplicantStaIfaceCallback.WpsErrorIndication;
26import android.net.wifi.WifiManager;
27import android.os.Handler;
28import android.os.Message;
29import android.os.test.TestLooper;
30import android.test.suitebuilder.annotation.SmallTest;
31
32import com.android.server.wifi.hotspot2.AnqpEvent;
33
34import org.junit.Before;
35import org.junit.Test;
36import org.mockito.ArgumentCaptor;
37
38import java.lang.reflect.Constructor;
39
40/**
41 * Unit tests for {@link com.android.server.wifi.WifiMonitor}.
42 */
43@SmallTest
44public class WifiMonitorTest {
45    private static final String WLAN_IFACE_NAME = "wlan0";
46    private WifiMonitor mWifiMonitor;
47    private TestLooper mLooper;
48    private Handler mHandlerSpy;
49
50    @Before
51    public void setUp() throws Exception {
52        final Constructor<WifiMonitor> wifiMonitorConstructor =
53                WifiMonitor.class.getDeclaredConstructor();
54        wifiMonitorConstructor.setAccessible(true);
55        mWifiMonitor = spy(wifiMonitorConstructor.newInstance());
56        mLooper = new TestLooper();
57        mHandlerSpy = spy(new Handler(mLooper.getLooper()));
58        mWifiMonitor.setMonitoring(WLAN_IFACE_NAME, true);
59    }
60
61    /**
62     * Broadcast WPS failure event test.
63     */
64    @Test
65    public void testBroadcastWpsEventFailDueToErrorTkipOnlyProhibhited() {
66        mWifiMonitor.registerHandler(
67                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
68        mWifiMonitor.broadcastWpsFailEvent(
69                WLAN_IFACE_NAME, WpsConfigError.NO_ERROR,
70                WpsErrorIndication.SECURITY_TKIP_ONLY_PROHIBITED);
71        mLooper.dispatchAll();
72
73        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
74        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
75        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
76        assertEquals(WifiManager.WPS_TKIP_ONLY_PROHIBITED, messageCaptor.getValue().arg1);
77    }
78
79    /**
80     * Broadcast WPS failure event test.
81     */
82    @Test
83    public void testBroadcastWpsEventFailDueToErrorWepProhibhited() {
84        mWifiMonitor.registerHandler(
85                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
86        mWifiMonitor.broadcastWpsFailEvent(
87                WLAN_IFACE_NAME, WpsConfigError.NO_ERROR,
88                WpsErrorIndication.SECURITY_WEP_PROHIBITED);
89        mLooper.dispatchAll();
90
91        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
92        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
93        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
94        assertEquals(WifiManager.WPS_WEP_PROHIBITED, messageCaptor.getValue().arg1);
95    }
96
97    /**
98     * Broadcast WPS failure event test.
99     */
100    @Test
101    public void testBroadcastWpsEventFailDueToConfigAuthError() {
102        mWifiMonitor.registerHandler(
103                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
104        mWifiMonitor.broadcastWpsFailEvent(
105                WLAN_IFACE_NAME, WpsConfigError.DEV_PASSWORD_AUTH_FAILURE,
106                WpsErrorIndication.NO_ERROR);
107
108        mLooper.dispatchAll();
109        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
110        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
111        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
112        assertEquals(WifiManager.WPS_AUTH_FAILURE, messageCaptor.getValue().arg1);
113    }
114
115    /**
116     * Broadcast WPS failure event test.
117     */
118    @Test
119    public void testBroadcastWpsEventFailDueToConfigPbcOverlapError() {
120        mWifiMonitor.registerHandler(
121                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
122        mWifiMonitor.broadcastWpsFailEvent(
123                WLAN_IFACE_NAME, WpsConfigError.MULTIPLE_PBC_DETECTED,
124                WpsErrorIndication.NO_ERROR);
125        mLooper.dispatchAll();
126
127        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
128        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
129        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
130        assertEquals(WifiManager.WPS_OVERLAP_ERROR, messageCaptor.getValue().arg1);
131    }
132
133    /**
134     * Broadcast WPS failure event test.
135     */
136    @Test
137    public void testBroadcastWpsEventFailDueToConfigError() {
138        mWifiMonitor.registerHandler(
139                WLAN_IFACE_NAME, WifiMonitor.WPS_FAIL_EVENT, mHandlerSpy);
140        mWifiMonitor.broadcastWpsFailEvent(
141                WLAN_IFACE_NAME, WpsConfigError.MSG_TIMEOUT,
142                WpsErrorIndication.NO_ERROR);
143        mLooper.dispatchAll();
144
145        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
146        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
147        assertEquals(WifiMonitor.WPS_FAIL_EVENT, messageCaptor.getValue().what);
148        assertEquals(WifiManager.ERROR, messageCaptor.getValue().arg1);
149        assertEquals(WpsConfigError.MSG_TIMEOUT, messageCaptor.getValue().arg2);
150    }
151
152    /**
153     * Broadcast WPS success event test.
154     */
155    @Test
156    public void testBroadcastWpsEventSuccess() {
157        mWifiMonitor.registerHandler(
158                WLAN_IFACE_NAME, WifiMonitor.WPS_SUCCESS_EVENT, mHandlerSpy);
159        mWifiMonitor.broadcastWpsSuccessEvent(WLAN_IFACE_NAME);
160        mLooper.dispatchAll();
161
162        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
163        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
164        assertEquals(WifiMonitor.WPS_SUCCESS_EVENT, messageCaptor.getValue().what);
165    }
166
167    /**
168     * Broadcast WPS overlap event test.
169     */
170    @Test
171    public void testBroadcastWpsEventOverlap() {
172        mWifiMonitor.registerHandler(
173                WLAN_IFACE_NAME, WifiMonitor.WPS_OVERLAP_EVENT, mHandlerSpy);
174        mWifiMonitor.broadcastWpsOverlapEvent(WLAN_IFACE_NAME);
175        mLooper.dispatchAll();
176
177        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
178        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
179        assertEquals(WifiMonitor.WPS_OVERLAP_EVENT, messageCaptor.getValue().what);
180    }
181
182    /**
183     * Broadcast WPS timeout event test.
184     */
185    @Test
186    public void testBroadcastWpsEventTimeout() {
187        mWifiMonitor.registerHandler(
188                WLAN_IFACE_NAME, WifiMonitor.WPS_TIMEOUT_EVENT, mHandlerSpy);
189        mWifiMonitor.broadcastWpsTimeoutEvent(WLAN_IFACE_NAME);
190        mLooper.dispatchAll();
191
192        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
193        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
194        assertEquals(WifiMonitor.WPS_TIMEOUT_EVENT, messageCaptor.getValue().what);
195    }
196
197    /**
198     * Broadcast ANQP done event test.
199     */
200    @Test
201    public void testBroadcastAnqpDoneEvent() {
202        mWifiMonitor.registerHandler(
203                WLAN_IFACE_NAME, WifiMonitor.ANQP_DONE_EVENT, mHandlerSpy);
204        long bssid = 5;
205        mWifiMonitor.broadcastAnqpDoneEvent(WLAN_IFACE_NAME, new AnqpEvent(bssid, null));
206        mLooper.dispatchAll();
207
208        ArgumentCaptor<Message> messageCaptor = ArgumentCaptor.forClass(Message.class);
209        verify(mHandlerSpy).handleMessage(messageCaptor.capture());
210        assertEquals(WifiMonitor.ANQP_DONE_EVENT, messageCaptor.getValue().what);
211        assertEquals(bssid, ((AnqpEvent) messageCaptor.getValue().obj).getBssid());
212        assertNull(((AnqpEvent) messageCaptor.getValue().obj).getElements());
213    }
214}
215