• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2016 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 com.android.server.wifi;
18 
19 import static org.junit.Assert.*;
20 
21 import android.net.InetAddresses;
22 import android.net.IpConfiguration;
23 import android.net.LinkAddress;
24 import android.net.ProxyInfo;
25 import android.net.StaticIpConfiguration;
26 import android.net.Uri;
27 import android.net.wifi.SecurityParams;
28 import android.net.wifi.WifiConfiguration;
29 import android.net.wifi.WifiConfiguration.NetworkSelectionStatus;
30 import android.net.wifi.WifiEnterpriseConfig;
31 import android.net.wifi.WifiSsid;
32 import android.text.TextUtils;
33 
34 import com.android.modules.utils.build.SdkLevel;
35 
36 import java.net.InetAddress;
37 import java.security.cert.X509Certificate;
38 import java.util.Arrays;
39 import java.util.List;
40 
41 /**
42  * Helper for creating and populating WifiConfigurations in unit tests.
43  */
44 public class WifiConfigurationTestUtil {
45     /**
46      * These values are used to describe AP's security setting. One AP can support multiple of them,
47      * only if there is no conflict.
48      */
49     public static final int SECURITY_NONE = 1 << 0;
50     public static final int SECURITY_WEP =  1 << 1;
51     public static final int SECURITY_PSK =  1 << 2;
52     public static final int SECURITY_EAP =  1 << 3;
53     public static final int SECURITY_SAE =  1 << 4;
54     public static final int SECURITY_OWE =  1 << 5;
55     public static final int SECURITY_EAP_SUITE_B =  1 << 6;
56     public static final int SECURITY_WAPI_PSK =     1 << 7;
57     public static final int SECURITY_WAPI_CERT =    1 << 8;
58     public static final int SECURITY_WPA3_ENTERPRISE = 1 << 9;
59 
60     /**
61      * These values are used to describe ip configuration parameters for a network.
62      */
63     public static final int STATIC_IP_ASSIGNMENT = 0;
64     public static final int DHCP_IP_ASSIGNMENT = 1;
65     public static final int STATIC_PROXY_SETTING = 0;
66     public static final int PAC_PROXY_SETTING = 1;
67     public static final int NONE_PROXY_SETTING = 2;
68 
69     /**
70      * These are constants used to generate predefined WifiConfiguration objects.
71      */
72     public static final int TEST_NETWORK_ID = -1;
73     public static final int TEST_UID = 5;
74     public static final String TEST_SSID = "WifiConfigurationTestSSID";
75     public static final String TEST_PSK = "\"WifiConfigurationTestUtilPsk\"";
76     public static final String[] TEST_WEP_KEYS =
77             {"\"WifiTestWep12\"", "\"WifiTestWep34\"",
78                     "45342312ab", "45342312ab45342312ab34ac12"};
79     public static final String TEST_EAP_PASSWORD = "WifiConfigurationTestUtilEapPassword";
80     public static final int TEST_WEP_TX_KEY_INDEX = 1;
81     public static final String TEST_FQDN = "WifiConfigurationTestUtilFQDN";
82     public static final String TEST_PROVIDER_FRIENDLY_NAME =
83             "WifiConfigurationTestUtilFriendlyName";
84     public static final String TEST_STATIC_IP_LINK_ADDRESS = "192.168.48.2";
85     public static final int TEST_STATIC_IP_LINK_PREFIX_LENGTH = 8;
86     public static final String TEST_STATIC_IP_GATEWAY_ADDRESS = "192.168.48.1";
87     public static final String[] TEST_STATIC_IP_DNS_SERVER_ADDRESSES =
88             new String[]{"192.168.48.1", "192.168.48.10"};
89     public static final String TEST_STATIC_PROXY_HOST = "192.168.48.1";
90     public static final int TEST_STATIC_PROXY_PORT = 8000;
91     public static final String TEST_STATIC_PROXY_EXCLUSION_LIST = "";
92     public static final String TEST_PAC_PROXY_LOCATION = "http://";
93     public static final String TEST_CA_CERT_ALIAS = "WifiConfigurationTestUtilCaCertAlias";
94     public static final String TEST_CA_CERT_SUITE_B_ALIAS = "SuiteBCaCertAlias";
95     public static final String TEST_CA_CERT_PATH = "caPath";
96     public static final String TEST_DOM_SUBJECT_MATCH = "domSubjectMatch";
97     public static final String TEST_IDENTITY = "user@example.com";
98 
99     private static final int MAX_SSID_LENGTH = 32;
100     /**
101      * Index used to assign unique SSIDs for the generation of predefined WifiConfiguration objects.
102      */
103     private static int sNetworkIndex = 0;
104 
105     /**
106      * Construct a {@link android.net.wifi.WifiConfiguration}.
107      * @param networkId the configuration's networkId
108      * @param uid the configuration's creator uid
109      * @param ssid the configuration's ssid
110      * @param shared whether the configuration is shared with other users on the device
111      * @param enabled whether the configuration is enabled
112      * @param fqdn the configuration's FQDN (Hotspot 2.0 only)
113      * @param providerFriendlyName the configuration's provider's friendly name (Hotspot 2.0 only)
114      * @return the constructed {@link android.net.wifi.WifiConfiguration}
115      */
generateWifiConfig(int networkId, int uid, String ssid, boolean shared, boolean enabled, String fqdn, String providerFriendlyName)116     private static WifiConfiguration generateWifiConfig(int networkId, int uid, String ssid,
117             boolean shared, boolean enabled, String fqdn, String providerFriendlyName) {
118         final WifiConfiguration config = new WifiConfiguration();
119         config.SSID = ssid;
120         config.networkId = networkId;
121         config.creatorUid = uid;
122         config.shared = shared;
123         config.status = enabled ? WifiConfiguration.Status.ENABLED
124                 : WifiConfiguration.Status.DISABLED;
125         config.FQDN = fqdn;
126         config.providerFriendlyName = providerFriendlyName;
127         if (config.FQDN != null) {
128             int uniqueId = config.FQDN.hashCode() + config.networkId + config.creatorUid;
129             // Generate a Passpoint unique id locally for the test
130             config.setPasspointUniqueId(config.FQDN + "_" + uniqueId);
131         }
132         return config;
133     }
134 
135     /**
136      * Construct a {@link android.net.wifi.WifiConfiguration}.
137      * @param networkId the configuration's networkId
138      * @param uid the configuration's creator uid
139      * @param ssid the configuration's ssid
140      * @param shared whether the configuration is shared with other users on the device
141      * @param enabled whether the configuration is enabled
142      * @param fqdn the configuration's FQDN (Hotspot 2.0 only)
143      * @param providerFriendlyName the configuration's provider's friendly name (Hotspot 2.0 only)
144      * @param security the configuration's security type
145      * @return the constructed {@link android.net.wifi.WifiConfiguration}
146      */
generateWifiConfig(int networkId, int uid, String ssid, boolean shared, boolean enabled, String fqdn, String providerFriendlyName, int security)147     public static WifiConfiguration generateWifiConfig(int networkId, int uid, String ssid,
148             boolean shared, boolean enabled, String fqdn, String providerFriendlyName,
149             int security) {
150         WifiConfiguration config = generateWifiConfig(networkId, uid, ssid, shared, enabled, fqdn,
151                 providerFriendlyName);
152 
153         if ((security & SECURITY_NONE) != 0) {
154             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
155         }
156         if ((security & SECURITY_WEP) != 0) {
157             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_WEP);
158         }
159         if ((security & SECURITY_PSK) != 0) {
160             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
161         }
162 
163         if ((security & SECURITY_SAE) != 0) {
164             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
165         }
166 
167         if ((security & SECURITY_OWE) != 0) {
168             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OWE);
169         }
170 
171         if ((security & SECURITY_EAP) != 0) {
172             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP);
173             config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TTLS);
174             config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.MSCHAPV2);
175             config.enterpriseConfig.setIdentity(TEST_IDENTITY);
176             config.enterpriseConfig.setPassword(TEST_EAP_PASSWORD);
177             config.enterpriseConfig.setCaPath(TEST_CA_CERT_PATH);
178             config.enterpriseConfig.setDomainSuffixMatch(TEST_DOM_SUBJECT_MATCH);
179         }
180 
181         if ((security & SECURITY_WPA3_ENTERPRISE) != 0) {
182             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
183             config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.PEAP);
184             config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.MSCHAPV2);
185             config.enterpriseConfig.setIdentity(TEST_IDENTITY);
186             config.enterpriseConfig.setPassword(TEST_EAP_PASSWORD);
187             config.enterpriseConfig.setCaPath(TEST_CA_CERT_PATH);
188             config.enterpriseConfig.setDomainSuffixMatch(TEST_DOM_SUBJECT_MATCH);
189         }
190 
191         if ((security & SECURITY_EAP_SUITE_B) != 0) {
192             config.addSecurityParams(
193                     WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT);
194             config.enterpriseConfig.setDomainSuffixMatch(TEST_DOM_SUBJECT_MATCH);
195         }
196 
197         if ((security & SECURITY_WAPI_PSK) != 0) {
198             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_PSK);
199         }
200 
201         if ((security & SECURITY_WAPI_CERT) != 0) {
202             config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_CERT);
203             config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.WAPI_CERT);
204         }
205         return config;
206     }
207 
208     /**
209      * Construct a {@link android.net.IpConfiguration }.
210      * @param ipAssignmentType One of {@link #STATIC_IP_ASSIGNMENT} or {@link #DHCP_IP_ASSIGNMENT}.
211      * @param proxySettingType One of {@link #STATIC_PROXY_SETTING} or {@link #PAC_PROXY_SETTING} or
212      *                        {@link #NONE_PROXY_SETTING}.
213      * @param linkAddress static ip address string.
214      * @param linkPrefixLength static ip address prefix length.
215      * @param gatewayAddress static gateway address.
216      * @param dnsServerAddresses list of dns servers for static ip configuration.
217      * @param proxyHost Static proxy server address.
218      * @param proxyPort Static proxy server port.
219      * @param proxyExclusionList Static proxy exclusion list.
220      * @param pacProxyPath Pac proxy server path.
221      * @return the constructed {@link android.net.IpConfiguration}
222      */
generateIpConfig( int ipAssignmentType, int proxySettingType, String linkAddress, int linkPrefixLength, String gatewayAddress, String[] dnsServerAddresses, String proxyHost, int proxyPort, String proxyExclusionList, String pacProxyPath)223     public static IpConfiguration generateIpConfig(
224             int ipAssignmentType, int proxySettingType, String linkAddress, int linkPrefixLength,
225             String gatewayAddress, String[] dnsServerAddresses, String proxyHost,
226             int proxyPort, String proxyExclusionList, String pacProxyPath) {
227         StaticIpConfiguration staticIpConfiguration = null;
228         ProxyInfo proxyInfo = null;
229         IpConfiguration.IpAssignment ipAssignment = IpConfiguration.IpAssignment.UNASSIGNED;
230         IpConfiguration.ProxySettings proxySettings = IpConfiguration.ProxySettings.UNASSIGNED;
231 
232         if (ipAssignmentType == STATIC_IP_ASSIGNMENT) {
233             staticIpConfiguration = new StaticIpConfiguration();
234             if (!TextUtils.isEmpty(linkAddress)) {
235                 LinkAddress linkAddr =
236                         new LinkAddress(
237                                 InetAddresses.parseNumericAddress(linkAddress), linkPrefixLength);
238                 staticIpConfiguration.ipAddress = linkAddr;
239             }
240 
241             if (!TextUtils.isEmpty(gatewayAddress)) {
242                 InetAddress gatewayAddr =
243                         InetAddresses.parseNumericAddress(gatewayAddress);
244                 staticIpConfiguration.gateway = gatewayAddr;
245             }
246             if (dnsServerAddresses != null) {
247                 for (String dnsServerAddress : dnsServerAddresses) {
248                     if (!TextUtils.isEmpty(dnsServerAddress)) {
249                         staticIpConfiguration.dnsServers.add(
250                                 InetAddresses.parseNumericAddress(dnsServerAddress));
251                     }
252 
253                 }
254             }
255             ipAssignment = IpConfiguration.IpAssignment.STATIC;
256         } else if (ipAssignmentType == DHCP_IP_ASSIGNMENT) {
257             ipAssignment = IpConfiguration.IpAssignment.DHCP;
258         }
259 
260         if (proxySettingType == STATIC_PROXY_SETTING) {
261             proxyInfo = new ProxyInfo(proxyHost, proxyPort, proxyExclusionList);
262             proxySettings = IpConfiguration.ProxySettings.STATIC;
263         } else if (proxySettingType == PAC_PROXY_SETTING) {
264             proxyInfo = ProxyInfo.buildPacProxy(Uri.parse(pacProxyPath));
265             proxySettings = IpConfiguration.ProxySettings.PAC;
266         } else if (proxySettingType == NONE_PROXY_SETTING) {
267             proxySettings = IpConfiguration.ProxySettings.NONE;
268         }
269         return new IpConfiguration(ipAssignment, proxySettings, staticIpConfiguration, proxyInfo);
270     }
271 
272     /**
273      * Create a new SSID for the the network being created.
274      */
createNewSSID()275     private static String createNewSSID() {
276         String ssid = TEST_SSID + sNetworkIndex++;
277         assertTrue(ssid.length() <= MAX_SSID_LENGTH);
278         return "\"" + ssid + "\"";
279     }
280 
281     /**
282      * Helper methods to generate predefined WifiConfiguration objects of the required type. These
283      * use a static index to avoid duplicate configurations.
284      */
createOweNetwork()285     public static WifiConfiguration createOweNetwork() {
286         return createOweNetwork(createNewSSID());
287     }
288 
createOweNetwork(String ssid)289     public static WifiConfiguration createOweNetwork(String ssid) {
290         return generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true, null,
291                 null, SECURITY_OWE);
292     }
293 
createOpenNetwork()294     public static WifiConfiguration createOpenNetwork() {
295         return createOpenNetwork(createNewSSID());
296     }
297 
createOpenNetwork(String ssid)298     public static WifiConfiguration createOpenNetwork(String ssid) {
299         WifiConfiguration config = generateWifiConfig(
300                 TEST_NETWORK_ID, TEST_UID, ssid, true, true, null,
301                 null, SECURITY_NONE);
302         return config;
303     }
304 
createOpenOweNetwork()305     public static WifiConfiguration createOpenOweNetwork() {
306         return createOpenOweNetwork(createNewSSID());
307     }
308 
createOpenOweNetwork(String ssid)309     public static WifiConfiguration createOpenOweNetwork(String ssid) {
310         WifiConfiguration config = generateWifiConfig(
311                 TEST_NETWORK_ID, TEST_UID, ssid, true, true, null,
312                 null, SECURITY_NONE);
313         // the upgradable type is always added.
314         SecurityParams params = SecurityParams
315                 .createSecurityParamsBySecurityType(WifiConfiguration.SECURITY_TYPE_OWE);
316         params.setIsAddedByAutoUpgrade(true);
317         config.addSecurityParams(params);
318         return config;
319     }
320 
createEphemeralNetwork()321     public static WifiConfiguration createEphemeralNetwork() {
322         WifiConfiguration configuration = createOpenNetwork();
323         configuration.ephemeral = true;
324         return configuration;
325     }
326 
createOpenHiddenNetwork()327     public static WifiConfiguration createOpenHiddenNetwork() {
328         WifiConfiguration configuration = createOpenNetwork();
329         configuration.hiddenSSID = true;
330         return configuration;
331     }
332 
createSaeNetwork()333     public static WifiConfiguration createSaeNetwork() {
334         return createSaeNetwork(createNewSSID());
335     }
336 
createPskNetwork()337     public static WifiConfiguration createPskNetwork() {
338         return createPskNetwork(createNewSSID());
339     }
340 
createPskNetwork(String ssid)341     public static WifiConfiguration createPskNetwork(String ssid) {
342         WifiConfiguration configuration =
343                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true, null,
344                         null, SECURITY_PSK);
345         configuration.preSharedKey = TEST_PSK;
346         return configuration;
347     }
348 
createPskSaeNetwork()349     public static WifiConfiguration createPskSaeNetwork() {
350         return createPskSaeNetwork(createNewSSID());
351     }
352 
createPskSaeNetwork(String ssid)353     public static WifiConfiguration createPskSaeNetwork(String ssid) {
354         WifiConfiguration configuration =
355                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true, null,
356                         null, SECURITY_PSK);
357         configuration.preSharedKey = TEST_PSK;
358         // the upgradable type is always added.
359         SecurityParams params = SecurityParams
360                 .createSecurityParamsBySecurityType(WifiConfiguration.SECURITY_TYPE_SAE);
361         params.setIsAddedByAutoUpgrade(true);
362         configuration.addSecurityParams(params);
363         return configuration;
364     }
365 
createSaeNetwork(String ssid)366     public static WifiConfiguration createSaeNetwork(String ssid) {
367         WifiConfiguration configuration =
368                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true, null,
369                         null, SECURITY_SAE);
370 
371         // SAE password uses the same member.
372         configuration.preSharedKey = TEST_PSK;
373         configuration.requirePmf = true;
374         return configuration;
375     }
376 
createPskHiddenNetwork()377     public static WifiConfiguration createPskHiddenNetwork() {
378         WifiConfiguration configuration = createPskNetwork();
379         configuration.hiddenSSID = true;
380         return configuration;
381     }
382 
createWepNetwork()383     public static WifiConfiguration createWepNetwork() {
384         WifiConfiguration configuration =
385                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, null,
386                         null, SECURITY_WEP);
387         configuration.wepKeys = TEST_WEP_KEYS;
388         configuration.wepTxKeyIndex = TEST_WEP_TX_KEY_INDEX;
389         return configuration;
390     }
391 
createWepHiddenNetwork()392     public static WifiConfiguration createWepHiddenNetwork() {
393         WifiConfiguration configuration = createWepNetwork();
394         configuration.hiddenSSID = true;
395         return configuration;
396     }
397 
createWepNetworkWithSingleKey()398     public static WifiConfiguration createWepNetworkWithSingleKey() {
399         WifiConfiguration configuration =
400                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, null,
401                         null, SECURITY_WEP);
402         configuration.wepKeys[0] = TEST_WEP_KEYS[0];
403         configuration.wepTxKeyIndex = 0;
404         return configuration;
405     }
406 
407 
createEapNetwork()408     public static WifiConfiguration createEapNetwork() {
409         return createEapNetwork(createNewSSID());
410     }
411 
createEapNetwork(String ssid)412     public static WifiConfiguration createEapNetwork(String ssid) {
413         return createEapNetwork(ssid,
414                 WifiEnterpriseConfig.Eap.NONE,
415                 WifiEnterpriseConfig.Phase2.NONE);
416     }
417 
418 
createEapNetwork(int eapMethod, int phase2Method)419     public static WifiConfiguration createEapNetwork(int eapMethod, int phase2Method) {
420         return createEapNetwork(createNewSSID(), eapMethod, phase2Method);
421     }
422 
createEapNetwork(String ssid, int eapMethod, int phase2Method)423     public static WifiConfiguration createEapNetwork(String ssid, int eapMethod, int phase2Method) {
424         WifiConfiguration configuration =
425                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true,
426                         null, null, SECURITY_EAP);
427         if (eapMethod != WifiEnterpriseConfig.Eap.NONE) {
428             configuration.enterpriseConfig.setEapMethod(eapMethod);
429             configuration.enterpriseConfig.setPhase2Method(phase2Method);
430         }
431         return configuration;
432     }
433 
createWpa2Wpa3EnterpriseNetwork()434     public static WifiConfiguration createWpa2Wpa3EnterpriseNetwork() {
435         return createWpa2Wpa3EnterpriseNetwork(createNewSSID());
436     }
437 
createWpa2Wpa3EnterpriseNetwork( int eapMethod, int phase2Method)438     public static WifiConfiguration createWpa2Wpa3EnterpriseNetwork(
439             int eapMethod, int phase2Method) {
440         return createWpa2Wpa3EnterpriseNetwork(createNewSSID(), eapMethod, phase2Method);
441     }
442 
createWpa2Wpa3EnterpriseNetwork(String ssid)443     public static WifiConfiguration createWpa2Wpa3EnterpriseNetwork(String ssid) {
444         return createWpa2Wpa3EnterpriseNetwork(
445                 ssid,
446                 WifiEnterpriseConfig.Eap.NONE,
447                 WifiEnterpriseConfig.Phase2.NONE);
448     }
449 
createWpa2Wpa3EnterpriseNetwork( String ssid, int eapMethod, int phase2Method)450     public static WifiConfiguration createWpa2Wpa3EnterpriseNetwork(
451             String ssid, int eapMethod, int phase2Method) {
452         WifiConfiguration configuration =
453                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true,
454                         null, null, SECURITY_EAP);
455         if (eapMethod != WifiEnterpriseConfig.Eap.NONE) {
456             configuration.enterpriseConfig.setEapMethod(eapMethod);
457             configuration.enterpriseConfig.setPhase2Method(phase2Method);
458         }
459         // the upgradable type is always added.
460         SecurityParams params = SecurityParams
461                 .createSecurityParamsBySecurityType(
462                         WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
463         params.setIsAddedByAutoUpgrade(true);
464         configuration.addSecurityParams(params);
465         return configuration;
466     }
467 
createWpa3EnterpriseNetwork(String ssid)468     public static WifiConfiguration createWpa3EnterpriseNetwork(String ssid) {
469         WifiConfiguration configuration =
470                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true,
471                         null, null, SECURITY_WPA3_ENTERPRISE);
472         return configuration;
473     }
474 
createEapSuiteBNetwork()475     public static WifiConfiguration createEapSuiteBNetwork() {
476         return createEapSuiteBNetwork(WifiConfiguration.SuiteBCipher.ECDHE_RSA);
477     }
478 
createEapSuiteBNetwork(int signatureType)479     public static WifiConfiguration createEapSuiteBNetwork(int signatureType) {
480         WifiConfiguration configuration =
481                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true,
482                         null, null, SECURITY_EAP_SUITE_B);
483 
484         configuration.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TLS);
485         configuration.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
486 
487         if (signatureType == WifiConfiguration.SuiteBCipher.ECDHE_ECDSA) {
488             configuration.enterpriseConfig.setCaCertificate(FakeKeys.CA_SUITE_B_ECDSA_CERT);
489             configuration.enterpriseConfig.setClientKeyEntryWithCertificateChain(
490                     FakeKeys.CLIENT_SUITE_B_ECC_KEY,
491                     new X509Certificate[] {FakeKeys.CLIENT_SUITE_B_ECDSA_CERT});
492         } else {
493             configuration.enterpriseConfig.setCaCertificate(FakeKeys.CA_SUITE_B_RSA3072_CERT);
494             configuration.enterpriseConfig.setClientKeyEntryWithCertificateChain(
495                     FakeKeys.CLIENT_SUITE_B_RSA3072_KEY,
496                     new X509Certificate[] {FakeKeys.CLIENT_SUITE_B_RSA3072_CERT});
497         }
498         return configuration;
499     }
500 
createPasspointNetwork()501     public static WifiConfiguration createPasspointNetwork() {
502         WifiConfiguration configuration =
503                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true,
504                         TEST_FQDN, TEST_PROVIDER_FRIENDLY_NAME, SECURITY_EAP);
505         return configuration;
506     }
507 
createWapiPskNetwork()508     public static WifiConfiguration createWapiPskNetwork() {
509         WifiConfiguration configuration =
510                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, null,
511                         null, SECURITY_WAPI_PSK);
512         configuration.preSharedKey = TEST_PSK;
513         return configuration;
514     }
515 
createWapiCertNetwork()516     public static WifiConfiguration createWapiCertNetwork() {
517         WifiEnterpriseConfig enterpriseConfig = new WifiEnterpriseConfig();
518         enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.WAPI_CERT);
519         enterpriseConfig.setWapiCertSuite("wapiCertSuite");
520         WifiConfiguration configuration =
521                 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, null,
522                         null, SECURITY_WAPI_CERT);
523         configuration.enterpriseConfig = enterpriseConfig;
524         return configuration;
525     }
526 
createStaticIpConfigurationWithPacProxy()527     public static IpConfiguration createStaticIpConfigurationWithPacProxy() {
528         return generateIpConfig(
529                 STATIC_IP_ASSIGNMENT, PAC_PROXY_SETTING,
530                 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH,
531                 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES,
532                 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST,
533                 TEST_PAC_PROXY_LOCATION);
534     }
535 
createStaticIpConfigurationWithStaticProxy()536     public static IpConfiguration createStaticIpConfigurationWithStaticProxy() {
537         return generateIpConfig(
538                 STATIC_IP_ASSIGNMENT, STATIC_PROXY_SETTING,
539                 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH,
540                 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES,
541                 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST,
542                 TEST_PAC_PROXY_LOCATION);
543     }
544 
createPartialStaticIpConfigurationWithPacProxy()545     public static IpConfiguration createPartialStaticIpConfigurationWithPacProxy() {
546         return generateIpConfig(
547                 STATIC_IP_ASSIGNMENT, PAC_PROXY_SETTING,
548                 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH,
549                 null, null,
550                 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST,
551                 TEST_PAC_PROXY_LOCATION);
552     }
553 
createDHCPIpConfigurationWithPacProxy()554     public static IpConfiguration createDHCPIpConfigurationWithPacProxy() {
555         return generateIpConfig(
556                 DHCP_IP_ASSIGNMENT, PAC_PROXY_SETTING,
557                 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH,
558                 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES,
559                 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST,
560                 TEST_PAC_PROXY_LOCATION);
561     }
562 
createDHCPIpConfigurationWithStaticProxy()563     public static IpConfiguration createDHCPIpConfigurationWithStaticProxy() {
564         return generateIpConfig(
565                 DHCP_IP_ASSIGNMENT, STATIC_PROXY_SETTING,
566                 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH,
567                 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES,
568                 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST,
569                 TEST_PAC_PROXY_LOCATION);
570     }
571 
createDHCPIpConfigurationWithNoProxy()572     public static IpConfiguration createDHCPIpConfigurationWithNoProxy() {
573         return generateIpConfig(
574                 DHCP_IP_ASSIGNMENT, NONE_PROXY_SETTING,
575                 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH,
576                 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES,
577                 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST,
578                 TEST_PAC_PROXY_LOCATION);
579     }
580 
581     /**
582      * Creates an IP configuration with specific parameters.
583      * @param proxySetting Must be one of {@link WifiConfigurationTestUtil#STATIC_PROXY_SETTING},
584      * {@link WifiConfigurationTestUtil#PAC_PROXY_SETTING},
585      * {@link WifiConfigurationTestUtil#NONE_PROXY_SETTING}
586      */
createDHCPIpConfigurationWithSpecificProxy( int proxySetting, String staticProxyHost, int staticProxyPort, String staticProxyExclusionList, String pacProxyLocation)587     public static IpConfiguration createDHCPIpConfigurationWithSpecificProxy(
588             int proxySetting,
589             String staticProxyHost,
590             int staticProxyPort,
591             String staticProxyExclusionList,
592             String pacProxyLocation) {
593         return generateIpConfig(
594                 DHCP_IP_ASSIGNMENT, proxySetting,
595                 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH,
596                 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES,
597                 staticProxyHost, staticProxyPort, staticProxyExclusionList,
598                 pacProxyLocation);
599     }
600 
601     // TODO: These enterprise configurations may need more parameters set.
createPEAPWifiEnterpriseConfigWithGTCPhase2()602     public static WifiEnterpriseConfig createPEAPWifiEnterpriseConfigWithGTCPhase2() {
603         WifiEnterpriseConfig config = new WifiEnterpriseConfig();
604         config.setEapMethod(WifiEnterpriseConfig.Eap.PEAP);
605         config.setPhase2Method(WifiEnterpriseConfig.Phase2.GTC);
606         config.setCaCertificateAliases(new String[] {TEST_CA_CERT_ALIAS + "PEAP"});
607         config.setCaCertificates(new X509Certificate[] {FakeKeys.CA_CERT0, FakeKeys.CA_CERT1});
608         config.setDomainSuffixMatch(TEST_DOM_SUBJECT_MATCH);
609         config.setIdentity(TEST_IDENTITY);
610         config.setPassword(TEST_EAP_PASSWORD);
611         return config;
612     }
613 
createTLSWifiEnterpriseConfigWithNonePhase2()614     public static WifiEnterpriseConfig createTLSWifiEnterpriseConfigWithNonePhase2() {
615         WifiEnterpriseConfig config = new WifiEnterpriseConfig();
616         config.setEapMethod(WifiEnterpriseConfig.Eap.TLS);
617         config.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
618         config.setCaCertificateAliases(new String[] {TEST_CA_CERT_ALIAS + "TLS"});
619         config.setCaCertificates(new X509Certificate[] {FakeKeys.CA_CERT0, FakeKeys.CA_CERT1});
620         config.setDomainSuffixMatch(TEST_DOM_SUBJECT_MATCH);
621         return config;
622     }
623 
createTLSWifiEnterpriseConfigWithAkaPhase2()624     public static WifiEnterpriseConfig createTLSWifiEnterpriseConfigWithAkaPhase2() {
625         WifiEnterpriseConfig config = new WifiEnterpriseConfig();
626         config.setEapMethod(WifiEnterpriseConfig.Eap.TLS);
627         config.setPhase2Method(WifiEnterpriseConfig.Phase2.AKA);
628         config.setDomainSuffixMatch(TEST_DOM_SUBJECT_MATCH);
629         return config;
630     }
631 
632     /**
633      * Gets scan result capabilities for a particular network configuration.
634      */
getScanResultCapsForNetwork(WifiConfiguration configuration)635     public static String getScanResultCapsForNetwork(WifiConfiguration configuration) {
636         String caps = "";
637         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_PSK)) {
638             caps += "[RSN-PSK-CCMP]";
639         }
640         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE)) {
641             caps += "[RSN-EAP/SHA256-CCMP][MFPC][MFPR]";
642         }
643         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_EAP)) {
644             caps += "[RSN-EAP/SHA1-CCMP]";
645         }
646         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_WEP)
647                 && WifiConfigurationUtil.hasAnyValidWepKey(configuration.wepKeys)) {
648             caps += "[WEP]";
649         }
650         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_SAE)) {
651             caps += "[RSN-SAE-CCMP]";
652         }
653         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_OWE)) {
654             caps += "[RSN-OWE-CCMP]";
655         }
656         if (configuration.isSecurityType(
657                 WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT)) {
658             caps += "[RSN-SUITE_B_192-CCMP][MFPR]";
659         }
660         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_WAPI_PSK)) {
661             caps += "[WAPI-WAPI-PSK-SMS4]";
662         }
663         if (configuration.isSecurityType(WifiConfiguration.SECURITY_TYPE_WAPI_CERT)) {
664             caps += "[WAPI-WAPI-CERT-SMS4]";
665         }
666         return caps;
667     }
668 
669     /**
670      * Gets scan result capabilities for a WPA2/WPA3-Transition mode network configuration
671      */
getScanResultCapsForWpa2Wpa3TransitionNetwork()672     public static String getScanResultCapsForWpa2Wpa3TransitionNetwork() {
673         String caps = "[RSN-PSK+SAE-CCMP]";
674         return caps;
675     }
676 
677     /**
678      * Creates a scan detail corresponding to the provided network and given BSSID, etc.
679      */
createScanDetailForNetwork( WifiConfiguration configuration, String bssid, int level, int frequency, long tsf, long seen)680     public static ScanDetail createScanDetailForNetwork(
681             WifiConfiguration configuration, String bssid, int level, int frequency,
682             long tsf, long seen) {
683         String caps = getScanResultCapsForNetwork(configuration);
684         WifiSsid ssid = WifiSsid.fromString(configuration.SSID);
685         return new ScanDetail(ssid, bssid, caps, level, frequency, tsf, seen);
686     }
687 
688     /**
689      * Creates a scan detail corresponding to the provided network and given BSSID, but sets
690      * the capabilities to WPA2/WPA3-Transition mode network.
691      */
createScanDetailForWpa2Wpa3TransitionModeNetwork( WifiConfiguration configuration, String bssid, int level, int frequency, long tsf, long seen)692     public static ScanDetail createScanDetailForWpa2Wpa3TransitionModeNetwork(
693             WifiConfiguration configuration, String bssid, int level, int frequency,
694             long tsf, long seen) {
695         String caps = getScanResultCapsForWpa2Wpa3TransitionNetwork();
696         WifiSsid ssid = WifiSsid.fromUtf8Text(configuration.getPrintableSsid());
697         return new ScanDetail(ssid, bssid, caps, level, frequency, tsf, seen);
698     }
699 
700     /**
701      * Asserts that the 2 WifiConfigurations are equal in the elements saved for both backup/restore
702      * and config store.
703      */
assertCommonConfigurationElementsEqual( WifiConfiguration expected, WifiConfiguration actual, boolean isSupplicantBackup)704     private static void assertCommonConfigurationElementsEqual(
705             WifiConfiguration expected, WifiConfiguration actual, boolean isSupplicantBackup) {
706         assertNotNull(expected);
707         assertNotNull(actual);
708         assertEquals(expected.SSID, actual.SSID);
709         assertEquals(expected.BSSID, actual.BSSID);
710         assertEquals(expected.preSharedKey, actual.preSharedKey);
711         assertEquals(expected.wepKeys, actual.wepKeys);
712         assertEquals(expected.wepTxKeyIndex, actual.wepTxKeyIndex);
713         assertEquals(expected.hiddenSSID, actual.hiddenSSID);
714         assertEquals(expected.requirePmf, actual.requirePmf);
715         assertEquals(expected.allowedKeyManagement, actual.allowedKeyManagement);
716         assertEquals(expected.allowedAuthAlgorithms, actual.allowedAuthAlgorithms);
717         // Supplicant backup does not include the following fields.
718         if (!isSupplicantBackup) {
719             assertEquals(expected.allowedProtocols, actual.allowedProtocols);
720             assertEquals(expected.allowedGroupCiphers, actual.allowedGroupCiphers);
721             assertEquals(expected.allowedPairwiseCiphers, actual.allowedPairwiseCiphers);
722             assertEquals(expected.shared, actual.shared);
723         }
724         assertEquals(expected.getIpConfiguration(), actual.getIpConfiguration());
725     }
726 
727 
728    /**
729      * Asserts that the 2 WifiConfigurations are equal. This only compares the elements saved
730      * for softAp used.
731      */
assertConfigurationEqualForSoftAp( WifiConfiguration expected, WifiConfiguration actual)732     public static void assertConfigurationEqualForSoftAp(
733             WifiConfiguration expected, WifiConfiguration actual) {
734         assertEquals(expected.SSID, actual.SSID);
735         assertEquals(expected.BSSID, actual.BSSID);
736         assertEquals(expected.apBand, actual.apBand);
737         assertEquals(expected.apChannel, actual.apChannel);
738         assertEquals(expected.preSharedKey, actual.preSharedKey);
739         assertEquals(expected.getAuthType(), actual.getAuthType());
740         assertEquals(expected.hiddenSSID, actual.hiddenSSID);
741     }
742 
743     /**
744      * Asserts that the 2 WifiConfigurations are equal. This only compares the elements saved
745      * for backup/restore.
746      */
assertConfigurationEqualForBackup( WifiConfiguration expected, WifiConfiguration actual)747     public static void assertConfigurationEqualForBackup(
748             WifiConfiguration expected, WifiConfiguration actual) {
749         assertCommonConfigurationElementsEqual(expected, actual, true);
750         assertEquals(expected.meteredOverride, actual.meteredOverride);
751     }
752 
753     /**
754      * Asserts that the 2 WifiConfigurations are equal. This compares all the elements saved for
755      * config store.
756      */
assertConfigurationEqualForConfigStore( WifiConfiguration expected, WifiConfiguration actual)757     public static void assertConfigurationEqualForConfigStore(
758             WifiConfiguration expected, WifiConfiguration actual) {
759         assertCommonConfigurationElementsEqual(expected, actual, false);
760         assertEquals(expected.status, actual.status);
761         assertEquals(expected.FQDN, actual.FQDN);
762         assertEquals(expected.providerFriendlyName, actual.providerFriendlyName);
763         assertTrue(Arrays.equals(expected.roamingConsortiumIds, actual.roamingConsortiumIds));
764         assertEquals(expected.linkedConfigurations, actual.linkedConfigurations);
765         assertEquals(expected.defaultGwMacAddress, actual.defaultGwMacAddress);
766         assertEquals(expected.validatedInternetAccess, actual.validatedInternetAccess);
767         assertEquals(expected.noInternetAccessExpected, actual.noInternetAccessExpected);
768         assertEquals(expected.meteredHint, actual.meteredHint);
769         assertEquals(expected.meteredOverride, actual.meteredOverride);
770         assertEquals(expected.useExternalScores, actual.useExternalScores);
771         assertEquals(expected.trusted, actual.trusted);
772         assertEquals(expected.oemPaid, actual.oemPaid);
773         assertEquals(expected.oemPrivate, actual.oemPrivate);
774         assertEquals(expected.carrierMerged, actual.carrierMerged);
775         assertEquals(expected.restricted, actual.restricted);
776         assertEquals(0, actual.numAssociation);
777         assertEquals(expected.creatorUid, actual.creatorUid);
778         assertEquals(expected.creatorName, actual.creatorName);
779         assertEquals(expected.lastUpdateUid, actual.lastUpdateUid);
780         assertEquals(expected.lastUpdateName, actual.lastUpdateName);
781         assertEquals(expected.lastConnectUid, actual.lastConnectUid);
782         assertEquals(expected.isLegacyPasspointConfig, actual.isLegacyPasspointConfig);
783         assertEquals(expected.getRandomizedMacAddress(), actual.getRandomizedMacAddress());
784         assertEquals(expected.macRandomizationSetting, actual.macRandomizationSetting);
785         assertNetworkSelectionStatusEqualForConfigStore(
786                 expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus());
787         assertWifiEnterpriseConfigEqualForConfigStore(
788                 expected.enterpriseConfig, actual.enterpriseConfig);
789     }
790 
791     /**
792      * Asserts that the 2 WifiConfigurations are equal. This compares all the elements that are
793      * saved into internal database by WifiConfigurationManager for network additions/updates.
794      */
assertConfigurationEqualForConfigManagerAddOrUpdate( WifiConfiguration expected, WifiConfiguration actual)795     public static void assertConfigurationEqualForConfigManagerAddOrUpdate(
796             WifiConfiguration expected, WifiConfiguration actual) {
797         assertCommonConfigurationElementsEqual(expected, actual, false);
798         assertEquals(expected.FQDN, actual.FQDN);
799         assertEquals(expected.providerFriendlyName, actual.providerFriendlyName);
800         assertEquals(expected.noInternetAccessExpected, actual.noInternetAccessExpected);
801         assertEquals(expected.meteredHint, actual.meteredHint);
802         assertEquals(expected.meteredOverride, actual.meteredOverride);
803         assertEquals(expected.useExternalScores, actual.useExternalScores);
804         assertEquals(expected.ephemeral, actual.ephemeral);
805         assertEquals(expected.osu, actual.osu);
806         assertEquals(expected.trusted, actual.trusted);
807         assertEquals(expected.oemPaid, actual.oemPaid);
808         assertEquals(expected.fromWifiNetworkSuggestion, actual.fromWifiNetworkSuggestion);
809         assertEquals(expected.fromWifiNetworkSpecifier, actual.fromWifiNetworkSpecifier);
810         assertEquals(expected.creatorUid, actual.creatorUid);
811         assertEquals(expected.creatorName, actual.creatorName);
812         assertEquals(expected.lastUpdateUid, actual.lastUpdateUid);
813         assertEquals(expected.lastUpdateName, actual.lastUpdateName);
814         assertNetworkSelectionStatusEqualForConfigStore(
815                 expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus());
816         assertWifiEnterpriseConfigEqualForConfigStore(
817                 expected.enterpriseConfig, actual.enterpriseConfig);
818     }
819 
820     /**
821      * Asserts that the 2 WifiConfigurations are equal. This compares all the elements that are
822      * saved into wpa_supplicant by SupplicantStaNetwork.
823      */
assertConfigurationEqualForSupplicant( WifiConfiguration expected, WifiConfiguration actual)824     public static void assertConfigurationEqualForSupplicant(
825             WifiConfiguration expected, WifiConfiguration actual) {
826         assertNotNull(expected);
827         assertNotNull(actual);
828         assertEquals(expected.SSID, actual.SSID);
829         assertEquals(expected.getNetworkSelectionStatus().getNetworkSelectionBSSID(),
830                 actual.getNetworkSelectionStatus().getNetworkSelectionBSSID());
831         assertEquals(expected.preSharedKey, actual.preSharedKey);
832         assertEquals(expected.wepKeys, actual.wepKeys);
833         assertEquals(expected.wepTxKeyIndex, actual.wepTxKeyIndex);
834         assertEquals(expected.hiddenSSID, actual.hiddenSSID);
835         assertEquals(expected.requirePmf, actual.requirePmf);
836         assertEquals(expected.allowedKeyManagement, actual.allowedKeyManagement);
837         /* security params are static to the security type, no need to check them anymore */
838         assertWifiEnterpriseConfigEqualForConfigStore(
839                 expected.enterpriseConfig, actual.enterpriseConfig);
840     }
841 
842     /**
843      * Asserts that the 2 WifiConfigurations are equal. This is a generic version of the comparator
844      * which is used in QNS tests for comparing the network selections.
845      * This importantly checks that the networkId's of the 2 configs are equal.
846      */
assertConfigurationEqual( WifiConfiguration expected, WifiConfiguration actual)847     public static void assertConfigurationEqual(
848             WifiConfiguration expected, WifiConfiguration actual) {
849         assertCommonConfigurationElementsEqual(expected, actual, false);
850         assertEquals(expected.networkId, actual.networkId);
851         assertEquals(expected.ephemeral, actual.ephemeral);
852         assertEquals(expected.fromWifiNetworkSuggestion, actual.fromWifiNetworkSuggestion);
853         assertEquals(expected.fromWifiNetworkSpecifier, actual.fromWifiNetworkSpecifier);
854         assertEquals(expected.trusted, actual.trusted);
855     }
856 
857     /**
858      * Assert that the 2 NetworkSelectionStatus's are equal. This compares all the elements saved
859      * for config store.
860      */
assertNetworkSelectionStatusEqualForConfigStore( NetworkSelectionStatus expected, NetworkSelectionStatus actual)861     public static void assertNetworkSelectionStatusEqualForConfigStore(
862             NetworkSelectionStatus expected, NetworkSelectionStatus actual) {
863         if (expected.isNetworkTemporaryDisabled()) {
864             // Temporarily disabled networks are enabled when persisted.
865             assertEquals(
866                     NetworkSelectionStatus.NETWORK_SELECTION_ENABLED,
867                     actual.getNetworkSelectionStatus());
868             assertEquals(
869                     NetworkSelectionStatus.DISABLED_NONE,
870                     actual.getNetworkSelectionDisableReason());
871         } else {
872             assertEquals(expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus());
873             assertEquals(
874                     expected.getNetworkSelectionDisableReason(),
875                     actual.getNetworkSelectionDisableReason());
876         }
877         assertEquals(expected.getConnectChoice(), actual.getConnectChoice());
878         assertEquals(expected.hasEverConnected(), actual.hasEverConnected());
879     }
880 
881     /**
882      * Assert that the 2 WifiEnterpriseConfig's are equal. This compares all the elements saved
883      * for config store.
884      */
assertWifiEnterpriseConfigEqualForConfigStore( WifiEnterpriseConfig expected, WifiEnterpriseConfig actual)885     public static void assertWifiEnterpriseConfigEqualForConfigStore(
886             WifiEnterpriseConfig expected, WifiEnterpriseConfig actual) {
887         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.IDENTITY_KEY),
888                 actual.getFieldValue(WifiEnterpriseConfig.IDENTITY_KEY));
889         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ANON_IDENTITY_KEY),
890                 actual.getFieldValue(WifiEnterpriseConfig.ANON_IDENTITY_KEY));
891         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PASSWORD_KEY),
892                 actual.getFieldValue(WifiEnterpriseConfig.PASSWORD_KEY));
893         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY),
894                 actual.getFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY));
895         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CA_CERT_KEY),
896                 actual.getFieldValue(WifiEnterpriseConfig.CA_CERT_KEY));
897         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY),
898                 actual.getFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY));
899         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY),
900                 actual.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY));
901         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY),
902                 actual.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY));
903         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY),
904                 actual.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY));
905         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY),
906                 actual.getFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY));
907         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY),
908                 actual.getFieldValue(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY));
909         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CA_PATH_KEY),
910                 actual.getFieldValue(WifiEnterpriseConfig.CA_PATH_KEY));
911         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.REALM_KEY),
912                 actual.getFieldValue(WifiEnterpriseConfig.REALM_KEY));
913         assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PLMN_KEY),
914                 actual.getFieldValue(WifiEnterpriseConfig.PLMN_KEY));
915         assertEquals(expected.getEapMethod(), actual.getEapMethod());
916         assertEquals(expected.getPhase2Method(), actual.getPhase2Method());
917         if (SdkLevel.isAtLeastS()) {
918             assertEquals(expected.getClientKeyPairAlias(), actual.getClientKeyPairAlias());
919         }
920     }
921 
922     /**
923      * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements
924      * saved for backup/restore.
925      */
assertConfigurationsEqualForBackup( List<WifiConfiguration> expected, List<WifiConfiguration> actual)926     public static void assertConfigurationsEqualForBackup(
927             List<WifiConfiguration> expected, List<WifiConfiguration> actual) {
928         assertEquals(expected.size(), actual.size());
929         for (WifiConfiguration expectedConfiguration : expected) {
930             String expectedConfigKey = expectedConfiguration.getProfileKey();
931             boolean didCompare = false;
932             for (WifiConfiguration actualConfiguration : actual) {
933                 String actualConfigKey = actualConfiguration.getProfileKey();
934                 if (actualConfigKey.equals(expectedConfigKey)) {
935                     assertConfigurationEqualForBackup(
936                             expectedConfiguration, actualConfiguration);
937                     didCompare = true;
938                 }
939             }
940             assertTrue(didCompare);
941         }
942     }
943 
944     /**
945      * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements
946      * that are saved into internal database by WifiConfigurationManager for network
947      * additions/updates.
948      */
assertConfigurationsEqualForConfigManagerAddOrUpdate( List<WifiConfiguration> expected, List<WifiConfiguration> actual)949     public static void assertConfigurationsEqualForConfigManagerAddOrUpdate(
950             List<WifiConfiguration> expected, List<WifiConfiguration> actual) {
951         assertEquals(expected.size(), actual.size());
952         for (WifiConfiguration expectedConfiguration : expected) {
953             String expectedConfigKey = expectedConfiguration.getProfileKey();
954             boolean didCompare = false;
955             for (WifiConfiguration actualConfiguration : actual) {
956                 String actualConfigKey = actualConfiguration.getProfileKey();
957                 if (actualConfigKey.equals(expectedConfigKey)) {
958                     assertConfigurationEqualForConfigManagerAddOrUpdate(
959                             expectedConfiguration, actualConfiguration);
960                     didCompare = true;
961                 }
962             }
963             assertTrue(didCompare);
964         }
965     }
966 
967     /**
968      * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements
969      * saved for config store.
970      */
assertConfigurationsEqualForConfigStore( List<WifiConfiguration> expected, List<WifiConfiguration> actual)971     public static void assertConfigurationsEqualForConfigStore(
972             List<WifiConfiguration> expected, List<WifiConfiguration> actual) {
973         assertEquals(expected.size(), actual.size());
974         for (WifiConfiguration expectedConfiguration : expected) {
975             String expectedConfigKey = expectedConfiguration.getProfileKey();
976             boolean didCompare = false;
977             for (WifiConfiguration actualConfiguration : actual) {
978                 String actualConfigKey = actualConfiguration.getProfileKey();
979                 if (actualConfigKey.equals(expectedConfigKey)) {
980                     assertConfigurationEqualForConfigStore(
981                             expectedConfiguration, actualConfiguration);
982                     didCompare = true;
983                 }
984             }
985             assertTrue(didCompare);
986         }
987     }
988 }
989