WifiConfigurationTestUtil.java revision 9ef555a48ac600c8766f703fa60db15b69e20301
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 "45342312ab", "45342312ab45342312ab34ac12"}; 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 assertEquals(expected.isLegacyPasspointConfig, actual.isLegacyPasspointConfig); 459 assertNetworkSelectionStatusEqualForConfigStore( 460 expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus()); 461 assertWifiEnterpriseConfigEqualForConfigStore( 462 expected.enterpriseConfig, actual.enterpriseConfig); 463 } 464 465 /** 466 * Asserts that the 2 WifiConfigurations are equal. This compares all the elements that are 467 * saved into internal database by WifiConfigurationManager for network additions/updates. 468 */ 469 public static void assertConfigurationEqualForConfigManagerAddOrUpdate( 470 WifiConfiguration expected, WifiConfiguration actual) { 471 assertCommonConfigurationElementsEqual(expected, actual); 472 assertEquals(expected.FQDN, actual.FQDN); 473 assertEquals(expected.providerFriendlyName, actual.providerFriendlyName); 474 assertEquals(expected.noInternetAccessExpected, actual.noInternetAccessExpected); 475 assertEquals(expected.meteredHint, actual.meteredHint); 476 assertEquals(expected.useExternalScores, actual.useExternalScores); 477 assertEquals(expected.ephemeral, actual.ephemeral); 478 assertEquals(expected.creatorUid, actual.creatorUid); 479 assertEquals(expected.creatorName, actual.creatorName); 480 assertEquals(expected.creationTime, actual.creationTime); 481 assertEquals(expected.lastUpdateUid, actual.lastUpdateUid); 482 assertEquals(expected.lastUpdateName, actual.lastUpdateName); 483 assertEquals(expected.updateTime, actual.updateTime); 484 assertNetworkSelectionStatusEqualForConfigStore( 485 expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus()); 486 assertWifiEnterpriseConfigEqualForConfigStore( 487 expected.enterpriseConfig, actual.enterpriseConfig); 488 } 489 490 /** 491 * Asserts that the 2 WifiConfigurations are equal. This compares all the elements that are 492 * saved into wpa_supplicant by SupplicantStaNetwork. 493 */ 494 public static void assertConfigurationEqualForSupplicant( 495 WifiConfiguration expected, WifiConfiguration actual) { 496 assertNotNull(expected); 497 assertNotNull(actual); 498 assertEquals(expected.SSID, actual.SSID); 499 assertEquals(expected.getNetworkSelectionStatus().getNetworkSelectionBSSID(), 500 actual.getNetworkSelectionStatus().getNetworkSelectionBSSID()); 501 assertEquals(expected.preSharedKey, actual.preSharedKey); 502 assertEquals(expected.wepKeys, actual.wepKeys); 503 assertEquals(expected.wepTxKeyIndex, actual.wepTxKeyIndex); 504 assertEquals(expected.hiddenSSID, actual.hiddenSSID); 505 assertEquals(expected.requirePMF, actual.requirePMF); 506 assertEquals(expected.allowedKeyManagement, actual.allowedKeyManagement); 507 assertEquals(expected.allowedProtocols, actual.allowedProtocols); 508 assertEquals(expected.allowedAuthAlgorithms, actual.allowedAuthAlgorithms); 509 assertEquals(expected.allowedGroupCiphers, actual.allowedGroupCiphers); 510 assertEquals(expected.allowedPairwiseCiphers, actual.allowedPairwiseCiphers); 511 assertWifiEnterpriseConfigEqualForConfigStore( 512 expected.enterpriseConfig, actual.enterpriseConfig); 513 } 514 515 /** 516 * Asserts that the 2 WifiConfigurations are equal. This is a generic version of the comparator 517 * which is used in QNS tests for comparing the network selections. 518 * This importantly checks that the networkId's of the 2 configs are equal. 519 */ 520 public static void assertConfigurationEqual( 521 WifiConfiguration expected, WifiConfiguration actual) { 522 assertCommonConfigurationElementsEqual(expected, actual); 523 assertEquals(expected.networkId, actual.networkId); 524 } 525 526 /** 527 * Assert that the 2 NetworkSelectionStatus's are equal. This compares all the elements saved 528 * for config store. 529 */ 530 public static void assertNetworkSelectionStatusEqualForConfigStore( 531 NetworkSelectionStatus expected, NetworkSelectionStatus actual) { 532 if (expected.isNetworkTemporaryDisabled()) { 533 // Temporarily disabled networks are enabled when persisted. 534 assertEquals( 535 NetworkSelectionStatus.NETWORK_SELECTION_ENABLED, 536 actual.getNetworkSelectionStatus()); 537 assertEquals( 538 NetworkSelectionStatus.NETWORK_SELECTION_ENABLE, 539 actual.getNetworkSelectionDisableReason()); 540 } else { 541 assertEquals(expected.getNetworkSelectionStatus(), actual.getNetworkSelectionStatus()); 542 assertEquals( 543 expected.getNetworkSelectionDisableReason(), 544 actual.getNetworkSelectionDisableReason()); 545 } 546 assertEquals(expected.getConnectChoice(), actual.getConnectChoice()); 547 assertEquals(expected.getConnectChoiceTimestamp(), actual.getConnectChoiceTimestamp()); 548 assertEquals(expected.getHasEverConnected(), actual.getHasEverConnected()); 549 } 550 551 /** 552 * Assert that the 2 WifiEnterpriseConfig's are equal. This compares all the elements saved 553 * for config store. 554 */ 555 public static void assertWifiEnterpriseConfigEqualForConfigStore( 556 WifiEnterpriseConfig expected, WifiEnterpriseConfig actual) { 557 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.IDENTITY_KEY), 558 actual.getFieldValue(WifiEnterpriseConfig.IDENTITY_KEY)); 559 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ANON_IDENTITY_KEY), 560 actual.getFieldValue(WifiEnterpriseConfig.ANON_IDENTITY_KEY)); 561 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PASSWORD_KEY), 562 actual.getFieldValue(WifiEnterpriseConfig.PASSWORD_KEY)); 563 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY), 564 actual.getFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY)); 565 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CA_CERT_KEY), 566 actual.getFieldValue(WifiEnterpriseConfig.CA_CERT_KEY)); 567 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY), 568 actual.getFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY)); 569 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY), 570 actual.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY)); 571 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY), 572 actual.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY)); 573 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY), 574 actual.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY)); 575 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY), 576 actual.getFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY)); 577 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY), 578 actual.getFieldValue(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY)); 579 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.CA_PATH_KEY), 580 actual.getFieldValue(WifiEnterpriseConfig.CA_PATH_KEY)); 581 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.REALM_KEY), 582 actual.getFieldValue(WifiEnterpriseConfig.REALM_KEY)); 583 assertEquals(expected.getFieldValue(WifiEnterpriseConfig.PLMN_KEY), 584 actual.getFieldValue(WifiEnterpriseConfig.PLMN_KEY)); 585 assertEquals(expected.getEapMethod(), actual.getEapMethod()); 586 assertEquals(expected.getPhase2Method(), actual.getPhase2Method()); 587 } 588 589 /** 590 * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements 591 * saved for backup/restore. 592 */ 593 public static void assertConfigurationsEqualForBackup( 594 List<WifiConfiguration> expected, List<WifiConfiguration> actual) { 595 assertEquals(expected.size(), actual.size()); 596 for (WifiConfiguration expectedConfiguration : expected) { 597 String expectedConfigKey = expectedConfiguration.configKey(); 598 boolean didCompare = false; 599 for (WifiConfiguration actualConfiguration : actual) { 600 String actualConfigKey = actualConfiguration.configKey(); 601 if (actualConfigKey.equals(expectedConfigKey)) { 602 assertConfigurationEqualForBackup( 603 expectedConfiguration, actualConfiguration); 604 didCompare = true; 605 } 606 } 607 assertTrue(didCompare); 608 } 609 } 610 611 /** 612 * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements 613 * that are saved into internal database by WifiConfigurationManager for network 614 * additions/updates. 615 */ 616 public static void assertConfigurationsEqualForConfigManagerAddOrUpdate( 617 List<WifiConfiguration> expected, List<WifiConfiguration> actual) { 618 assertEquals(expected.size(), actual.size()); 619 for (WifiConfiguration expectedConfiguration : expected) { 620 String expectedConfigKey = expectedConfiguration.configKey(); 621 boolean didCompare = false; 622 for (WifiConfiguration actualConfiguration : actual) { 623 String actualConfigKey = actualConfiguration.configKey(); 624 if (actualConfigKey.equals(expectedConfigKey)) { 625 assertConfigurationEqualForConfigManagerAddOrUpdate( 626 expectedConfiguration, actualConfiguration); 627 didCompare = true; 628 } 629 } 630 assertTrue(didCompare); 631 } 632 } 633 634 /** 635 * Asserts that the 2 lists of WifiConfigurations are equal. This compares all the elements 636 * saved for config store. 637 */ 638 public static void assertConfigurationsEqualForConfigStore( 639 List<WifiConfiguration> expected, List<WifiConfiguration> actual) { 640 assertEquals(expected.size(), actual.size()); 641 for (WifiConfiguration expectedConfiguration : expected) { 642 String expectedConfigKey = expectedConfiguration.configKey(); 643 boolean didCompare = false; 644 for (WifiConfiguration actualConfiguration : actual) { 645 String actualConfigKey = actualConfiguration.configKey(); 646 if (actualConfigKey.equals(expectedConfigKey)) { 647 assertConfigurationEqualForConfigStore( 648 expectedConfiguration, actualConfiguration); 649 didCompare = true; 650 } 651 } 652 assertTrue(didCompare); 653 } 654 } 655} 656