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 17package com.android.server.wifi; 18 19import static org.junit.Assert.*; 20 21import android.net.IpConfiguration; 22import android.net.LinkAddress; 23import android.net.NetworkUtils; 24import android.net.ProxyInfo; 25import android.net.StaticIpConfiguration; 26import android.net.wifi.WifiConfiguration; 27import android.net.wifi.WifiConfiguration.NetworkSelectionStatus; 28import android.net.wifi.WifiEnterpriseConfig; 29import android.net.wifi.WifiSsid; 30import android.text.TextUtils; 31 32import java.net.InetAddress; 33import java.security.cert.X509Certificate; 34import java.util.Arrays; 35import java.util.List; 36 37/** 38 * Helper for creating and populating WifiConfigurations in unit tests. 39 */ 40public class WifiConfigurationTestUtil { 41 /** 42 * These values are used to describe AP's security setting. One AP can support multiple of them, 43 * only if there is no conflict. 44 */ 45 public static final int SECURITY_NONE = 0; 46 public static final int SECURITY_WEP = 1 << 0; 47 public static final int SECURITY_PSK = 1 << 1; 48 public static final int SECURITY_EAP = 1 << 2; 49 50 /** 51 * These values are used to describe ip configuration parameters for a network. 52 */ 53 public static final int STATIC_IP_ASSIGNMENT = 0; 54 public static final int DHCP_IP_ASSIGNMENT = 1; 55 public static final int STATIC_PROXY_SETTING = 0; 56 public static final int PAC_PROXY_SETTING = 1; 57 public static final int NONE_PROXY_SETTING = 2; 58 59 /** 60 * These are constants used to generate predefined WifiConfiguration objects. 61 */ 62 public static final int TEST_NETWORK_ID = -1; 63 public static final int TEST_UID = 5; 64 public static final String TEST_SSID = "WifiConfigurationTestUtilSSID"; 65 public static final String TEST_PSK = "\"WifiConfigurationTestUtilPsk\""; 66 public static final String[] TEST_WEP_KEYS = 67 {"\"WifiConfigurationTestUtilWep1\"", "\"WifiConfigurationTestUtilWep2\"", 68 "45342312ab", "45342312ab45342312ab34ac12"}; 69 public static final String TEST_EAP_PASSWORD = "WifiConfigurationTestUtilEapPassword"; 70 public static final int TEST_WEP_TX_KEY_INDEX = 1; 71 public static final String TEST_FQDN = "WifiConfigurationTestUtilFQDN"; 72 public static final String TEST_PROVIDER_FRIENDLY_NAME = 73 "WifiConfigurationTestUtilFriendlyName"; 74 public static final String TEST_STATIC_IP_LINK_ADDRESS = "192.168.48.2"; 75 public static final int TEST_STATIC_IP_LINK_PREFIX_LENGTH = 8; 76 public static final String TEST_STATIC_IP_GATEWAY_ADDRESS = "192.168.48.1"; 77 public static final String[] TEST_STATIC_IP_DNS_SERVER_ADDRESSES = 78 new String[]{"192.168.48.1", "192.168.48.10"}; 79 public static final String TEST_STATIC_PROXY_HOST = "192.168.48.1"; 80 public static final int TEST_STATIC_PROXY_PORT = 8000; 81 public static final String TEST_STATIC_PROXY_EXCLUSION_LIST = ""; 82 public static final String TEST_PAC_PROXY_LOCATION = "http://"; 83 public static final String TEST_CA_CERT_ALIAS = "WifiConfigurationTestUtilCaCertAlias"; 84 85 private static final int MAX_SSID_LENGTH = 32; 86 /** 87 * Index used to assign unique SSIDs for the generation of predefined WifiConfiguration objects. 88 */ 89 private static int sNetworkIndex = 0; 90 91 /** 92 * Construct a {@link android.net.wifi.WifiConfiguration}. 93 * @param networkId the configuration's networkId 94 * @param uid the configuration's creator uid 95 * @param ssid the configuration's ssid 96 * @param shared whether the configuration is shared with other users on the device 97 * @param enabled whether the configuration is enabled 98 * @param fqdn the configuration's FQDN (Hotspot 2.0 only) 99 * @param providerFriendlyName the configuration's provider's friendly name (Hotspot 2.0 only) 100 * @return the constructed {@link android.net.wifi.WifiConfiguration} 101 */ 102 public static WifiConfiguration generateWifiConfig(int networkId, int uid, String ssid, 103 boolean shared, boolean enabled, String fqdn, String providerFriendlyName) { 104 final WifiConfiguration config = new WifiConfiguration(); 105 config.SSID = ssid; 106 config.networkId = networkId; 107 config.creatorUid = uid; 108 config.shared = shared; 109 config.status = enabled ? WifiConfiguration.Status.ENABLED 110 : WifiConfiguration.Status.DISABLED; 111 config.FQDN = fqdn; 112 config.providerFriendlyName = providerFriendlyName; 113 return config; 114 } 115 116 /** 117 * Construct a {@link android.net.wifi.WifiConfiguration}. 118 * @param networkId the configuration's networkId 119 * @param uid the configuration's creator uid 120 * @param ssid the configuration's ssid 121 * @param shared whether the configuration is shared with other users on the device 122 * @param enabled whether the configuration is enabled 123 * @param fqdn the configuration's FQDN (Hotspot 2.0 only) 124 * @param providerFriendlyName the configuration's provider's friendly name (Hotspot 2.0 only) 125 * @param security the configuration's security type 126 * @return the constructed {@link android.net.wifi.WifiConfiguration} 127 */ 128 public static WifiConfiguration generateWifiConfig(int networkId, int uid, String ssid, 129 boolean shared, boolean enabled, String fqdn, String providerFriendlyName, 130 int security) { 131 WifiConfiguration config = generateWifiConfig(networkId, uid, ssid, shared, enabled, fqdn, 132 providerFriendlyName); 133 134 if ((security == SECURITY_NONE) || ((security & SECURITY_WEP) != 0)) { 135 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE); 136 } else { 137 if ((security & SECURITY_PSK) != 0) { 138 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK); 139 } 140 141 if ((security & SECURITY_EAP) != 0) { 142 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP); 143 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.IEEE8021X); 144 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TTLS); 145 } 146 } 147 return config; 148 } 149 150 /** 151 * Construct a {@link android.net.IpConfiguration }. 152 * @param ipAssignmentType One of {@link #STATIC_IP_ASSIGNMENT} or {@link #DHCP_IP_ASSIGNMENT}. 153 * @param proxySettingType One of {@link #STATIC_PROXY_SETTING} or {@link #PAC_PROXY_SETTING} or 154 * {@link #NONE_PROXY_SETTING}. 155 * @param linkAddress static ip address string. 156 * @param linkPrefixLength static ip address prefix length. 157 * @param gatewayAddress static gateway address. 158 * @param dnsServerAddresses list of dns servers for static ip configuration. 159 * @param proxyHost Static proxy server address. 160 * @param proxyPort Static proxy server port. 161 * @param proxyExclusionList Static proxy exclusion list. 162 * @param pacProxyPath Pac proxy server path. 163 * @return the constructed {@link android.net.IpConfiguration} 164 */ 165 public static IpConfiguration generateIpConfig( 166 int ipAssignmentType, int proxySettingType, String linkAddress, int linkPrefixLength, 167 String gatewayAddress, String[] dnsServerAddresses, String proxyHost, 168 int proxyPort, String proxyExclusionList, String pacProxyPath) { 169 StaticIpConfiguration staticIpConfiguration = null; 170 ProxyInfo proxyInfo = null; 171 IpConfiguration.IpAssignment ipAssignment = IpConfiguration.IpAssignment.UNASSIGNED; 172 IpConfiguration.ProxySettings proxySettings = IpConfiguration.ProxySettings.UNASSIGNED; 173 174 if (ipAssignmentType == STATIC_IP_ASSIGNMENT) { 175 staticIpConfiguration = new StaticIpConfiguration(); 176 if (!TextUtils.isEmpty(linkAddress)) { 177 LinkAddress linkAddr = 178 new LinkAddress( 179 NetworkUtils.numericToInetAddress(linkAddress), linkPrefixLength); 180 staticIpConfiguration.ipAddress = linkAddr; 181 } 182 183 if (!TextUtils.isEmpty(gatewayAddress)) { 184 InetAddress gatewayAddr = 185 NetworkUtils.numericToInetAddress(gatewayAddress); 186 staticIpConfiguration.gateway = gatewayAddr; 187 } 188 if (dnsServerAddresses != null) { 189 for (String dnsServerAddress : dnsServerAddresses) { 190 if (!TextUtils.isEmpty(dnsServerAddress)) { 191 staticIpConfiguration.dnsServers.add( 192 NetworkUtils.numericToInetAddress(dnsServerAddress)); 193 } 194 195 } 196 } 197 ipAssignment = IpConfiguration.IpAssignment.STATIC; 198 } else if (ipAssignmentType == DHCP_IP_ASSIGNMENT) { 199 ipAssignment = IpConfiguration.IpAssignment.DHCP; 200 } 201 202 if (proxySettingType == STATIC_PROXY_SETTING) { 203 proxyInfo = new ProxyInfo(proxyHost, proxyPort, proxyExclusionList); 204 proxySettings = IpConfiguration.ProxySettings.STATIC; 205 } else if (proxySettingType == PAC_PROXY_SETTING) { 206 proxyInfo = new ProxyInfo(pacProxyPath); 207 proxySettings = IpConfiguration.ProxySettings.PAC; 208 } else if (proxySettingType == NONE_PROXY_SETTING) { 209 proxySettings = IpConfiguration.ProxySettings.NONE; 210 } 211 return new IpConfiguration(ipAssignment, proxySettings, staticIpConfiguration, proxyInfo); 212 } 213 214 /** 215 * Create a new SSID for the the network being created. 216 */ 217 private static String createNewSSID() { 218 String ssid = TEST_SSID + sNetworkIndex++; 219 assertTrue(ssid.length() <= MAX_SSID_LENGTH); 220 return "\"" + ssid + "\""; 221 } 222 223 /** 224 * Helper methods to generate predefined WifiConfiguration objects of the required type. These 225 * use a static index to avoid duplicate configurations. 226 */ 227 public static WifiConfiguration createOpenNetwork() { 228 return createOpenNetwork(createNewSSID()); 229 } 230 231 public static WifiConfiguration createOpenNetwork(String ssid) { 232 return generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true, null, 233 null, SECURITY_NONE); 234 } 235 236 public static WifiConfiguration createEphemeralNetwork() { 237 WifiConfiguration configuration = createOpenNetwork(); 238 configuration.ephemeral = true; 239 return configuration; 240 } 241 242 public static WifiConfiguration createOpenHiddenNetwork() { 243 WifiConfiguration configuration = createOpenNetwork(); 244 configuration.hiddenSSID = true; 245 return configuration; 246 } 247 248 public static WifiConfiguration createPskNetwork() { 249 WifiConfiguration configuration = 250 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, null, 251 null, SECURITY_PSK); 252 configuration.preSharedKey = TEST_PSK; 253 return configuration; 254 } 255 256 public static WifiConfiguration createPskNetwork(String ssid) { 257 WifiConfiguration configuration = 258 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true, null, 259 null, SECURITY_PSK); 260 configuration.preSharedKey = TEST_PSK; 261 return configuration; 262 } 263 264 265 public static WifiConfiguration createPskHiddenNetwork() { 266 WifiConfiguration configuration = createPskNetwork(); 267 configuration.hiddenSSID = true; 268 return configuration; 269 } 270 271 public static WifiConfiguration createWepNetwork() { 272 WifiConfiguration configuration = 273 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, null, 274 null, SECURITY_WEP); 275 configuration.wepKeys = TEST_WEP_KEYS; 276 configuration.wepTxKeyIndex = TEST_WEP_TX_KEY_INDEX; 277 return configuration; 278 } 279 280 public static WifiConfiguration createWepHiddenNetwork() { 281 WifiConfiguration configuration = createWepNetwork(); 282 configuration.hiddenSSID = true; 283 return configuration; 284 } 285 286 287 public static WifiConfiguration createWepNetworkWithSingleKey() { 288 WifiConfiguration configuration = 289 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, null, 290 null, SECURITY_WEP); 291 configuration.wepKeys[0] = TEST_WEP_KEYS[0]; 292 configuration.wepTxKeyIndex = 0; 293 return configuration; 294 } 295 296 297 public static WifiConfiguration createEapNetwork() { 298 WifiConfiguration configuration = 299 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, 300 null, null, SECURITY_EAP); 301 return configuration; 302 } 303 304 public static WifiConfiguration createEapNetwork(String ssid) { 305 WifiConfiguration configuration = 306 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, ssid, true, true, 307 null, null, SECURITY_EAP); 308 return configuration; 309 } 310 311 312 public static WifiConfiguration createEapNetwork(int eapMethod, int phase2Method) { 313 WifiConfiguration configuration = 314 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, 315 null, null, SECURITY_EAP); 316 configuration.enterpriseConfig.setEapMethod(eapMethod); 317 configuration.enterpriseConfig.setPhase2Method(phase2Method); 318 return configuration; 319 } 320 321 public static WifiConfiguration createPasspointNetwork() { 322 WifiConfiguration configuration = 323 generateWifiConfig(TEST_NETWORK_ID, TEST_UID, createNewSSID(), true, true, 324 TEST_FQDN, TEST_PROVIDER_FRIENDLY_NAME, SECURITY_EAP); 325 return configuration; 326 } 327 328 public static IpConfiguration createStaticIpConfigurationWithPacProxy() { 329 return generateIpConfig( 330 STATIC_IP_ASSIGNMENT, PAC_PROXY_SETTING, 331 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH, 332 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES, 333 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST, 334 TEST_PAC_PROXY_LOCATION); 335 } 336 337 public static IpConfiguration createStaticIpConfigurationWithStaticProxy() { 338 return generateIpConfig( 339 STATIC_IP_ASSIGNMENT, STATIC_PROXY_SETTING, 340 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH, 341 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES, 342 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST, 343 TEST_PAC_PROXY_LOCATION); 344 } 345 346 public static IpConfiguration createPartialStaticIpConfigurationWithPacProxy() { 347 return generateIpConfig( 348 STATIC_IP_ASSIGNMENT, PAC_PROXY_SETTING, 349 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH, 350 null, null, 351 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST, 352 TEST_PAC_PROXY_LOCATION); 353 } 354 355 public static IpConfiguration createDHCPIpConfigurationWithPacProxy() { 356 return generateIpConfig( 357 DHCP_IP_ASSIGNMENT, PAC_PROXY_SETTING, 358 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH, 359 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES, 360 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST, 361 TEST_PAC_PROXY_LOCATION); 362 } 363 364 public static IpConfiguration createDHCPIpConfigurationWithStaticProxy() { 365 return generateIpConfig( 366 DHCP_IP_ASSIGNMENT, STATIC_PROXY_SETTING, 367 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH, 368 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES, 369 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST, 370 TEST_PAC_PROXY_LOCATION); 371 } 372 373 public static IpConfiguration createDHCPIpConfigurationWithNoProxy() { 374 return generateIpConfig( 375 DHCP_IP_ASSIGNMENT, NONE_PROXY_SETTING, 376 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH, 377 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES, 378 TEST_STATIC_PROXY_HOST, TEST_STATIC_PROXY_PORT, TEST_STATIC_PROXY_EXCLUSION_LIST, 379 TEST_PAC_PROXY_LOCATION); 380 } 381 382 /** 383 * Creates an IP configuration with specific parameters. 384 * @param proxySetting Must be one of {@link WifiConfigurationTestUtil#STATIC_PROXY_SETTING}, 385 * {@link WifiConfigurationTestUtil#PAC_PROXY_SETTING}, 386 * {@link WifiConfigurationTestUtil#NONE_PROXY_SETTING} 387 */ 388 public static IpConfiguration createDHCPIpConfigurationWithSpecificProxy( 389 int proxySetting, 390 String staticProxyHost, 391 int staticProxyPort, 392 String staticProxyExclusionList, 393 String pacProxyLocation) { 394 return generateIpConfig( 395 DHCP_IP_ASSIGNMENT, proxySetting, 396 TEST_STATIC_IP_LINK_ADDRESS, TEST_STATIC_IP_LINK_PREFIX_LENGTH, 397 TEST_STATIC_IP_GATEWAY_ADDRESS, TEST_STATIC_IP_DNS_SERVER_ADDRESSES, 398 staticProxyHost, staticProxyPort, staticProxyExclusionList, 399 pacProxyLocation); 400 } 401 402 // TODO: These enterprise configurations may need more parameters set. 403 public static WifiEnterpriseConfig createPEAPWifiEnterpriseConfigWithGTCPhase2() { 404 WifiEnterpriseConfig config = new WifiEnterpriseConfig(); 405 config.setEapMethod(WifiEnterpriseConfig.Eap.PEAP); 406 config.setPhase2Method(WifiEnterpriseConfig.Phase2.GTC); 407 config.setCaCertificateAliases(new String[] {TEST_CA_CERT_ALIAS + "PEAP"}); 408 config.setCaCertificates(new X509Certificate[] {FakeKeys.CA_CERT0, FakeKeys.CA_CERT1}); 409 return config; 410 } 411 412 public static WifiEnterpriseConfig createTLSWifiEnterpriseConfigWithNonePhase2() { 413 WifiEnterpriseConfig config = new WifiEnterpriseConfig(); 414 config.setEapMethod(WifiEnterpriseConfig.Eap.TLS); 415 config.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 416 config.setCaCertificateAliases(new String[] {TEST_CA_CERT_ALIAS + "TLS"}); 417 config.setCaCertificates(new X509Certificate[] {FakeKeys.CA_CERT0, FakeKeys.CA_CERT1}); 418 return config; 419 } 420 421 public static WifiEnterpriseConfig createTLSWifiEnterpriseConfigWithAkaPhase2() { 422 WifiEnterpriseConfig config = new WifiEnterpriseConfig(); 423 config.setEapMethod(WifiEnterpriseConfig.Eap.TLS); 424 config.setPhase2Method(WifiEnterpriseConfig.Phase2.AKA); 425 return config; 426 } 427 428 /** 429 * Creates a scan detail corresponding to the provided network and given BSSID, level &frequency 430 * values. 431 */ 432 public static ScanDetail createScanDetailForNetwork( 433 WifiConfiguration configuration, String bssid, int level, int frequency, 434 long tsf, long seen) { 435 String caps; 436 if (configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)) { 437 caps = "[WPA2-PSK-CCMP]"; 438 } else if (configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP) 439 || configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X)) { 440 caps = "[WPA2-EAP-CCMP]"; 441 } else if (configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.NONE) 442 && WifiConfigurationUtil.hasAnyValidWepKey(configuration.wepKeys)) { 443 caps = "[WEP]"; 444 } else { 445 caps = "[]"; 446 } 447 WifiSsid ssid = WifiSsid.createFromAsciiEncoded(configuration.getPrintableSsid()); 448 return new ScanDetail(ssid, bssid, caps, level, frequency, tsf, seen); 449 } 450 451 /** 452 * Asserts that the 2 WifiConfigurations are equal in the elements saved for both backup/restore 453 * and config store. 454 */ 455 private static void assertCommonConfigurationElementsEqual( 456 WifiConfiguration expected, WifiConfiguration actual) { 457 assertNotNull(expected); 458 assertNotNull(actual); 459 assertEquals(expected.SSID, actual.SSID); 460 assertEquals(expected.BSSID, actual.BSSID); 461 assertEquals(expected.preSharedKey, actual.preSharedKey); 462 assertEquals(expected.wepKeys, actual.wepKeys); 463 assertEquals(expected.wepTxKeyIndex, actual.wepTxKeyIndex); 464 assertEquals(expected.hiddenSSID, actual.hiddenSSID); 465 assertEquals(expected.requirePMF, actual.requirePMF); 466 assertEquals(expected.allowedKeyManagement, actual.allowedKeyManagement); 467 assertEquals(expected.allowedProtocols, actual.allowedProtocols); 468 assertEquals(expected.allowedAuthAlgorithms, actual.allowedAuthAlgorithms); 469 assertEquals(expected.allowedGroupCiphers, actual.allowedGroupCiphers); 470 assertEquals(expected.allowedPairwiseCiphers, actual.allowedPairwiseCiphers); 471 assertEquals(expected.shared, actual.shared); 472 assertEquals(expected.getIpConfiguration(), actual.getIpConfiguration()); 473 } 474 475 /** 476 * Asserts that the 2 WifiConfigurations are equal. This only compares the elements saved 477 * fpr backup/restore. 478 */ 479 public static void assertConfigurationEqualForBackup( 480 WifiConfiguration expected, WifiConfiguration actual) { 481 assertCommonConfigurationElementsEqual(expected, actual); 482 } 483 484 /** 485 * Asserts that the 2 WifiConfigurations are equal. This compares all the elements saved for 486 * config store. 487 */ 488 public static void assertConfigurationEqualForConfigStore( 489 WifiConfiguration expected, WifiConfiguration actual) { 490 assertCommonConfigurationElementsEqual(expected, actual); 491 assertEquals(expected.status, actual.status); 492 assertEquals(expected.FQDN, actual.FQDN); 493 assertEquals(expected.providerFriendlyName, actual.providerFriendlyName); 494 assertTrue(Arrays.equals(expected.roamingConsortiumIds, actual.roamingConsortiumIds)); 495 assertEquals(expected.linkedConfigurations, actual.linkedConfigurations); 496 assertEquals(expected.defaultGwMacAddress, actual.defaultGwMacAddress); 497 assertEquals(expected.validatedInternetAccess, actual.validatedInternetAccess); 498 assertEquals(expected.noInternetAccessExpected, actual.noInternetAccessExpected); 499 assertEquals(expected.userApproved, actual.userApproved); 500 assertEquals(expected.meteredHint, actual.meteredHint); 501 assertEquals(expected.useExternalScores, actual.useExternalScores); 502 assertEquals(expected.numAssociation, actual.numAssociation); 503 assertEquals(expected.creatorUid, actual.creatorUid); 504 assertEquals(expected.creatorName, actual.creatorName); 505 assertEquals(expected.creationTime, actual.creationTime); 506 assertEquals(expected.lastUpdateUid, actual.lastUpdateUid); 507 assertEquals(expected.lastUpdateName, actual.lastUpdateName); 508 assertEquals(expected.lastConnectUid, actual.lastConnectUid); 509 assertEquals(expected.updateTime, actual.updateTime); 510 assertEquals(expected.isLegacyPasspointConfig, actual.isLegacyPasspointConfig); 511 assertNetworkSelectionStatusEqualForConfigStore( 512 expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus()); 513 assertWifiEnterpriseConfigEqualForConfigStore( 514 expected.enterpriseConfig, actual.enterpriseConfig); 515 } 516 517 /** 518 * Asserts that the 2 WifiConfigurations are equal. This compares all the elements that are 519 * saved into internal database by WifiConfigurationManager for network additions/updates. 520 */ 521 public static void assertConfigurationEqualForConfigManagerAddOrUpdate( 522 WifiConfiguration expected, WifiConfiguration actual) { 523 assertCommonConfigurationElementsEqual(expected, actual); 524 assertEquals(expected.FQDN, actual.FQDN); 525 assertEquals(expected.providerFriendlyName, actual.providerFriendlyName); 526 assertEquals(expected.noInternetAccessExpected, actual.noInternetAccessExpected); 527 assertEquals(expected.meteredHint, actual.meteredHint); 528 assertEquals(expected.useExternalScores, actual.useExternalScores); 529 assertEquals(expected.ephemeral, actual.ephemeral); 530 assertEquals(expected.creatorUid, actual.creatorUid); 531 assertEquals(expected.creatorName, actual.creatorName); 532 assertEquals(expected.creationTime, actual.creationTime); 533 assertEquals(expected.lastUpdateUid, actual.lastUpdateUid); 534 assertEquals(expected.lastUpdateName, actual.lastUpdateName); 535 assertEquals(expected.updateTime, actual.updateTime); 536 assertNetworkSelectionStatusEqualForConfigStore( 537 expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus()); 538 assertWifiEnterpriseConfigEqualForConfigStore( 539 expected.enterpriseConfig, actual.enterpriseConfig); 540 } 541 542 /** 543 * Asserts that the 2 WifiConfigurations are equal. This compares all the elements that are 544 * saved into wpa_supplicant by SupplicantStaNetwork. 545 */ 546 public static void assertConfigurationEqualForSupplicant( 547 WifiConfiguration expected, WifiConfiguration actual) { 548 assertNotNull(expected); 549 assertNotNull(actual); 550 assertEquals(expected.SSID, actual.SSID); 551 assertEquals(expected.getNetworkSelectionStatus().getNetworkSelectionBSSID(), 552 actual.getNetworkSelectionStatus().getNetworkSelectionBSSID()); 553 assertEquals(expected.preSharedKey, actual.preSharedKey); 554 assertEquals(expected.wepKeys, actual.wepKeys); 555 assertEquals(expected.wepTxKeyIndex, actual.wepTxKeyIndex); 556 assertEquals(expected.hiddenSSID, actual.hiddenSSID); 557 assertEquals(expected.requirePMF, actual.requirePMF); 558 assertEquals(expected.allowedKeyManagement, actual.allowedKeyManagement); 559 assertEquals(expected.allowedProtocols, actual.allowedProtocols); 560 assertEquals(expected.allowedAuthAlgorithms, actual.allowedAuthAlgorithms); 561 assertEquals(expected.allowedGroupCiphers, actual.allowedGroupCiphers); 562 assertEquals(expected.allowedPairwiseCiphers, actual.allowedPairwiseCiphers); 563 assertWifiEnterpriseConfigEqualForConfigStore( 564 expected.enterpriseConfig, actual.enterpriseConfig); 565 } 566 567 /** 568 * Asserts that the 2 WifiConfigurations are equal. This is a generic version of the comparator 569 * which is used in QNS tests for comparing the network selections. 570 * This importantly checks that the networkId's of the 2 configs are equal. 571 */ 572 public static void assertConfigurationEqual( 573 WifiConfiguration expected, WifiConfiguration actual) { 574 assertCommonConfigurationElementsEqual(expected, actual); 575 assertEquals(expected.networkId, actual.networkId); 576 } 577 578 /** 579 * Assert that the 2 NetworkSelectionStatus's are equal. This compares all the elements saved 580 * for config store. 581 */ 582 public static void assertNetworkSelectionStatusEqualForConfigStore( 583 NetworkSelectionStatus expected, NetworkSelectionStatus actual) { 584 if (expected.isNetworkTemporaryDisabled()) { 585 // Temporarily disabled networks are enabled when persisted. 586 assertEquals( 587 NetworkSelectionStatus.NETWORK_SELECTION_ENABLED, 588 actual.getNetworkSelectionStatus()); 589 assertEquals( 590 NetworkSelectionStatus.NETWORK_SELECTION_ENABLE, 591 actual.getNetworkSelectionDisableReason()); 592 } else { 593 assertEquals(expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus()); 594 assertEquals( 595 expected.getNetworkSelectionDisableReason(), 596 actual.getNetworkSelectionDisableReason()); 597 } 598 assertEquals(expected.getConnectChoice(), actual.getConnectChoice()); 599 assertEquals(expected.getConnectChoiceTimestamp(), actual.getConnectChoiceTimestamp()); 600 assertEquals(expected.getHasEverConnected(), actual.getHasEverConnected()); 601 } 602 603 /** 604 * Assert that the 2 WifiEnterpriseConfig's are equal. This compares all the elements saved 605 * for config store. 606 */ 607 public static void assertWifiEnterpriseConfigEqualForConfigStore( 608 WifiEnterpriseConfig expected, WifiEnterpriseConfig actual) { 609 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.IDENTITY_KEY), 610 actual.getFieldValue(WifiEnterpriseConfig.IDENTITY_KEY)); 611 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ANON_IDENTITY_KEY), 612 actual.getFieldValue(WifiEnterpriseConfig.ANON_IDENTITY_KEY)); 613 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PASSWORD_KEY), 614 actual.getFieldValue(WifiEnterpriseConfig.PASSWORD_KEY)); 615 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY), 616 actual.getFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY)); 617 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CA_CERT_KEY), 618 actual.getFieldValue(WifiEnterpriseConfig.CA_CERT_KEY)); 619 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY), 620 actual.getFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY)); 621 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY), 622 actual.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY)); 623 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY), 624 actual.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY)); 625 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY), 626 actual.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY)); 627 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY), 628 actual.getFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY)); 629 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY), 630 actual.getFieldValue(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY)); 631 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CA_PATH_KEY), 632 actual.getFieldValue(WifiEnterpriseConfig.CA_PATH_KEY)); 633 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.REALM_KEY), 634 actual.getFieldValue(WifiEnterpriseConfig.REALM_KEY)); 635 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PLMN_KEY), 636 actual.getFieldValue(WifiEnterpriseConfig.PLMN_KEY)); 637 assertEquals(expected.getEapMethod(), actual.getEapMethod()); 638 assertEquals(expected.getPhase2Method(), actual.getPhase2Method()); 639 } 640 641 /** 642 * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements 643 * saved for backup/restore. 644 */ 645 public static void assertConfigurationsEqualForBackup( 646 List<WifiConfiguration> expected, List<WifiConfiguration> actual) { 647 assertEquals(expected.size(), actual.size()); 648 for (WifiConfiguration expectedConfiguration : expected) { 649 String expectedConfigKey = expectedConfiguration.configKey(); 650 boolean didCompare = false; 651 for (WifiConfiguration actualConfiguration : actual) { 652 String actualConfigKey = actualConfiguration.configKey(); 653 if (actualConfigKey.equals(expectedConfigKey)) { 654 assertConfigurationEqualForBackup( 655 expectedConfiguration, actualConfiguration); 656 didCompare = true; 657 } 658 } 659 assertTrue(didCompare); 660 } 661 } 662 663 /** 664 * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements 665 * that are saved into internal database by WifiConfigurationManager for network 666 * additions/updates. 667 */ 668 public static void assertConfigurationsEqualForConfigManagerAddOrUpdate( 669 List<WifiConfiguration> expected, List<WifiConfiguration> actual) { 670 assertEquals(expected.size(), actual.size()); 671 for (WifiConfiguration expectedConfiguration : expected) { 672 String expectedConfigKey = expectedConfiguration.configKey(); 673 boolean didCompare = false; 674 for (WifiConfiguration actualConfiguration : actual) { 675 String actualConfigKey = actualConfiguration.configKey(); 676 if (actualConfigKey.equals(expectedConfigKey)) { 677 assertConfigurationEqualForConfigManagerAddOrUpdate( 678 expectedConfiguration, actualConfiguration); 679 didCompare = true; 680 } 681 } 682 assertTrue(didCompare); 683 } 684 } 685 686 /** 687 * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements 688 * saved for config store. 689 */ 690 public static void assertConfigurationsEqualForConfigStore( 691 List<WifiConfiguration> expected, List<WifiConfiguration> actual) { 692 assertEquals(expected.size(), actual.size()); 693 for (WifiConfiguration expectedConfiguration : expected) { 694 String expectedConfigKey = expectedConfiguration.configKey(); 695 boolean didCompare = false; 696 for (WifiConfiguration actualConfiguration : actual) { 697 String actualConfigKey = actualConfiguration.configKey(); 698 if (actualConfigKey.equals(expectedConfigKey)) { 699 assertConfigurationEqualForConfigStore( 700 expectedConfiguration, actualConfiguration); 701 didCompare = true; 702 } 703 } 704 assertTrue(didCompare); 705 } 706 } 707} 708