1 /*
2  * Copyright (C) 2019 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 android.net.wifi;
18 
19 import static com.google.common.truth.Truth.assertThat;
20 
21 import static org.junit.Assert.assertNull;
22 import static org.junit.Assert.assertTrue;
23 import static org.junit.Assume.assumeTrue;
24 
25 import android.net.MacAddress;
26 import android.os.Parcel;
27 import android.util.SparseIntArray;
28 
29 import androidx.test.filters.SmallTest;
30 
31 import com.android.modules.utils.build.SdkLevel;
32 
33 import org.junit.Test;
34 
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.List;
38 import java.util.Random;
39 
40 @SmallTest
41 public class SoftApConfigurationTest {
42     private static final String TEST_CHAR_SET_AS_STRING = "abcdefghijklmnopqrstuvwxyz0123456789";
43     private static final String TEST_BSSID = "aa:22:33:aa:bb:cc";
44 
parcelUnparcel(SoftApConfiguration configIn)45     private SoftApConfiguration parcelUnparcel(SoftApConfiguration configIn) {
46         Parcel parcel = Parcel.obtain();
47         parcel.writeParcelable(configIn, 0);
48         parcel.setDataPosition(0);
49         SoftApConfiguration configOut =
50                 parcel.readParcelable(SoftApConfiguration.class.getClassLoader());
51         parcel.recycle();
52         return configOut;
53     }
54 
55     /**
56      * Helper method to generate random string.
57      *
58      * Note: this method has limited use as a random string generator.
59      * The characters used in this method do no not cover all valid inputs.
60      * @param length number of characters to generate for the string
61      * @return String generated string of random characters
62      */
generateRandomString(int length)63     private String generateRandomString(int length) {
64         Random random = new Random();
65         StringBuilder stringBuilder = new StringBuilder(length);
66         int index = -1;
67         while (stringBuilder.length() < length) {
68             index = random.nextInt(TEST_CHAR_SET_AS_STRING.length());
69             stringBuilder.append(TEST_CHAR_SET_AS_STRING.charAt(index));
70         }
71         return stringBuilder.toString();
72     }
73 
74     @Test
testBasicSettings()75     public void testBasicSettings() {
76         MacAddress testBssid = MacAddress.fromString(TEST_BSSID);
77         SoftApConfiguration original = new SoftApConfiguration.Builder()
78                 .setSsid("ssid")
79                 .setBssid(testBssid)
80                 .build();
81         assertThat(original.getSsid()).isEqualTo("ssid");
82         assertThat(original.getBssid()).isEqualTo(testBssid);
83         assertThat(original.getPassphrase()).isNull();
84         assertThat(original.getSecurityType()).isEqualTo(SoftApConfiguration.SECURITY_TYPE_OPEN);
85         assertThat(original.getBand()).isEqualTo(SoftApConfiguration.BAND_2GHZ);
86         assertThat(original.getChannel()).isEqualTo(0);
87         assertThat(original.isHiddenSsid()).isEqualTo(false);
88         assertThat(original.getMaxNumberOfClients()).isEqualTo(0);
89         if (SdkLevel.isAtLeastS()) {
90             assertThat(original.getMacRandomizationSetting())
91                     .isEqualTo(SoftApConfiguration.RANDOMIZATION_PERSISTENT);
92             assertThat(original.isBridgedModeOpportunisticShutdownEnabled())
93                     .isEqualTo(true);
94             assertThat(original.isIeee80211axEnabled())
95                     .isEqualTo(true);
96             assertThat(original.isUserConfiguration())
97                     .isEqualTo(true);
98         }
99 
100         SoftApConfiguration unparceled = parcelUnparcel(original);
101         assertThat(unparceled).isNotSameInstanceAs(original);
102         assertThat(unparceled).isEqualTo(original);
103         assertThat(unparceled.hashCode()).isEqualTo(original.hashCode());
104 
105         SoftApConfiguration copy = new SoftApConfiguration.Builder(original).build();
106         assertThat(copy).isNotSameInstanceAs(original);
107         assertThat(copy).isEqualTo(original);
108         assertThat(copy.hashCode()).isEqualTo(original.hashCode());
109     }
110 
111     @Test
testWpa2()112     public void testWpa2() {
113         SoftApConfiguration original = new SoftApConfiguration.Builder()
114                 .setPassphrase("secretsecret", SoftApConfiguration.SECURITY_TYPE_WPA2_PSK)
115                 .build();
116         assertThat(original.getPassphrase()).isEqualTo("secretsecret");
117         assertThat(original.getSecurityType()).isEqualTo(
118                 SoftApConfiguration.SECURITY_TYPE_WPA2_PSK);
119         assertThat(original.getBand()).isEqualTo(SoftApConfiguration.BAND_2GHZ);
120         assertThat(original.getChannel()).isEqualTo(0);
121         assertThat(original.isHiddenSsid()).isEqualTo(false);
122         assertThat(original.getMaxNumberOfClients()).isEqualTo(0);
123 
124         SoftApConfiguration unparceled = parcelUnparcel(original);
125         assertThat(unparceled).isNotSameInstanceAs(original);
126         assertThat(unparceled).isEqualTo(original);
127         assertThat(unparceled.hashCode()).isEqualTo(original.hashCode());
128 
129         SoftApConfiguration copy = new SoftApConfiguration.Builder(original).build();
130         assertThat(copy).isNotSameInstanceAs(original);
131         assertThat(copy).isEqualTo(original);
132         assertThat(copy.hashCode()).isEqualTo(original.hashCode());
133     }
134 
135     @Test
testWpa2WithAllFieldCustomized()136     public void testWpa2WithAllFieldCustomized() {
137         List<MacAddress> testBlockedClientList = new ArrayList<>();
138         List<MacAddress> testAllowedClientList = new ArrayList<>();
139         testBlockedClientList.add(MacAddress.fromString("11:22:33:44:55:66"));
140         testAllowedClientList.add(MacAddress.fromString("aa:bb:cc:dd:ee:ff"));
141         SoftApConfiguration.Builder originalBuilder = new SoftApConfiguration.Builder()
142                 .setPassphrase("secretsecret", SoftApConfiguration.SECURITY_TYPE_WPA2_PSK)
143                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
144                 .setHiddenSsid(true)
145                 .setMaxNumberOfClients(10)
146                 .setAutoShutdownEnabled(true)
147                 .setShutdownTimeoutMillis(500000)
148                 .setClientControlByUserEnabled(true)
149                 .setBlockedClientList(testBlockedClientList)
150                 .setAllowedClientList(testAllowedClientList);
151         if (SdkLevel.isAtLeastS()) {
152             originalBuilder.setMacRandomizationSetting(SoftApConfiguration.RANDOMIZATION_NONE);
153             originalBuilder.setBridgedModeOpportunisticShutdownEnabled(false);
154             originalBuilder.setIeee80211axEnabled(false);
155             originalBuilder.setUserConfiguration(false);
156         }
157 
158         SoftApConfiguration original = originalBuilder.build();
159         assertThat(original.getPassphrase()).isEqualTo("secretsecret");
160         assertThat(original.getSecurityType()).isEqualTo(
161                 SoftApConfiguration.SECURITY_TYPE_WPA2_PSK);
162         assertThat(original.getBand()).isEqualTo(SoftApConfiguration.BAND_5GHZ);
163         assertThat(original.getChannel()).isEqualTo(149);
164         assertThat(original.isHiddenSsid()).isEqualTo(true);
165         assertThat(original.getMaxNumberOfClients()).isEqualTo(10);
166         assertThat(original.isAutoShutdownEnabled()).isEqualTo(true);
167         assertThat(original.getShutdownTimeoutMillis()).isEqualTo(500000);
168         assertThat(original.isClientControlByUserEnabled()).isEqualTo(true);
169         assertThat(original.getBlockedClientList()).isEqualTo(testBlockedClientList);
170         assertThat(original.getAllowedClientList()).isEqualTo(testAllowedClientList);
171         if (SdkLevel.isAtLeastS()) {
172             assertThat(original.getMacRandomizationSetting())
173                     .isEqualTo(SoftApConfiguration.RANDOMIZATION_NONE);
174             assertThat(original.isBridgedModeOpportunisticShutdownEnabled())
175                     .isEqualTo(false);
176             assertThat(original.isIeee80211axEnabled())
177                     .isEqualTo(false);
178             assertThat(original.isUserConfiguration())
179                     .isEqualTo(false);
180         }
181 
182         SoftApConfiguration unparceled = parcelUnparcel(original);
183         assertThat(unparceled).isNotSameInstanceAs(original);
184         assertThat(unparceled).isEqualTo(original);
185         assertThat(unparceled.hashCode()).isEqualTo(original.hashCode());
186 
187         SoftApConfiguration copy = new SoftApConfiguration.Builder(original).build();
188         assertThat(copy).isNotSameInstanceAs(original);
189         assertThat(copy).isEqualTo(original);
190         assertThat(copy.hashCode()).isEqualTo(original.hashCode());
191     }
192 
193     @Test
testWpa3Sae()194     public void testWpa3Sae() {
195         SoftApConfiguration original = new SoftApConfiguration.Builder()
196                 .setPassphrase("secretsecret", SoftApConfiguration.SECURITY_TYPE_WPA3_SAE)
197                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
198                 .setHiddenSsid(true)
199                 .build();
200         assertThat(original.getPassphrase()).isEqualTo("secretsecret");
201         assertThat(original.getSecurityType()).isEqualTo(
202                 SoftApConfiguration.SECURITY_TYPE_WPA3_SAE);
203         assertThat(original.getBand()).isEqualTo(SoftApConfiguration.BAND_5GHZ);
204         assertThat(original.getChannel()).isEqualTo(149);
205         assertThat(original.isHiddenSsid()).isEqualTo(true);
206 
207 
208         SoftApConfiguration unparceled = parcelUnparcel(original);
209         assertThat(unparceled).isNotSameInstanceAs(original);
210         assertThat(unparceled).isEqualTo(original);
211         assertThat(unparceled.hashCode()).isEqualTo(original.hashCode());
212 
213         SoftApConfiguration copy = new SoftApConfiguration.Builder(original).build();
214         assertThat(copy).isNotSameInstanceAs(original);
215         assertThat(copy).isEqualTo(original);
216         assertThat(copy.hashCode()).isEqualTo(original.hashCode());
217     }
218 
219     @Test
testWpa3SaeTransition()220     public void testWpa3SaeTransition() {
221         SoftApConfiguration original = new SoftApConfiguration.Builder()
222                 .setPassphrase("secretsecret",
223                         SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION)
224                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
225                 .setHiddenSsid(true)
226                 .build();
227         assertThat(original.getSecurityType()).isEqualTo(
228                 SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION);
229         assertThat(original.getPassphrase()).isEqualTo("secretsecret");
230         assertThat(original.getBand()).isEqualTo(SoftApConfiguration.BAND_5GHZ);
231         assertThat(original.getChannel()).isEqualTo(149);
232         assertThat(original.isHiddenSsid()).isEqualTo(true);
233 
234 
235         SoftApConfiguration unparceled = parcelUnparcel(original);
236         assertThat(unparceled).isNotSameInstanceAs(original);
237         assertThat(unparceled).isEqualTo(original);
238         assertThat(unparceled.hashCode()).isEqualTo(original.hashCode());
239 
240         SoftApConfiguration copy = new SoftApConfiguration.Builder(original).build();
241         assertThat(copy).isNotSameInstanceAs(original);
242         assertThat(copy).isEqualTo(original);
243         assertThat(copy.hashCode()).isEqualTo(original.hashCode());
244     }
245 
246     @Test(expected = IllegalArgumentException.class)
testInvalidBroadcastBssid()247     public void testInvalidBroadcastBssid() {
248         SoftApConfiguration original = new SoftApConfiguration.Builder()
249                 .setBssid(MacAddress.BROADCAST_ADDRESS)
250                 .build();
251     }
252 
253     @Test(expected = IllegalArgumentException.class)
testInvalidMulticastBssid()254     public void testInvalidMulticastBssid() {
255         SoftApConfiguration original = new SoftApConfiguration.Builder()
256                 .setBssid(MacAddress.fromString("01:aa:bb:cc:dd:ee"))
257                 .build();
258     }
259 
260     @Test(expected = IllegalArgumentException.class)
testInvalidShortPasswordLengthForWpa2()261     public void testInvalidShortPasswordLengthForWpa2() {
262         SoftApConfiguration original = new SoftApConfiguration.Builder()
263                 .setPassphrase(generateRandomString(SoftApConfiguration.PSK_MIN_LEN - 1),
264                         SoftApConfiguration.SECURITY_TYPE_WPA2_PSK)
265                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
266                 .setHiddenSsid(true)
267                 .build();
268     }
269 
270     @Test(expected = IllegalArgumentException.class)
testInvalidLongPasswordLengthForWpa2()271     public void testInvalidLongPasswordLengthForWpa2() {
272         SoftApConfiguration original = new SoftApConfiguration.Builder()
273                 .setPassphrase(generateRandomString(SoftApConfiguration.PSK_MAX_LEN + 1),
274                         SoftApConfiguration.SECURITY_TYPE_WPA2_PSK)
275                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
276                 .setHiddenSsid(true)
277                 .build();
278     }
279 
280     @Test(expected = IllegalArgumentException.class)
testInvalidShortPasswordLengthForWpa3SaeTransition()281     public void testInvalidShortPasswordLengthForWpa3SaeTransition() {
282         SoftApConfiguration original = new SoftApConfiguration.Builder()
283                 .setPassphrase(generateRandomString(SoftApConfiguration.PSK_MIN_LEN - 1),
284                         SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION)
285                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
286                 .setHiddenSsid(true)
287                 .build();
288     }
289 
290     @Test(expected = IllegalArgumentException.class)
testInvalidLongPasswordLengthForWpa3SaeTransition()291     public void testInvalidLongPasswordLengthForWpa3SaeTransition() {
292         SoftApConfiguration original = new SoftApConfiguration.Builder()
293                 .setPassphrase(generateRandomString(SoftApConfiguration.PSK_MAX_LEN + 1),
294                         SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION)
295                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
296                 .setHiddenSsid(true)
297                 .build();
298     }
299 
300     @Test(expected = IllegalArgumentException.class)
testInvalieShutdownTimeoutMillis()301     public void testInvalieShutdownTimeoutMillis() {
302         SoftApConfiguration original = new SoftApConfiguration.Builder()
303                 .setShutdownTimeoutMillis(-1)
304                 .build();
305     }
306 
307     @Test(expected = IllegalArgumentException.class)
testSetClientListExceptionWhenExistMacAddressInBothList()308     public void testSetClientListExceptionWhenExistMacAddressInBothList() {
309         final MacAddress testMacAddress_1 = MacAddress.fromString("22:33:44:55:66:77");
310         final MacAddress testMacAddress_2 = MacAddress.fromString("aa:bb:cc:dd:ee:ff");
311         ArrayList<MacAddress> testAllowedClientList = new ArrayList<>();
312         testAllowedClientList.add(testMacAddress_1);
313         testAllowedClientList.add(testMacAddress_2);
314         ArrayList<MacAddress> testBlockedClientList = new ArrayList<>();
315         testBlockedClientList.add(testMacAddress_1);
316         SoftApConfiguration.Builder configBuilder = new SoftApConfiguration.Builder();
317         configBuilder.setBlockedClientList(testBlockedClientList)
318                 .setAllowedClientList(testAllowedClientList)
319                 .build();
320     }
321 
322     @Test
testToWifiConfigurationWithUnsupportedParameter()323     public void testToWifiConfigurationWithUnsupportedParameter() {
324         SoftApConfiguration sae_config = new SoftApConfiguration.Builder()
325                 .setPassphrase("secretsecret", SoftApConfiguration.SECURITY_TYPE_WPA3_SAE)
326                 .build();
327 
328         assertNull(sae_config.toWifiConfiguration());
329         SoftApConfiguration band_6g_config = new SoftApConfiguration.Builder()
330                 .setBand(SoftApConfiguration.BAND_6GHZ)
331                 .build();
332 
333         assertNull(band_6g_config.toWifiConfiguration());
334     }
335 
336     @Test
testToWifiConfigurationWithSupportedParameter()337     public void testToWifiConfigurationWithSupportedParameter() {
338         SoftApConfiguration softApConfig_2g = new SoftApConfiguration.Builder()
339                 .setPassphrase("secretsecret",
340                         SoftApConfiguration.SECURITY_TYPE_WPA2_PSK)
341                 .setChannel(11, SoftApConfiguration.BAND_2GHZ)
342                 .setHiddenSsid(true)
343                 .build();
344         WifiConfiguration wifiConfig_2g = softApConfig_2g.toWifiConfiguration();
345         assertThat(wifiConfig_2g.getAuthType()).isEqualTo(WifiConfiguration.KeyMgmt.WPA2_PSK);
346         assertThat(wifiConfig_2g.preSharedKey).isEqualTo("secretsecret");
347         assertThat(wifiConfig_2g.apBand).isEqualTo(WifiConfiguration.AP_BAND_2GHZ);
348         assertThat(wifiConfig_2g.apChannel).isEqualTo(11);
349         assertThat(wifiConfig_2g.hiddenSSID).isEqualTo(true);
350 
351         SoftApConfiguration softApConfig_5g = new SoftApConfiguration.Builder()
352                 .setPassphrase("secretsecret",
353                         SoftApConfiguration.SECURITY_TYPE_WPA2_PSK)
354                 .setChannel(149, SoftApConfiguration.BAND_5GHZ)
355                 .setHiddenSsid(true)
356                 .build();
357         WifiConfiguration wifiConfig_5g = softApConfig_5g.toWifiConfiguration();
358         assertThat(wifiConfig_5g.getAuthType()).isEqualTo(WifiConfiguration.KeyMgmt.WPA2_PSK);
359         assertThat(wifiConfig_5g.preSharedKey).isEqualTo("secretsecret");
360         assertThat(wifiConfig_5g.apBand).isEqualTo(WifiConfiguration.AP_BAND_5GHZ);
361         assertThat(wifiConfig_5g.apChannel).isEqualTo(149);
362         assertThat(wifiConfig_5g.hiddenSSID).isEqualTo(true);
363 
364         SoftApConfiguration softApConfig_2g5g = new SoftApConfiguration.Builder()
365                 .setPassphrase("secretsecret",
366                         SoftApConfiguration.SECURITY_TYPE_WPA2_PSK)
367                 .setBand(SoftApConfiguration.BAND_2GHZ | SoftApConfiguration.BAND_5GHZ)
368                 .setHiddenSsid(true)
369                 .build();
370         WifiConfiguration wifiConfig_2g5g = softApConfig_2g5g.toWifiConfiguration();
371         assertThat(wifiConfig_2g5g.getAuthType()).isEqualTo(WifiConfiguration.KeyMgmt.WPA2_PSK);
372         assertThat(wifiConfig_2g5g.preSharedKey).isEqualTo("secretsecret");
373         assertThat(wifiConfig_2g5g.apBand).isEqualTo(WifiConfiguration.AP_BAND_ANY);
374         assertThat(wifiConfig_2g5g.apChannel).isEqualTo(0);
375         assertThat(wifiConfig_2g5g.hiddenSSID).isEqualTo(true);
376 
377         SoftApConfiguration softApConfig_sae_transition = new SoftApConfiguration.Builder()
378                 .setPassphrase("secretsecret",
379                 SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION)
380                 .build();
381 
382         WifiConfiguration wifiConfig_sae_transition =
383                 softApConfig_sae_transition.toWifiConfiguration();
384         assertThat(wifiConfig_sae_transition.getAuthType())
385                 .isEqualTo(WifiConfiguration.KeyMgmt.WPA2_PSK);
386         assertThat(wifiConfig_sae_transition.preSharedKey).isEqualTo("secretsecret");
387     }
388 
389     @Test
testDualBands()390     public void testDualBands() {
391         assumeTrue(SdkLevel.isAtLeastS());
392         int[] dual_bands = new int[2];
393         dual_bands[0] = SoftApConfiguration.BAND_2GHZ;
394         dual_bands[1] = SoftApConfiguration.BAND_5GHZ;
395         SoftApConfiguration dual_bands_config = new SoftApConfiguration.Builder()
396                 .setSsid("ssid")
397                 .setBands(dual_bands)
398                 .build();
399         assertTrue(Arrays.equals(dual_bands, dual_bands_config.getBands()));
400         assertThat(dual_bands_config.getBand()).isEqualTo(SoftApConfiguration.BAND_2GHZ);
401     }
402 
403     @Test
testDualChannels()404     public void testDualChannels() {
405         assumeTrue(SdkLevel.isAtLeastS());
406         int[] expected_dual_bands = new int[2];
407         expected_dual_bands[0] = SoftApConfiguration.BAND_2GHZ;
408         expected_dual_bands[1] = SoftApConfiguration.BAND_5GHZ;
409         SparseIntArray dual_channels = new SparseIntArray(2);
410         dual_channels.put(SoftApConfiguration.BAND_5GHZ, 149);
411         dual_channels.put(SoftApConfiguration.BAND_2GHZ, 2);
412         SoftApConfiguration dual_channels_config = new SoftApConfiguration.Builder()
413                 .setSsid("ssid")
414                 .setChannels(dual_channels)
415                 .build();
416         assertTrue(Arrays.equals(expected_dual_bands, dual_channels_config.getBands()));
417         assertThat(dual_channels_config.getBand()).isEqualTo(SoftApConfiguration.BAND_2GHZ);
418         assertTrue(dual_channels.toString().equals(dual_channels_config.getChannels().toString()));
419         assertThat(dual_channels_config.getChannel()).isEqualTo(2);
420 
421         // Test different parameters.
422         dual_channels.clear();
423         dual_channels.put(SoftApConfiguration.BAND_5GHZ, 149);
424         dual_channels.put(SoftApConfiguration.BAND_2GHZ | SoftApConfiguration.BAND_5GHZ, 0);
425         expected_dual_bands[0] = SoftApConfiguration.BAND_5GHZ;
426         expected_dual_bands[1] = SoftApConfiguration.BAND_2GHZ | SoftApConfiguration.BAND_5GHZ;
427         dual_channels_config = new SoftApConfiguration.Builder()
428                 .setSsid("ssid")
429                 .setChannels(dual_channels)
430                 .build();
431         assertTrue(Arrays.equals(expected_dual_bands, dual_channels_config.getBands()));
432         assertThat(dual_channels_config.getBand()).isEqualTo(SoftApConfiguration.BAND_5GHZ);
433         assertTrue(dual_channels.toString().equals(dual_channels_config.getChannels().toString()));
434         assertThat(dual_channels_config.getChannel()).isEqualTo(149);
435     }
436 
437     @Test
testInvalidBandWhenSetBands()438     public void testInvalidBandWhenSetBands() {
439         assumeTrue(SdkLevel.isAtLeastS());
440         boolean isIllegalArgumentExceptionHappened = false;
441         int[] dual_bands = new int[2];
442         dual_bands[0] = SoftApConfiguration.BAND_2GHZ;
443         dual_bands[1] = -1;
444         try {
445             SoftApConfiguration dual_channels_config = new SoftApConfiguration.Builder()
446                     .setSsid("ssid")
447                     .setBands(dual_bands)
448                     .build();
449             isIllegalArgumentExceptionHappened = false;
450         } catch (IllegalArgumentException iae) {
451             isIllegalArgumentExceptionHappened = true;
452         }
453         assertTrue(isIllegalArgumentExceptionHappened);
454 
455         try {
456             SoftApConfiguration dual_channels_config = new SoftApConfiguration.Builder()
457                     .setSsid("ssid")
458                     .setBands(new int[0])
459                     .build();
460             isIllegalArgumentExceptionHappened = false;
461         } catch (IllegalArgumentException iae) {
462             isIllegalArgumentExceptionHappened = true;
463         }
464         assertTrue(isIllegalArgumentExceptionHappened);
465 
466         try {
467             SoftApConfiguration dual_channels_config = new SoftApConfiguration.Builder()
468                     .setSsid("ssid")
469                     .setBands(new int[3])
470                     .build();
471             isIllegalArgumentExceptionHappened = false;
472         } catch (IllegalArgumentException iae) {
473             isIllegalArgumentExceptionHappened = true;
474         }
475         assertTrue(isIllegalArgumentExceptionHappened);
476     }
477 
478     @Test
testInvalidConfigWhenSetChannels()479     public void testInvalidConfigWhenSetChannels() {
480         assumeTrue(SdkLevel.isAtLeastS());
481         boolean isIllegalArgumentExceptionHappened = false;
482         SparseIntArray invalid_channels = new SparseIntArray();
483         try {
484             SoftApConfiguration zero_channels_config = new SoftApConfiguration.Builder()
485                     .setSsid("ssid")
486                     .setChannels(invalid_channels)
487                     .build();
488             isIllegalArgumentExceptionHappened = false;
489         } catch (IllegalArgumentException iae) {
490             isIllegalArgumentExceptionHappened = true;
491         }
492         assertTrue(isIllegalArgumentExceptionHappened);
493 
494         try {
495             invalid_channels.clear();
496             invalid_channels.put(SoftApConfiguration.BAND_2GHZ, 2);
497             invalid_channels.put(SoftApConfiguration.BAND_5GHZ, 11);
498             SoftApConfiguration invalid_band_channels_config = new SoftApConfiguration.Builder()
499                     .setSsid("ssid")
500                     .setChannels(invalid_channels)
501                     .build();
502             isIllegalArgumentExceptionHappened = false;
503         } catch (IllegalArgumentException iae) {
504             isIllegalArgumentExceptionHappened = true;
505         }
506         assertTrue(isIllegalArgumentExceptionHappened);
507 
508         try {
509             invalid_channels.clear();
510             invalid_channels.put(SoftApConfiguration.BAND_2GHZ, 2);
511             invalid_channels.put(SoftApConfiguration.BAND_2GHZ | SoftApConfiguration.BAND_5GHZ,
512                     149);
513             SoftApConfiguration invalid_dual_channels_config = new SoftApConfiguration.Builder()
514                     .setSsid("ssid")
515                     .setChannels(invalid_channels)
516                     .build();
517             isIllegalArgumentExceptionHappened = false;
518         } catch (IllegalArgumentException iae) {
519             isIllegalArgumentExceptionHappened = true;
520         }
521         assertTrue(isIllegalArgumentExceptionHappened);
522 
523         try {
524             invalid_channels.clear();
525             invalid_channels.put(SoftApConfiguration.BAND_2GHZ, 2);
526             invalid_channels.put(SoftApConfiguration.BAND_5GHZ, 149);
527             invalid_channels.put(SoftApConfiguration.BAND_6GHZ, 2);
528             SoftApConfiguration three_channels_config = new SoftApConfiguration.Builder()
529                     .setSsid("ssid")
530                     .setChannels(invalid_channels)
531                     .build();
532             isIllegalArgumentExceptionHappened = false;
533         } catch (IllegalArgumentException iae) {
534             isIllegalArgumentExceptionHappened = true;
535         }
536         assertTrue(isIllegalArgumentExceptionHappened);
537     }
538 
539     @Test(expected = IllegalArgumentException.class)
testInvalidConfigWhenSet60GhzChannels()540     public void testInvalidConfigWhenSet60GhzChannels() throws Exception {
541         assumeTrue(SdkLevel.isAtLeastS());
542         SparseIntArray invalid_channels = new SparseIntArray();
543         invalid_channels.put(SoftApConfiguration.BAND_60GHZ, 99);
544         SoftApConfiguration config = new SoftApConfiguration.Builder()
545                 .setSsid("ssid")
546                 .setChannels(invalid_channels)
547                 .build();
548     }
549 }
550