1 /* 2 * Copyright (C) 2019 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.settings.wifi; 18 19 import static com.android.settings.wifi.WifiConfigController.DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE; 20 import static com.android.settings.wifi.WifiConfigController2.DEFAULT_ANONYMOUS_ID; 21 import static com.android.settings.wifi.WifiConfigController2.WIFI_EAP_METHOD_SIM; 22 23 import static com.google.common.truth.Truth.assertThat; 24 25 import static org.mockito.ArgumentMatchers.any; 26 import static org.mockito.ArgumentMatchers.anyInt; 27 import static org.mockito.Mockito.eq; 28 import static org.mockito.Mockito.mock; 29 import static org.mockito.Mockito.never; 30 import static org.mockito.Mockito.spy; 31 import static org.mockito.Mockito.verify; 32 import static org.mockito.Mockito.when; 33 import static org.robolectric.Shadows.shadowOf; 34 35 import android.content.Context; 36 import android.content.Intent; 37 import android.content.res.Resources; 38 import android.net.IpConfiguration; 39 import android.net.wifi.WifiConfiguration; 40 import android.net.wifi.WifiEnterpriseConfig; 41 import android.net.wifi.WifiEnterpriseConfig.Eap; 42 import android.net.wifi.WifiEnterpriseConfig.Phase2; 43 import android.net.wifi.WifiManager; 44 import android.telephony.SubscriptionInfo; 45 import android.telephony.SubscriptionManager; 46 import android.telephony.TelephonyManager; 47 import android.view.LayoutInflater; 48 import android.view.View; 49 import android.view.inputmethod.InputMethodManager; 50 import android.widget.AdapterView; 51 import android.widget.ArrayAdapter; 52 import android.widget.CheckBox; 53 import android.widget.LinearLayout; 54 import android.widget.Spinner; 55 import android.widget.TextView; 56 57 import com.android.settings.R; 58 import com.android.settings.network.SubscriptionUtil; 59 import com.android.settings.utils.AndroidKeystoreAliasLoader; 60 import com.android.settings.wifi.details2.WifiPrivacyPreferenceController; 61 import com.android.settings.wifi.details2.WifiPrivacyPreferenceController2; 62 import com.android.wifitrackerlib.WifiEntry; 63 64 import com.google.common.collect.ImmutableList; 65 66 import org.junit.Before; 67 import org.junit.Test; 68 import org.junit.runner.RunWith; 69 import org.mockito.ArgumentCaptor; 70 import org.mockito.Mock; 71 import org.mockito.MockitoAnnotations; 72 import org.robolectric.RobolectricTestRunner; 73 import org.robolectric.RuntimeEnvironment; 74 import org.robolectric.Shadows; 75 import org.robolectric.shadows.ShadowInputMethodManager; 76 import org.robolectric.shadows.ShadowSubscriptionManager; 77 78 import java.util.Arrays; 79 import java.util.List; 80 import java.util.stream.Collectors; 81 import java.util.stream.IntStream; 82 83 @RunWith(RobolectricTestRunner.class) 84 public class WifiConfigController2Test { 85 86 static final String WIFI_EAP_TLS_V1_3 = "TLS v1.3"; 87 88 @Mock 89 private WifiConfigUiBase2 mConfigUiBase; 90 @Mock 91 private Context mContext; 92 @Mock 93 private WifiEntry mWifiEntry; 94 @Mock 95 private AndroidKeystoreAliasLoader mAndroidKeystoreAliasLoader; 96 @Mock 97 private WifiManager mWifiManager; 98 @Mock 99 Spinner mEapMethodSimSpinner; 100 private View mView; 101 private Spinner mHiddenSettingsSpinner; 102 private Spinner mEapCaCertSpinner; 103 private Spinner mEapUserCertSpinner; 104 private String mUnspecifiedCertString; 105 private String mUseSystemCertsString; 106 private String mDoNotProvideEapUserCertString; 107 private ShadowSubscriptionManager mShadowSubscriptionManager; 108 109 public WifiConfigController2 mController; 110 private static final String HEX_PSK = "01234567012345670123456701234567012345670123456701234567" 111 + "01abcdef"; 112 // An invalid ASCII PSK pass phrase. It is 64 characters long, must not be greater than 63 113 private static final String LONG_PSK = 114 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl"; 115 // An invalid PSK pass phrase. It is 7 characters long, must be at least 8 116 private static final String SHORT_PSK = "abcdefg"; 117 // Valid PSK pass phrase 118 private static final String GOOD_PSK = "abcdefghijklmnopqrstuvwxyz"; 119 private static final String GOOD_SSID = "abc"; 120 private static final String VALID_HEX_PSK = 121 "123456789012345678901234567890123456789012345678901234567890abcd"; 122 private static final String INVALID_HEX_PSK = 123 "123456789012345678901234567890123456789012345678901234567890ghij"; 124 private static final String NUMBER_AND_CHARACTER_KEY = "123456abcd"; 125 private static final String PARTIAL_NUMBER_AND_CHARACTER_KEY = "123456abc?"; 126 private static final int DHCP = 0; 127 // Saved certificates 128 private static final String SAVED_CA_CERT = "saved CA cert"; 129 private static final String SAVED_USER_CERT = "saved user cert"; 130 131 private static final int POSITION_SYSTEM_CERT = 1; 132 private static final int POSITION_INSTALL_CERT = 2; 133 private static final String ACTION_INSTALL_CERTS = "android.credentials.INSTALL"; 134 private static final String KEY_INSTALL_CERTIFICATE = "certificate_install_usage"; 135 private static final String INSTALL_CERTIFICATE_VALUE = "wifi"; 136 137 @Before setUp()138 public void setUp() { 139 MockitoAnnotations.initMocks(this); 140 mContext = spy(RuntimeEnvironment.application); 141 when(mContext.getSystemService(eq(WifiManager.class))).thenReturn(mWifiManager); 142 when(mWifiManager.isConnectedMacRandomizationSupported()).thenReturn(true); 143 when(mConfigUiBase.getContext()).thenReturn(mContext); 144 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_PSK); 145 mView = LayoutInflater.from(mContext).inflate(R.layout.wifi_dialog, null); 146 final Spinner ipSettingsSpinner = mView.findViewById(R.id.ip_settings); 147 mHiddenSettingsSpinner = mView.findViewById(R.id.hidden_settings); 148 mEapCaCertSpinner = mView.findViewById(R.id.ca_cert); 149 mEapUserCertSpinner = mView.findViewById(R.id.user_cert); 150 mUseSystemCertsString = mContext.getString(R.string.wifi_use_system_certs); 151 mUnspecifiedCertString = mContext.getString(R.string.wifi_unspecified); 152 mDoNotProvideEapUserCertString = 153 mContext.getString(R.string.wifi_do_not_provide_eap_user_cert); 154 ipSettingsSpinner.setSelection(DHCP); 155 mShadowSubscriptionManager = shadowOf(mContext.getSystemService(SubscriptionManager.class)); 156 when(mEapMethodSimSpinner.getSelectedItemPosition()).thenReturn(WIFI_EAP_METHOD_SIM); 157 } 158 createController( WifiEntry mWifiEntry, int modeConnect, boolean hideMeteredAndPrivacy)159 private void createController( 160 WifiEntry mWifiEntry, int modeConnect, boolean hideMeteredAndPrivacy) { 161 mController = new WifiConfigController2(mConfigUiBase, mView, mWifiEntry, 162 modeConnect, hideMeteredAndPrivacy, mWifiManager, mAndroidKeystoreAliasLoader); 163 } 164 165 @Test ssidExceeds32Bytes_shouldShowSsidTooLongWarning()166 public void ssidExceeds32Bytes_shouldShowSsidTooLongWarning() { 167 createController(null, WifiConfigUiBase2.MODE_CONNECT, false); 168 final TextView ssid = mView.findViewById(R.id.ssid); 169 assertThat(ssid).isNotNull(); 170 ssid.setText("☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎"); 171 mController.showWarningMessagesIfAppropriate(); 172 173 assertThat(mView.findViewById(R.id.ssid_too_long_warning).getVisibility()) 174 .isEqualTo(View.VISIBLE); 175 } 176 177 @Test ssidShorterThan32Bytes_shouldNotShowSsidTooLongWarning()178 public void ssidShorterThan32Bytes_shouldNotShowSsidTooLongWarning() { 179 createController(null, WifiConfigUiBase2.MODE_CONNECT, false); 180 181 final TextView ssid = mView.findViewById(R.id.ssid); 182 assertThat(ssid).isNotNull(); 183 ssid.setText("123456789012345678901234567890"); 184 mController.showWarningMessagesIfAppropriate(); 185 186 assertThat(mView.findViewById(R.id.ssid_too_long_warning).getVisibility()) 187 .isEqualTo(View.GONE); 188 189 ssid.setText("123"); 190 mController.showWarningMessagesIfAppropriate(); 191 192 assertThat(mView.findViewById(R.id.ssid_too_long_warning).getVisibility()) 193 .isEqualTo(View.GONE); 194 } 195 196 @Test isSubmittable_noSSID_shouldReturnFalse()197 public void isSubmittable_noSSID_shouldReturnFalse() { 198 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 199 final TextView ssid = mView.findViewById(R.id.ssid); 200 assertThat(ssid).isNotNull(); 201 ssid.setText(""); 202 assertThat(mController.isSubmittable()).isFalse(); 203 } 204 205 @Test isSubmittable_longPsk_shouldReturnFalse()206 public void isSubmittable_longPsk_shouldReturnFalse() { 207 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 208 final TextView password = mView.findViewById(R.id.password); 209 assertThat(password).isNotNull(); 210 password.setText(LONG_PSK); 211 assertThat(mController.isSubmittable()).isFalse(); 212 } 213 214 @Test isSubmittable_shortPsk_shouldReturnFalse()215 public void isSubmittable_shortPsk_shouldReturnFalse() { 216 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 217 final TextView password = mView.findViewById(R.id.password); 218 assertThat(password).isNotNull(); 219 password.setText(SHORT_PSK); 220 assertThat(mController.isSubmittable()).isFalse(); 221 } 222 223 @Test isSubmittable_goodPsk_shouldReturnTrue()224 public void isSubmittable_goodPsk_shouldReturnTrue() { 225 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 226 final TextView password = mView.findViewById(R.id.password); 227 assertThat(password).isNotNull(); 228 password.setText(GOOD_PSK); 229 assertThat(mController.isSubmittable()).isTrue(); 230 } 231 232 @Test isSubmittable_hexPsk_shouldReturnTrue()233 public void isSubmittable_hexPsk_shouldReturnTrue() { 234 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 235 final TextView password = mView.findViewById(R.id.password); 236 assertThat(password).isNotNull(); 237 password.setText(HEX_PSK); 238 assertThat(mController.isSubmittable()).isTrue(); 239 } 240 241 @Test isSubmittable_savedConfigZeroLengthPassword_shouldReturnTrue()242 public void isSubmittable_savedConfigZeroLengthPassword_shouldReturnTrue() { 243 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 244 final TextView password = mView.findViewById(R.id.password); 245 assertThat(password).isNotNull(); 246 password.setText(""); 247 when(mWifiEntry.isSaved()).thenReturn(true); 248 assertThat(mController.isSubmittable()).isTrue(); 249 } 250 251 @Test isSubmittable_nullWifiEntry_noException()252 public void isSubmittable_nullWifiEntry_noException() { 253 createController(null, WifiConfigUiBase2.MODE_CONNECT, false); 254 mController.isSubmittable(); 255 } 256 257 @Test isSubmittable_EapToPskWithValidPassword_shouldReturnTrue()258 public void isSubmittable_EapToPskWithValidPassword_shouldReturnTrue() { 259 createController(null, WifiConfigUiBase2.MODE_CONNECT, false); 260 final TextView ssid = mView.findViewById(R.id.ssid); 261 final TextView password = mView.findViewById(R.id.password); 262 final Spinner securitySpinner = mView.findViewById(R.id.security); 263 assertThat(password).isNotNull(); 264 assertThat(securitySpinner).isNotNull(); 265 when(mWifiEntry.isSaved()).thenReturn(true); 266 267 // Change it from EAP to PSK 268 mController.onItemSelected(securitySpinner, null, WifiEntry.SECURITY_EAP, 0); 269 mController.onItemSelected(securitySpinner, null, WifiEntry.SECURITY_PSK, 0); 270 password.setText(GOOD_PSK); 271 ssid.setText(GOOD_SSID); 272 273 assertThat(mController.isSubmittable()).isTrue(); 274 } 275 276 @Test isSubmittable_EapWithAkaMethod_shouldReturnTrue()277 public void isSubmittable_EapWithAkaMethod_shouldReturnTrue() { 278 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 279 when(mWifiEntry.isSaved()).thenReturn(true); 280 mController.mWifiEntrySecurity = WifiEntry.SECURITY_EAP; 281 mView.findViewById(R.id.l_ca_cert).setVisibility(View.GONE); 282 283 assertThat(mController.isSubmittable()).isTrue(); 284 } 285 286 @Test isSubmittable_caCertWithoutDomain_shouldReturnFalse()287 public void isSubmittable_caCertWithoutDomain_shouldReturnFalse() { 288 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 289 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 290 mView.findViewById(R.id.l_ca_cert).setVisibility(View.VISIBLE); 291 final Spinner eapCaCertSpinner = mView.findViewById(R.id.ca_cert); 292 eapCaCertSpinner.setAdapter(mController.getSpinnerAdapter(new String[]{"certificate"})); 293 eapCaCertSpinner.setSelection(0); 294 mView.findViewById(R.id.l_domain).setVisibility(View.VISIBLE); 295 296 assertThat(mController.isSubmittable()).isFalse(); 297 } 298 299 @Test isSubmittable_caCertWithDomain_shouldReturnTrue()300 public void isSubmittable_caCertWithDomain_shouldReturnTrue() { 301 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 302 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 303 mView.findViewById(R.id.l_ca_cert).setVisibility(View.VISIBLE); 304 final Spinner eapCaCertSpinner = mView.findViewById(R.id.ca_cert); 305 eapCaCertSpinner.setAdapter(mController.getSpinnerAdapter(new String[]{"certificate"})); 306 eapCaCertSpinner.setSelection(0); 307 mView.findViewById(R.id.l_domain).setVisibility(View.VISIBLE); 308 ((TextView) mView.findViewById(R.id.domain)).setText("fakeDomain"); 309 310 assertThat(mController.isSubmittable()).isTrue(); 311 } 312 313 @Test getSignalString_notReachable_shouldHaveNoSignalString()314 public void getSignalString_notReachable_shouldHaveNoSignalString() { 315 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 316 when(mWifiEntry.getLevel()).thenReturn(WifiEntry.WIFI_LEVEL_UNREACHABLE); 317 318 assertThat(mController.getSignalString()).isNull(); 319 } 320 321 @Test loadCertificates_undesiredCertificates_shouldNotLoadUndesiredCertificates()322 public void loadCertificates_undesiredCertificates_shouldNotLoadUndesiredCertificates() { 323 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 324 final Spinner spinner = new Spinner(mContext); 325 326 mController.loadCertificates(spinner, 327 Arrays.asList(WifiConfigController.UNDESIRED_CERTIFICATES), 328 "doNotProvideEapUserCertString", 329 false /* showMultipleCerts */, 330 false /* showUsePreinstalledCertOption */); 331 332 assertThat(spinner.getAdapter().getCount()).isEqualTo(1); // doNotProvideEapUserCertString 333 } 334 335 @Test ssidGetFocus_addNewNetwork_shouldReturnTrue()336 public void ssidGetFocus_addNewNetwork_shouldReturnTrue() { 337 createController(null, WifiConfigUiBase2.MODE_CONNECT, false); 338 final TextView ssid = mView.findViewById(R.id.ssid); 339 // Verify ssid text get focus when add new network (wifiEntry is null) 340 assertThat(ssid.isFocused()).isTrue(); 341 } 342 343 @Test passwordGetFocus_connectSecureWifi_shouldReturnTrue()344 public void passwordGetFocus_connectSecureWifi_shouldReturnTrue() { 345 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 346 final TextView password = mView.findViewById(R.id.password); 347 // Verify password get focus when connect to secure wifi without eap type 348 assertThat(password.isFocused()).isTrue(); 349 } 350 351 @Test hiddenWarning_warningVisibilityProperlyUpdated()352 public void hiddenWarning_warningVisibilityProperlyUpdated() { 353 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 354 View warningView = mView.findViewById(R.id.hidden_settings_warning); 355 mController.onItemSelected(mHiddenSettingsSpinner, null, mController.HIDDEN_NETWORK, 0); 356 assertThat(warningView.getVisibility()).isEqualTo(View.VISIBLE); 357 358 mController.onItemSelected(mHiddenSettingsSpinner, null, mController.NOT_HIDDEN_NETWORK, 0); 359 assertThat(warningView.getVisibility()).isEqualTo(View.GONE); 360 } 361 362 @Test hiddenField_visibilityUpdatesCorrectly()363 public void hiddenField_visibilityUpdatesCorrectly() { 364 View hiddenField = mView.findViewById(R.id.hidden_settings_field); 365 assertThat(hiddenField.getVisibility()).isEqualTo(View.GONE); 366 367 createController(null, WifiConfigUiBase2.MODE_CONNECT, false); 368 assertThat(hiddenField.getVisibility()).isEqualTo(View.VISIBLE); 369 } 370 371 @Test securitySpinner_saeSuitebAndOweNotVisible()372 public void securitySpinner_saeSuitebAndOweNotVisible() { 373 securitySpinnerTestHelper(false, false, false); 374 } 375 376 @Test securitySpinner_saeSuitebAndOweVisible()377 public void securitySpinner_saeSuitebAndOweVisible() { 378 securitySpinnerTestHelper(true, true, true); 379 } 380 381 @Test securitySpinner_saeVisible_suitebAndOweNotVisible()382 public void securitySpinner_saeVisible_suitebAndOweNotVisible() { 383 securitySpinnerTestHelper(true, false, false); 384 } 385 386 @Test securitySpinner_oweVisible_suitebAndSaeNotVisible()387 public void securitySpinner_oweVisible_suitebAndSaeNotVisible() { 388 securitySpinnerTestHelper(false, false, true); 389 } 390 securitySpinnerTestHelper(boolean saeVisible, boolean suitebVisible, boolean oweVisible)391 private void securitySpinnerTestHelper(boolean saeVisible, boolean suitebVisible, 392 boolean oweVisible) { 393 when(mWifiManager.isWpa3SaeSupported()).thenReturn(saeVisible); 394 when(mWifiManager.isWpa3SuiteBSupported()).thenReturn(suitebVisible); 395 when(mWifiManager.isEnhancedOpenSupported()).thenReturn(oweVisible); 396 397 createController(null, WifiConfigUiBase2.MODE_MODIFY, false); 398 399 final Spinner securitySpinner = mView.findViewById(R.id.security); 400 final ArrayAdapter<String> adapter = (ArrayAdapter) securitySpinner.getAdapter(); 401 boolean saeFound = false; 402 boolean suitebFound = false; 403 boolean oweFound = false; 404 for (int i = 0; i < adapter.getCount(); i++) { 405 String val = adapter.getItem(i); 406 407 if (val.compareTo(mContext.getString( 408 com.android.settingslib.R.string.wifi_security_sae)) == 0) { 409 saeFound = true; 410 } 411 412 if (val.compareTo(mContext.getString( 413 com.android.settingslib.R.string.wifi_security_eap_suiteb)) == 0) { 414 suitebFound = true; 415 } 416 417 if (val.compareTo(mContext.getString( 418 com.android.settingslib.R.string.wifi_security_owe)) == 0) { 419 oweFound = true; 420 } 421 } 422 423 if (saeVisible) { 424 assertThat(saeFound).isTrue(); 425 } else { 426 assertThat(saeFound).isFalse(); 427 } 428 if (suitebVisible) { 429 assertThat(suitebFound).isTrue(); 430 } else { 431 assertThat(suitebFound).isFalse(); 432 } 433 if (oweVisible) { 434 assertThat(oweFound).isTrue(); 435 } else { 436 assertThat(oweFound).isFalse(); 437 } 438 } 439 440 @Test whenHideMeteredAndPrivacy_shouldHideMetered()441 public void whenHideMeteredAndPrivacy_shouldHideMetered() { 442 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, true); 443 444 View view = mView.findViewById(R.id.metered_settings_fields); 445 446 assertThat(view.getVisibility()).isEqualTo(View.GONE); 447 } 448 449 @Test whenHideMeteredAndPrivacy_shouldHidePrivacy()450 public void whenHideMeteredAndPrivacy_shouldHidePrivacy() { 451 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, true); 452 453 View view = mView.findViewById(R.id.privacy_settings_fields); 454 455 assertThat(view.getVisibility()).isEqualTo(View.GONE); 456 } 457 458 @Test loadMacRandomizedValue_shouldPersistentAsDefault()459 public void loadMacRandomizedValue_shouldPersistentAsDefault() { 460 final Spinner privacySetting = mView.findViewById(R.id.privacy_settings); 461 final int prefPersist = 462 WifiPrivacyPreferenceController2.translateMacRandomizedValueToPrefValue( 463 WifiConfiguration.RANDOMIZATION_PERSISTENT); 464 465 assertThat(privacySetting.getVisibility()).isEqualTo(View.VISIBLE); 466 assertThat(privacySetting.getSelectedItemPosition()).isEqualTo(prefPersist); 467 } 468 469 @Test loadSavedMacRandomizedPersistentValue_shouldCorrectMacValue()470 public void loadSavedMacRandomizedPersistentValue_shouldCorrectMacValue() { 471 checkSavedMacRandomizedValue(WifiConfiguration.RANDOMIZATION_PERSISTENT); 472 } 473 474 @Test loadSavedMacRandomizedNoneValue_shouldCorrectMacValue()475 public void loadSavedMacRandomizedNoneValue_shouldCorrectMacValue() { 476 checkSavedMacRandomizedValue(WifiConfiguration.RANDOMIZATION_NONE); 477 } 478 checkSavedMacRandomizedValue(int macRandomizedValue)479 private void checkSavedMacRandomizedValue(int macRandomizedValue) { 480 when(mWifiEntry.isSaved()).thenReturn(true); 481 final WifiConfiguration mockWifiConfig = spy(new WifiConfiguration()); 482 when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class)); 483 when(mWifiEntry.getWifiConfiguration()).thenReturn(mockWifiConfig); 484 mockWifiConfig.macRandomizationSetting = macRandomizedValue; 485 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 486 487 final Spinner privacySetting = mView.findViewById(R.id.privacy_settings); 488 final int expectedPrefValue = 489 WifiPrivacyPreferenceController2.translateMacRandomizedValueToPrefValue( 490 macRandomizedValue); 491 492 assertThat(privacySetting.getVisibility()).isEqualTo(View.VISIBLE); 493 assertThat(privacySetting.getSelectedItemPosition()).isEqualTo(expectedPrefValue); 494 } 495 496 @Test saveMacRandomizedValue_noChanged_shouldPersistentAsDefault()497 public void saveMacRandomizedValue_noChanged_shouldPersistentAsDefault() { 498 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 499 WifiConfiguration config = mController.getConfig(); 500 assertThat(config.macRandomizationSetting).isEqualTo( 501 WifiConfiguration.RANDOMIZATION_PERSISTENT); 502 } 503 504 @Test saveMacRandomizedValue_ChangedToNone_shouldGetNone()505 public void saveMacRandomizedValue_ChangedToNone_shouldGetNone() { 506 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 507 final Spinner privacySetting = mView.findViewById(R.id.privacy_settings); 508 final int prefMacNone = 509 WifiPrivacyPreferenceController2.translateMacRandomizedValueToPrefValue( 510 WifiConfiguration.RANDOMIZATION_NONE); 511 privacySetting.setSelection(prefMacNone); 512 513 WifiConfiguration config = mController.getConfig(); 514 assertThat(config.macRandomizationSetting).isEqualTo(WifiConfiguration.RANDOMIZATION_NONE); 515 } 516 517 @Test loadSavedDhcpValue_true()518 public void loadSavedDhcpValue_true() { 519 checkSavedDhcpValue(true); 520 } 521 522 @Test loadSavedDhcpValue_false()523 public void loadSavedDhcpValue_false() { 524 checkSavedDhcpValue(false); 525 } 526 checkSavedDhcpValue(boolean dhcpValue)527 private void checkSavedDhcpValue(boolean dhcpValue) { 528 when(mWifiEntry.isSaved()).thenReturn(true); 529 final WifiConfiguration mockWifiConfig = mock(WifiConfiguration.class); 530 when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class)); 531 when(mockWifiConfig.isSendDhcpHostnameEnabled()).thenReturn(dhcpValue); 532 when(mWifiEntry.getWifiConfiguration()).thenReturn(mockWifiConfig); 533 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 534 final Spinner dhcpSetting = mView.findViewById(R.id.dhcp_settings); 535 final int expectedPrefValue = 536 WifiPrivacyPreferenceController.Companion 537 .translateSendDhcpHostnameEnabledToPrefValue(dhcpValue); 538 539 assertThat(dhcpSetting.getVisibility()).isEqualTo(View.VISIBLE); 540 assertThat(dhcpSetting.getSelectedItemPosition()).isEqualTo(expectedPrefValue); 541 } 542 543 @Test saveDhcpValue_changedToFalse()544 public void saveDhcpValue_changedToFalse() { 545 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 546 final Spinner privacySetting = mView.findViewById(R.id.dhcp_settings); 547 privacySetting.setSelection(DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE); 548 549 WifiConfiguration config = mController.getConfig(); 550 assertThat(config.isSendDhcpHostnameEnabled()).isEqualTo(false); 551 } 552 553 @Test replaceTtsString_whenTargetMatched_shouldSuccess()554 public void replaceTtsString_whenTargetMatched_shouldSuccess() { 555 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 556 final CharSequence[] display = {"PEAP", "AKA1", "AKA2'"}; 557 final CharSequence[] target = {"AKA1", "AKA2'"}; 558 final CharSequence[] ttsString = {"AKA1_TTS", "AKA2_TTS"}; 559 560 final CharSequence[] resultTts = mController.findAndReplaceTargetStrings(display, target, 561 ttsString); 562 563 assertThat(resultTts[0]).isEqualTo("PEAP"); 564 assertThat(resultTts[1]).isEqualTo("AKA1_TTS"); 565 assertThat(resultTts[2]).isEqualTo("AKA2_TTS"); 566 } 567 568 @Test replaceTtsString_whenNoTargetStringMatched_originalStringShouldNotChanged()569 public void replaceTtsString_whenNoTargetStringMatched_originalStringShouldNotChanged() { 570 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 571 final CharSequence[] display = {"PEAP", "AKA1", "AKA2"}; 572 final CharSequence[] target = {"WEP1", "WEP2'"}; 573 final CharSequence[] ttsString = {"WEP1_TTS", "WEP2_TTS"}; 574 575 final CharSequence[] resultTts = mController.findAndReplaceTargetStrings(display, target, 576 ttsString); 577 578 assertThat(resultTts[0]).isEqualTo("PEAP"); 579 assertThat(resultTts[1]).isEqualTo("AKA1"); 580 assertThat(resultTts[2]).isEqualTo("AKA2"); 581 } 582 583 @Test checktEapMethodTargetAndTtsArraylength_shouldHaveSameCount()584 public void checktEapMethodTargetAndTtsArraylength_shouldHaveSameCount() { 585 final Resources resources = mContext.getResources(); 586 final String[] targetStringArray = resources.getStringArray( 587 R.array.wifi_eap_method_target_strings); 588 final String[] ttsStringArray = resources.getStringArray( 589 R.array.wifi_eap_method_tts_strings); 590 591 assertThat(targetStringArray.length).isEqualTo(ttsStringArray.length); 592 } 593 594 @Test selectSecurity_wpa3Eap192bit_eapMethodTls()595 public void selectSecurity_wpa3Eap192bit_eapMethodTls() { 596 when(mWifiManager.isWpa3SuiteBSupported()).thenReturn(true); 597 createController(null, WifiConfigUiBase2.MODE_MODIFY, false); 598 final Spinner securitySpinner = mView.findViewById(R.id.security); 599 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 600 int wpa3Eap192bitPosition = -1; 601 final int securityCount = mController.mSecurityInPosition.length; 602 for (int i = 0; i < securityCount; i++) { 603 if (mController.mSecurityInPosition[i] != null 604 && mController.mSecurityInPosition[i] == WifiEntry.SECURITY_EAP_SUITE_B) { 605 wpa3Eap192bitPosition = i; 606 } 607 } 608 609 mController.onItemSelected(securitySpinner, /* view */ null, wpa3Eap192bitPosition, 610 /* id */ 0); 611 612 final int selectedItemPosition = eapMethodSpinner.getSelectedItemPosition(); 613 assertThat(eapMethodSpinner.getSelectedItem().toString()).isEqualTo("TLS"); 614 } 615 616 @Test checkImeStatus_whenAdvancedToggled_shouldBeHide()617 public void checkImeStatus_whenAdvancedToggled_shouldBeHide() { 618 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 619 final InputMethodManager inputMethodManager = mContext 620 .getSystemService(InputMethodManager.class); 621 final ShadowInputMethodManager shadowImm = Shadows.shadowOf(inputMethodManager); 622 final CheckBox advButton = mView.findViewById(R.id.wifi_advanced_togglebox); 623 624 inputMethodManager.showSoftInput(null /* view */, 0 /* flags */); 625 advButton.performClick(); 626 627 assertThat(shadowImm.isSoftInputVisible()).isFalse(); 628 } 629 630 @Test selectEapMethod_savedWifiEntry_shouldGetCorrectPosition()631 public void selectEapMethod_savedWifiEntry_shouldGetCorrectPosition() { 632 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 633 setUpModifyingSavedPeapConfigController(); 634 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 635 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 636 WifiConfiguration wifiConfiguration; 637 638 // Test EAP method PEAP 639 eapMethodSpinner.setSelection(Eap.PEAP); 640 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_MSCHAPV2); 641 wifiConfiguration = mController.getConfig(); 642 643 assertThat(wifiConfiguration.enterpriseConfig.getEapMethod()).isEqualTo(Eap.PEAP); 644 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo( 645 Phase2.MSCHAPV2); 646 647 // Test EAP method TTLS 648 eapMethodSpinner.setSelection(Eap.TTLS); 649 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_MSCHAPV2); 650 wifiConfiguration = mController.getConfig(); 651 652 assertThat(wifiConfiguration.enterpriseConfig.getEapMethod()).isEqualTo(Eap.TTLS); 653 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo( 654 Phase2.MSCHAPV2); 655 } 656 657 @Test getHiddenSettingsPosition_whenAdvancedToggled_shouldBeFirst()658 public void getHiddenSettingsPosition_whenAdvancedToggled_shouldBeFirst() { 659 final LinearLayout advancedFieldsLayout = mView.findViewById(R.id.wifi_advanced_fields); 660 final LinearLayout hiddenSettingLayout = mView.findViewById(R.id.hidden_settings_field); 661 662 final LinearLayout firstChild = (LinearLayout) advancedFieldsLayout.getChildAt(0); 663 664 assertThat(firstChild).isEqualTo(hiddenSettingLayout); 665 } 666 667 @Test getAdvancedOptionContentDescription_whenViewInitialed_shouldBeCorrect()668 public void getAdvancedOptionContentDescription_whenViewInitialed_shouldBeCorrect() { 669 final CheckBox advButton = mView.findViewById(R.id.wifi_advanced_togglebox); 670 671 assertThat(advButton.getContentDescription()).isEqualTo( 672 mContext.getString(R.string.wifi_advanced_toggle_description)); 673 } 674 675 @Test getWepConfig_withNumberAndCharacterKey_shouldContainTheSameKey()676 public void getWepConfig_withNumberAndCharacterKey_shouldContainTheSameKey() { 677 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 678 final TextView password = mView.findViewById(R.id.password); 679 password.setText(NUMBER_AND_CHARACTER_KEY); 680 mController.mWifiEntrySecurity = WifiEntry.SECURITY_WEP; 681 682 WifiConfiguration wifiConfiguration = mController.getConfig(); 683 684 assertThat(wifiConfiguration.wepKeys[0]).isEqualTo(NUMBER_AND_CHARACTER_KEY); 685 } 686 687 @Test getWepConfig_withPartialNumberAndCharacterKey_shouldContainDifferentKey()688 public void getWepConfig_withPartialNumberAndCharacterKey_shouldContainDifferentKey() { 689 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 690 final TextView password = mView.findViewById(R.id.password); 691 password.setText(PARTIAL_NUMBER_AND_CHARACTER_KEY); 692 mController.mWifiEntrySecurity = WifiEntry.SECURITY_WEP; 693 694 WifiConfiguration wifiConfiguration = mController.getConfig(); 695 696 assertThat(wifiConfiguration.wepKeys[0]).isNotEqualTo(PARTIAL_NUMBER_AND_CHARACTER_KEY); 697 } 698 699 @Test getPskConfig_withValidHexKey_shouldContainTheSameKey()700 public void getPskConfig_withValidHexKey_shouldContainTheSameKey() { 701 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 702 final TextView password = mView.findViewById(R.id.password); 703 password.setText(VALID_HEX_PSK); 704 mController.mWifiEntrySecurity = WifiEntry.SECURITY_PSK; 705 706 WifiConfiguration wifiConfiguration = mController.getConfig(); 707 708 assertThat(wifiConfiguration.preSharedKey).isEqualTo(VALID_HEX_PSK); 709 } 710 711 @Test getPskConfig_withInvalidHexKey_shouldContainDifferentKey()712 public void getPskConfig_withInvalidHexKey_shouldContainDifferentKey() { 713 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 714 final TextView password = mView.findViewById(R.id.password); 715 password.setText(INVALID_HEX_PSK); 716 mController.mWifiEntrySecurity = WifiEntry.SECURITY_PSK; 717 718 WifiConfiguration wifiConfiguration = mController.getConfig(); 719 720 assertThat(wifiConfiguration.preSharedKey).isNotEqualTo(INVALID_HEX_PSK); 721 } 722 723 @Test getEapConfig_withPhase2Gtc_shouldContainGtcMethod()724 public void getEapConfig_withPhase2Gtc_shouldContainGtcMethod() { 725 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 726 setUpModifyingSavedPeapConfigController(); 727 728 // Test EAP method PEAP 729 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 730 eapMethodSpinner.setSelection(Eap.PEAP); 731 732 // Test phase2 GTC 733 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 734 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_GTC); 735 736 WifiConfiguration wifiConfiguration = mController.getConfig(); 737 738 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.GTC); 739 } 740 741 @Test getEapConfig_withPhase2Sim_shouldContainSimMethod()742 public void getEapConfig_withPhase2Sim_shouldContainSimMethod() { 743 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 744 setUpModifyingSavedPeapConfigController(); 745 746 // Test EAP method PEAP 747 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 748 eapMethodSpinner.setSelection(Eap.PEAP); 749 750 // Test phase2 SIM 751 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 752 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_SIM); 753 754 WifiConfiguration wifiConfiguration = mController.getConfig(); 755 756 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.SIM); 757 } 758 759 @Test getEapConfig_withPhase2Aka_shouldContainAkaMethod()760 public void getEapConfig_withPhase2Aka_shouldContainAkaMethod() { 761 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 762 setUpModifyingSavedPeapConfigController(); 763 764 // Test EAP method PEAP 765 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 766 eapMethodSpinner.setSelection(Eap.PEAP); 767 768 // Test phase2 AKA 769 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 770 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_AKA); 771 772 WifiConfiguration wifiConfiguration = mController.getConfig(); 773 774 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.AKA); 775 } 776 777 @Test getEapConfig_withPhase2AkaPrime_shouldContainAkaPrimeMethod()778 public void getEapConfig_withPhase2AkaPrime_shouldContainAkaPrimeMethod() { 779 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 780 setUpModifyingSavedPeapConfigController(); 781 782 // Test EAP method PEAP 783 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 784 eapMethodSpinner.setSelection(Eap.PEAP); 785 786 // Test phase2 AKA PRIME 787 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 788 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_AKA_PRIME); 789 790 WifiConfiguration wifiConfiguration = mController.getConfig(); 791 792 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo( 793 Phase2.AKA_PRIME); 794 } 795 796 @Test getEapConfig_withPeapPhase2Unknown_shouldContainNoneMethod()797 public void getEapConfig_withPeapPhase2Unknown_shouldContainNoneMethod() { 798 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 799 setUpModifyingSavedPeapConfigController(); 800 801 // Test EAP method PEAP 802 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 803 eapMethodSpinner.setSelection(Eap.PEAP); 804 805 // Test phase2 Unknown 806 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 807 phase2Spinner.setSelection(-1); 808 809 WifiConfiguration wifiConfiguration = mController.getConfig(); 810 811 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.NONE); 812 } 813 814 @Test getEapConfig_withTTLSPhase2Pap_shouldContainPapMethod()815 public void getEapConfig_withTTLSPhase2Pap_shouldContainPapMethod() { 816 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 817 setUpModifyingSavedPeapConfigController(); 818 819 // Test EAP method TTLS 820 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 821 eapMethodSpinner.setSelection(Eap.TTLS); 822 823 // Test phase2 PAP 824 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 825 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_PAP); 826 827 WifiConfiguration wifiConfiguration = mController.getConfig(); 828 829 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.PAP); 830 } 831 832 @Test getEapConfig_withTTLSPhase2Mschap_shouldContainMschapMethod()833 public void getEapConfig_withTTLSPhase2Mschap_shouldContainMschapMethod() { 834 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 835 setUpModifyingSavedPeapConfigController(); 836 837 // Test EAP method TTLS 838 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 839 eapMethodSpinner.setSelection(Eap.TTLS); 840 841 // Test phase2 MSCHAP 842 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 843 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_MSCHAP); 844 845 WifiConfiguration wifiConfiguration = mController.getConfig(); 846 847 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.MSCHAP); 848 } 849 850 @Test getEapConfig_withTTLSPhase2Gtc_shouldContainGtcMethod()851 public void getEapConfig_withTTLSPhase2Gtc_shouldContainGtcMethod() { 852 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 853 setUpModifyingSavedPeapConfigController(); 854 855 // Test EAP method TTLS 856 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 857 eapMethodSpinner.setSelection(Eap.TTLS); 858 859 // Test phase2 GTC 860 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 861 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_GTC); 862 863 WifiConfiguration wifiConfiguration = mController.getConfig(); 864 865 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.GTC); 866 } 867 setUpModifyingSavedPeapConfigController()868 private void setUpModifyingSavedPeapConfigController() { 869 when(mWifiEntry.isSaved()).thenReturn(true); 870 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 871 final WifiConfiguration mockWifiConfig = spy(new WifiConfiguration()); 872 mockWifiConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 873 when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class)); 874 final WifiEnterpriseConfig mockWifiEnterpriseConfig = spy(new WifiEnterpriseConfig()); 875 when(mockWifiEnterpriseConfig.getEapMethod()).thenReturn(Eap.PEAP); 876 mockWifiConfig.enterpriseConfig = mockWifiEnterpriseConfig; 877 when(mWifiEntry.getWifiConfiguration()).thenReturn(mockWifiConfig); 878 createController(mWifiEntry, WifiConfigUiBase2.MODE_MODIFY, false); 879 } 880 881 @Test loadSims_noSim_simSpinnerDefaultNoSim()882 public void loadSims_noSim_simSpinnerDefaultNoSim() { 883 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 884 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 885 mController.mEapMethodSpinner = mEapMethodSimSpinner; 886 887 mController.loadSims(); 888 889 final WifiConfiguration wifiConfiguration = mController.getConfig(); 890 assertThat(wifiConfiguration.carrierId).isEqualTo(TelephonyManager.UNKNOWN_CARRIER_ID); 891 } 892 893 @Test loadSims_oneSim_simSpinnerDefaultSubscription()894 public void loadSims_oneSim_simSpinnerDefaultSubscription() { 895 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 896 final SubscriptionInfo subscriptionInfo = mock(SubscriptionInfo.class); 897 final int carrierId = 6; 898 when(subscriptionInfo.getSubscriptionId()).thenReturn(carrierId); 899 when(subscriptionInfo.getDisplayName()).thenReturn("FAKE-CARRIER"); 900 when(subscriptionInfo.getCarrierId()).thenReturn(carrierId); 901 when(subscriptionInfo.getCarrierName()).thenReturn("FAKE-CARRIER"); 902 SubscriptionUtil.setAvailableSubscriptionsForTesting(Arrays.asList(subscriptionInfo)); 903 mShadowSubscriptionManager.setActiveSubscriptionInfoList(Arrays.asList(subscriptionInfo)); 904 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 905 mController.mEapMethodSpinner = mEapMethodSimSpinner; 906 907 mController.loadSims(); 908 909 final WifiConfiguration wifiConfiguration = mController.getConfig(); 910 assertThat(wifiConfiguration.carrierId).isEqualTo(carrierId); 911 } 912 913 @Test loadSims_twoSimsWithDifferentCarrierId_showTwoSims()914 public void loadSims_twoSimsWithDifferentCarrierId_showTwoSims() { 915 SubscriptionInfo sub1 = createMockSubscription(1, "sub1", 8888); 916 SubscriptionInfo sub2 = createMockSubscription(2, "sub2", 9999); 917 SubscriptionUtil.setAvailableSubscriptionsForTesting(Arrays.asList(sub1, sub2)); 918 mShadowSubscriptionManager.setActiveSubscriptionInfoList(Arrays.asList(sub1, sub2)); 919 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 920 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 921 mController.mEapMethodSpinner = mEapMethodSimSpinner; 922 ShadowSubscriptionManager.setDefaultDataSubscriptionId(1); 923 924 mController.loadSims(); 925 926 assertThat(mController.mEapSimSpinner.getAdapter().getCount()).isEqualTo(2); 927 } 928 929 @Test loadSims_twoSimsWithSameCarrierId_showOneDefaultDataSim()930 public void loadSims_twoSimsWithSameCarrierId_showOneDefaultDataSim() { 931 SubscriptionInfo sub1 = createMockSubscription(1, "sub1", 9999); 932 SubscriptionInfo sub2 = createMockSubscription(2, "sub2", 9999); 933 SubscriptionUtil.setAvailableSubscriptionsForTesting(Arrays.asList(sub1, sub2)); 934 mShadowSubscriptionManager.setActiveSubscriptionInfoList(Arrays.asList(sub1, sub2)); 935 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 936 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 937 mController.mEapMethodSpinner = mEapMethodSimSpinner; 938 ShadowSubscriptionManager.setDefaultDataSubscriptionId(1); 939 940 mController.loadSims(); 941 942 assertThat(mController.mEapSimSpinner.getAdapter().getCount()).isEqualTo(1); 943 assertThat(mController.mEapSimSpinner.getSelectedItem().toString()).isEqualTo("sub1"); 944 945 ShadowSubscriptionManager.setDefaultDataSubscriptionId(2); 946 947 mController.loadSims(); 948 949 assertThat(mController.mEapSimSpinner.getAdapter().getCount()).isEqualTo(1); 950 assertThat(mController.mEapSimSpinner.getSelectedItem().toString()).isEqualTo("sub2"); 951 } 952 953 @Test loadCaCertificateValue_shouldPersistentAsDefault()954 public void loadCaCertificateValue_shouldPersistentAsDefault() { 955 setUpModifyingSavedCertificateConfigController(null, null); 956 957 mEapCaCertSpinner.setSelection(POSITION_SYSTEM_CERT); 958 assertThat(mEapCaCertSpinner.getSelectedItem()).isEqualTo(mUseSystemCertsString); 959 } 960 961 @Test onItemSelected_shouldPersistentInstallCertsAndStartInstallActivity()962 public void onItemSelected_shouldPersistentInstallCertsAndStartInstallActivity() { 963 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 964 String installCertsString = "install_certs"; 965 Spinner eapCaCertSpinner = mock(Spinner.class); 966 AdapterView view = mock(AdapterView.class); 967 when(eapCaCertSpinner.getItemAtPosition(anyInt())).thenReturn(view); 968 when(view.toString()).thenReturn(installCertsString); 969 mController.mInstallCertsString = installCertsString; 970 mController.mEapCaCertSpinner = eapCaCertSpinner; 971 972 mController.onItemSelected(eapCaCertSpinner, null, POSITION_INSTALL_CERT, 0); 973 974 final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class); 975 verify(mContext).startActivity(argumentCaptor.capture()); 976 final Intent intent = argumentCaptor.getValue(); 977 assertThat(intent.getAction()).isEqualTo(ACTION_INSTALL_CERTS); 978 assertThat(intent.getExtra(KEY_INSTALL_CERTIFICATE, "")) 979 .isEqualTo(INSTALL_CERTIFICATE_VALUE); 980 } 981 982 @Test loadSavedCaCertificateValue_shouldBeCorrectValue()983 public void loadSavedCaCertificateValue_shouldBeCorrectValue() { 984 setUpModifyingSavedCertificateConfigController(SAVED_CA_CERT, null); 985 986 assertThat(mEapCaCertSpinner.getSelectedItem()).isEqualTo(SAVED_CA_CERT); 987 } 988 989 @Test loadUserCertificateValue_shouldPersistentAsDefault()990 public void loadUserCertificateValue_shouldPersistentAsDefault() { 991 setUpModifyingSavedCertificateConfigController(null, null); 992 993 assertThat(mEapUserCertSpinner.getSelectedItem()).isEqualTo(mDoNotProvideEapUserCertString); 994 } 995 996 @Test loadSavedUserCertificateValue_shouldBeCorrectValue()997 public void loadSavedUserCertificateValue_shouldBeCorrectValue() { 998 setUpModifyingSavedCertificateConfigController(null, SAVED_USER_CERT); 999 1000 assertThat(mEapUserCertSpinner.getSelectedItem()).isEqualTo(SAVED_USER_CERT); 1001 } 1002 1003 @Test getEapMinTlsVerSpinner_isTlsV13Supported_containsTlsV13()1004 public void getEapMinTlsVerSpinner_isTlsV13Supported_containsTlsV13() { 1005 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 1006 Spinner spinner = mController.getEapMinTlsVerSpinner(true /* isTlsV13Supported */); 1007 1008 List<Object> list = IntStream.range(0, spinner.getAdapter().getCount()) 1009 .mapToObj(spinner.getAdapter()::getItem) 1010 .collect(Collectors.toList()); 1011 assertThat(list).contains(WIFI_EAP_TLS_V1_3); 1012 } 1013 1014 @Test getEapMinTlsVerSpinner_isNotTlsV13Supported_doesNotContainTlsV13()1015 public void getEapMinTlsVerSpinner_isNotTlsV13Supported_doesNotContainTlsV13() { 1016 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 1017 Spinner spinner = mController.getEapMinTlsVerSpinner(false /* isTlsV13Supported */); 1018 1019 List<Object> list = IntStream.range(0, spinner.getAdapter().getCount()) 1020 .mapToObj(spinner.getAdapter()::getItem) 1021 .collect(Collectors.toList()); 1022 assertThat(list).doesNotContain(WIFI_EAP_TLS_V1_3); 1023 } 1024 1025 @Test setAnonymousIdVisible_showAnonymousIdAndSetDefaultId()1026 public void setAnonymousIdVisible_showAnonymousIdAndSetDefaultId() { 1027 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 1028 View anonymousLayout = mView.findViewById(R.id.l_anonymous); 1029 TextView anonymousId = mView.findViewById(R.id.anonymous); 1030 mController.mEapAnonymousView = anonymousId; 1031 anonymousLayout.setVisibility(View.GONE); 1032 anonymousId.setText(""); 1033 1034 mController.setAnonymousIdVisible(); 1035 1036 assertThat(anonymousLayout.getVisibility()).isEqualTo(View.VISIBLE); 1037 assertThat(anonymousId.getText().toString()).isEqualTo(DEFAULT_ANONYMOUS_ID); 1038 } 1039 1040 @Test setAnonymousIdVisible_viewIsVisible_doNotSetText()1041 public void setAnonymousIdVisible_viewIsVisible_doNotSetText() { 1042 createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false); 1043 View anonymousLayout = mView.findViewById(R.id.l_anonymous); 1044 mController.mEapAnonymousView = mock(TextView.class); 1045 anonymousLayout.setVisibility(View.VISIBLE); 1046 1047 mController.setAnonymousIdVisible(); 1048 1049 verify(mController.mEapAnonymousView, never()).setText(any(String.class)); 1050 } 1051 setUpModifyingSavedCertificateConfigController(String savedCaCertificate, String savedUserCertificate)1052 private void setUpModifyingSavedCertificateConfigController(String savedCaCertificate, 1053 String savedUserCertificate) { 1054 final WifiConfiguration mockWifiConfig = spy(new WifiConfiguration()); 1055 final WifiEnterpriseConfig mockWifiEnterpriseConfig = spy(new WifiEnterpriseConfig()); 1056 1057 mockWifiConfig.enterpriseConfig = mockWifiEnterpriseConfig; 1058 when(mWifiEntry.isSaved()).thenReturn(true); 1059 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 1060 when(mWifiEntry.getWifiConfiguration()).thenReturn(mockWifiConfig); 1061 when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class)); 1062 when(mockWifiEnterpriseConfig.getEapMethod()).thenReturn(Eap.TLS); 1063 if (savedCaCertificate != null) { 1064 String[] savedCaCertificates = new String[]{savedCaCertificate}; 1065 when(mockWifiEnterpriseConfig.getCaCertificateAliases()) 1066 .thenReturn(savedCaCertificates); 1067 when(mAndroidKeystoreAliasLoader.getCaCertAliases()) 1068 .thenReturn(ImmutableList.of(savedCaCertificate)); 1069 } 1070 if (savedUserCertificate != null) { 1071 String[] savedUserCertificates = new String[]{savedUserCertificate}; 1072 when(mockWifiEnterpriseConfig.getClientCertificateAlias()) 1073 .thenReturn(savedUserCertificate); 1074 when(mAndroidKeystoreAliasLoader.getKeyCertAliases()) 1075 .thenReturn(ImmutableList.of(savedUserCertificate)); 1076 } 1077 1078 createController(mWifiEntry, WifiConfigUiBase2.MODE_MODIFY, false); 1079 1080 // Because Robolectric has a different behavior from normal flow. 1081 // 1082 // Normal flow: 1083 // showSecurityFields start -> mEapMethodSpinner.setSelection 1084 // -> showSecurityFields end -> mController.onItemSelected 1085 // 1086 // Robolectric flow: 1087 // showSecurityFields start -> mEapMethodSpinner.setSelection 1088 // -> mController.onItemSelected -> showSecurityFields end 1089 // 1090 // We need to add a redundant mEapMethodSpinner.setSelection here to verify whether the 1091 // certificates are covered by mController.onItemSelected after showSecurityFields end. 1092 mController.mEapMethodSpinner.setSelection(Eap.TLS); 1093 } 1094 createMockSubscription(int subId, String displayName, int carrierId)1095 private SubscriptionInfo createMockSubscription(int subId, String displayName, int carrierId) { 1096 SubscriptionInfo sub = mock(SubscriptionInfo.class); 1097 when(sub.getSubscriptionId()).thenReturn(subId); 1098 when(sub.getDisplayName()).thenReturn(displayName); 1099 when(sub.getCarrierId()).thenReturn(carrierId); 1100 return sub; 1101 } 1102 } 1103