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