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