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 android.net.wifi.WifiManager.WIFI_FEATURE_CONTROL_ROAMING;
20
21import static org.junit.Assert.*;
22import static org.mockito.Mockito.*;
23
24import android.app.test.MockAnswerUtil.AnswerWithArguments;
25import android.support.test.filters.SmallTest;
26
27import org.junit.After;
28import org.junit.Before;
29import org.junit.Test;
30import org.mockito.ArgumentCaptor;
31import org.mockito.Captor;
32import org.mockito.Mock;
33import org.mockito.MockitoAnnotations;
34
35import java.util.ArrayList;
36
37/**
38 * Unit tests for {@link com.android.server.wifi.WifiConnectivityHelper}.
39 */
40@SmallTest
41public class WifiConnectivityHelperTest {
42    /** Sets up test. */
43    @Before
44    public void setUp() throws Exception {
45        MockitoAnnotations.initMocks(this);
46        setupWifiNative();
47
48        mWifiConnectivityHelper = new WifiConnectivityHelper(mWifiNative);
49    }
50
51    /** Cleans up test. */
52    @After
53    public void cleanup() {
54        validateMockitoUsage();
55    }
56
57    private WifiConnectivityHelper mWifiConnectivityHelper;
58    @Mock private WifiNative mWifiNative;
59    @Captor ArgumentCaptor<WifiNative.RoamingConfig> mRoamingConfigCaptor;
60    private int mFeatureSetValue;
61    private static final String TAG = "WifiConnectivityHelperTest";
62    private static final int MAX_BSSID_BLACKLIST_SIZE = 16;
63    private static final int MAX_SSID_WHITELIST_SIZE = 8;
64
65    private void setupWifiNative() {
66        // Return firmware roaming feature as supported by default.
67        when(mWifiNative.getSupportedFeatureSet(any())).thenReturn(WIFI_FEATURE_CONTROL_ROAMING);
68
69        doAnswer(new AnswerWithArguments() {
70            public boolean answer(String ifaceName, WifiNative.RoamingCapabilities roamCap)
71                    throws Exception {
72                roamCap.maxBlacklistSize = MAX_BSSID_BLACKLIST_SIZE;
73                roamCap.maxWhitelistSize = MAX_SSID_WHITELIST_SIZE;
74                return true;
75            }}).when(mWifiNative).getRoamingCapabilities(any(), anyObject());
76
77        when(mWifiNative.configureRoaming(any(), anyObject())).thenReturn(true);
78    }
79
80    private ArrayList<String> buildBssidBlacklist(int size) {
81        ArrayList<String> bssidBlacklist = new ArrayList<String>();
82
83        for (int i = 0; i < size; i++) {
84            StringBuilder bssid = new StringBuilder("11:22:33:44:55:66");
85            bssid.setCharAt(16, (char) ('0' + i));
86            bssidBlacklist.add(bssid.toString());
87        }
88
89        return bssidBlacklist;
90    }
91
92    private ArrayList<String> buildSsidWhitelist(int size) {
93        ArrayList<String> ssidWhitelist = new ArrayList<String>();
94
95        for (int i = 0; i < size; i++) {
96            StringBuilder ssid = new StringBuilder("\"Test_Ap_0\"");
97            ssid.setCharAt(9, (char) ('0' + i));
98            ssidWhitelist.add(ssid.toString());
99        }
100
101        return ssidWhitelist;
102    }
103
104    /**
105     * When WifiNative has WIFI_FEATURE_CONTROL_ROAMING set, verify that
106     * WifiConnectivityHelper#isFirmwareRoamingSupported returns true.
107     */
108    @Test
109    public void returnFirmwareRoamingSupported() {
110        //By default WifiNative has WIFI_FEATURE_CONTROL_ROAMING set in its feature set.
111        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
112        assertTrue(mWifiConnectivityHelper.isFirmwareRoamingSupported());
113    }
114
115    /**
116     * When WifiNative doesn't have WIFI_FEATURE_CONTROL_ROAMING set, verify that
117     * WifiConnectivityHelper#isFirmwareRoamingSupported returns false.
118     */
119    @Test
120    public void returnFirmwareRoamingNotSupported() {
121        when(mWifiNative.getSupportedFeatureSet(any())).thenReturn(~WIFI_FEATURE_CONTROL_ROAMING);
122        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
123        assertFalse(mWifiConnectivityHelper.isFirmwareRoamingSupported());
124    }
125
126    /**
127     * Verify that correct firmware roaming capability values are returned if querying
128     * WifiNative for roaming capability succeeded.
129     */
130    @Test
131    public void verifyFirmwareRoamingCapabilityWithSuccessfulNativeCall() {
132        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
133        assertTrue(mWifiConnectivityHelper.isFirmwareRoamingSupported());
134        assertEquals(MAX_BSSID_BLACKLIST_SIZE, mWifiConnectivityHelper.getMaxNumBlacklistBssid());
135        assertEquals(MAX_SSID_WHITELIST_SIZE, mWifiConnectivityHelper.getMaxNumWhitelistSsid());
136    }
137
138    /**
139     * Verify that firmware roaming is set to not supported if WifiNative returned firmware roaming
140     * is supported but failed to return roaming capabilities. Firmware roaming capabilty values
141     * should be reset to INVALID_LIST_SIZE.
142     */
143    @Test
144    public void verifyFirmwareRoamingCapabilityWithFailureNativeCall() {
145        doAnswer(new AnswerWithArguments() {
146            public boolean answer(String ifaceName, WifiNative.RoamingCapabilities roamCap)
147                    throws Exception {
148                return false;
149            }}).when(mWifiNative).getRoamingCapabilities(any(), anyObject());
150        assertFalse(mWifiConnectivityHelper.getFirmwareRoamingInfo());
151        assertFalse(mWifiConnectivityHelper.isFirmwareRoamingSupported());
152        assertEquals(WifiConnectivityHelper.INVALID_LIST_SIZE,
153                mWifiConnectivityHelper.getMaxNumBlacklistBssid());
154        assertEquals(WifiConnectivityHelper.INVALID_LIST_SIZE,
155                mWifiConnectivityHelper.getMaxNumWhitelistSsid());
156    }
157
158    /**
159     * Verify that firmware roaming is set to not supported if WifiNative returned firmware roaming
160     * is supported but returned invalid max BSSID balcklist size. Firmware roaming capabilty values
161     * should be reset to INVALID_LIST_SIZE.
162     */
163    @Test
164    public void verifyFirmwareRoamingCapabilityWithInvalidMaxBssidBlacklistSize() {
165        doAnswer(new AnswerWithArguments() {
166            public boolean answer(String ifaceName, WifiNative.RoamingCapabilities roamCap)
167                    throws Exception {
168                roamCap.maxBlacklistSize = -5;
169                roamCap.maxWhitelistSize = MAX_SSID_WHITELIST_SIZE;
170                return true;
171            }}).when(mWifiNative).getRoamingCapabilities(any(), anyObject());
172        assertFalse(mWifiConnectivityHelper.getFirmwareRoamingInfo());
173        assertFalse(mWifiConnectivityHelper.isFirmwareRoamingSupported());
174        assertEquals(WifiConnectivityHelper.INVALID_LIST_SIZE,
175                mWifiConnectivityHelper.getMaxNumBlacklistBssid());
176        assertEquals(WifiConnectivityHelper.INVALID_LIST_SIZE,
177                mWifiConnectivityHelper.getMaxNumWhitelistSsid());
178    }
179
180    /**
181     * Verify that firmware roaming is set to not supported if WifiNative returned firmware roaming
182     * is supported but returned invalid max SSID whitelist size. Firmware roaming capabilty values
183     * should be reset to INVALID_LIST_SIZE.
184     */
185    @Test
186    public void verifyFirmwareRoamingCapabilityWithInvalidMaxSsidWhitelistSize() {
187        doAnswer(new AnswerWithArguments() {
188            public boolean answer(String ifaceName, WifiNative.RoamingCapabilities roamCap)
189                    throws Exception {
190                roamCap.maxBlacklistSize = MAX_BSSID_BLACKLIST_SIZE;
191                roamCap.maxWhitelistSize = -2;
192                return true;
193            }}).when(mWifiNative).getRoamingCapabilities(any(), anyObject());
194        assertFalse(mWifiConnectivityHelper.getFirmwareRoamingInfo());
195        assertFalse(mWifiConnectivityHelper.isFirmwareRoamingSupported());
196        assertEquals(WifiConnectivityHelper.INVALID_LIST_SIZE,
197                mWifiConnectivityHelper.getMaxNumBlacklistBssid());
198        assertEquals(WifiConnectivityHelper.INVALID_LIST_SIZE,
199                mWifiConnectivityHelper.getMaxNumWhitelistSsid());
200    }
201
202    /**
203     * Verify that correct size BSSID blacklist and SSID whitelist are accepted.
204     */
205    @Test
206    public void verifySetFirmwareRoamingConfigurationWithGoodInput() {
207        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
208        ArrayList<String> blacklist = buildBssidBlacklist(MAX_BSSID_BLACKLIST_SIZE);
209        ArrayList<String> whitelist = buildSsidWhitelist(MAX_SSID_WHITELIST_SIZE);
210        assertTrue(mWifiConnectivityHelper.setFirmwareRoamingConfiguration(blacklist, whitelist));
211
212        blacklist = buildBssidBlacklist(MAX_BSSID_BLACKLIST_SIZE - 2);
213        whitelist = buildSsidWhitelist(MAX_SSID_WHITELIST_SIZE - 3);
214        assertTrue(mWifiConnectivityHelper.setFirmwareRoamingConfiguration(blacklist, whitelist));
215    }
216
217    /**
218     * Verify that null BSSID blacklist or SSID whitelist is rejected.
219     */
220    @Test
221    public void verifySetFirmwareRoamingConfigurationWithNullInput() {
222        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
223        ArrayList<String> blacklist = buildBssidBlacklist(MAX_BSSID_BLACKLIST_SIZE);
224        ArrayList<String> whitelist = buildSsidWhitelist(MAX_SSID_WHITELIST_SIZE);
225        assertFalse(mWifiConnectivityHelper.setFirmwareRoamingConfiguration(null, whitelist));
226        assertFalse(mWifiConnectivityHelper.setFirmwareRoamingConfiguration(blacklist, null));
227    }
228
229    /**
230     * Verify that incorrect size BSSID blacklist is rejected.
231     */
232    @Test
233    public void verifySetFirmwareRoamingConfigurationWithIncorrectBlacklist() {
234        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
235        ArrayList<String> blacklist = buildBssidBlacklist(MAX_BSSID_BLACKLIST_SIZE + 1);
236        ArrayList<String> whitelist = buildSsidWhitelist(MAX_SSID_WHITELIST_SIZE);
237        assertFalse(mWifiConnectivityHelper.setFirmwareRoamingConfiguration(blacklist, whitelist));
238    }
239
240    /**
241     * Verify that incorrect size SSID whitelist is rejected.
242     */
243    @Test
244    public void verifySetFirmwareRoamingConfigurationWithIncorrectWhitelist() {
245        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
246        ArrayList<String> blacklist = buildBssidBlacklist(MAX_BSSID_BLACKLIST_SIZE);
247        ArrayList<String> whitelist = buildSsidWhitelist(MAX_SSID_WHITELIST_SIZE + 1);
248        assertFalse(mWifiConnectivityHelper.setFirmwareRoamingConfiguration(blacklist, whitelist));
249    }
250
251    /**
252     * Verify that empty BSSID blacklist and SSID whitelist are sent to WifiNative
253     * to reset the firmware roaming configuration.
254     */
255    @Test
256    public void verifySetFirmwareRoamingConfigurationWithEmptyBlacklistAndWhitelist() {
257        assertTrue(mWifiConnectivityHelper.getFirmwareRoamingInfo());
258        ArrayList<String> blacklist = buildBssidBlacklist(0);
259        ArrayList<String> whitelist = buildSsidWhitelist(0);
260        assertTrue(mWifiConnectivityHelper.setFirmwareRoamingConfiguration(blacklist, whitelist));
261        verify(mWifiNative).configureRoaming(any(), mRoamingConfigCaptor.capture());
262        assertEquals(0, mRoamingConfigCaptor.getValue().blacklistBssids.size());
263        assertEquals(0, mRoamingConfigCaptor.getValue().whitelistSsids.size());
264    }
265}
266