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