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.google.common.truth.Truth.assertThat; 20 21 import static org.mockito.Mockito.anyString; 22 import static org.mockito.Mockito.mock; 23 import static org.mockito.Mockito.when; 24 25 import android.content.Context; 26 import android.content.res.Resources; 27 import android.net.IpConfiguration; 28 import android.net.wifi.WifiConfiguration; 29 import android.net.wifi.WifiEnterpriseConfig; 30 import android.net.wifi.WifiEnterpriseConfig.Eap; 31 import android.net.wifi.WifiEnterpriseConfig.Phase2; 32 import android.net.wifi.WifiManager; 33 import android.os.ServiceSpecificException; 34 import android.security.KeyStore; 35 import android.view.LayoutInflater; 36 import android.view.View; 37 import android.view.inputmethod.InputMethodManager; 38 import android.widget.ArrayAdapter; 39 import android.widget.CheckBox; 40 import android.widget.LinearLayout; 41 import android.widget.Spinner; 42 import android.widget.TextView; 43 44 import com.android.settings.R; 45 import com.android.settings.testutils.shadow.ShadowConnectivityManager; 46 import com.android.settings.wifi.details.WifiPrivacyPreferenceController; 47 import com.android.wifitrackerlib.WifiEntry; 48 49 import org.junit.Before; 50 import org.junit.Test; 51 import org.junit.runner.RunWith; 52 import org.mockito.Mock; 53 import org.mockito.MockitoAnnotations; 54 import org.robolectric.RobolectricTestRunner; 55 import org.robolectric.RuntimeEnvironment; 56 import org.robolectric.Shadows; 57 import org.robolectric.annotation.Config; 58 import org.robolectric.shadows.ShadowInputMethodManager; 59 60 @RunWith(RobolectricTestRunner.class) 61 @Config(shadows = ShadowConnectivityManager.class) 62 public class WifiConfigController2Test { 63 64 @Mock 65 private WifiConfigUiBase2 mConfigUiBase; 66 @Mock 67 private Context mContext; 68 @Mock 69 private WifiEntry mWifiEntry; 70 @Mock 71 private KeyStore mKeyStore; 72 private View mView; 73 private Spinner mHiddenSettingsSpinner; 74 75 public WifiConfigController2 mController; 76 private static final String HEX_PSK = "01234567012345670123456701234567012345670123456701234567" 77 + "01abcdef"; 78 // An invalid ASCII PSK pass phrase. It is 64 characters long, must not be greater than 63 79 private static final String LONG_PSK = 80 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl"; 81 // An invalid PSK pass phrase. It is 7 characters long, must be at least 8 82 private static final String SHORT_PSK = "abcdefg"; 83 // Valid PSK pass phrase 84 private static final String GOOD_PSK = "abcdefghijklmnopqrstuvwxyz"; 85 private static final String GOOD_SSID = "abc"; 86 private static final String VALID_HEX_PSK = 87 "123456789012345678901234567890123456789012345678901234567890abcd"; 88 private static final String INVALID_HEX_PSK = 89 "123456789012345678901234567890123456789012345678901234567890ghij"; 90 private static final String NUMBER_AND_CHARACTER_KEY = "123456abcd"; 91 private static final String PARTIAL_NUMBER_AND_CHARACTER_KEY = "123456abc?"; 92 private static final int DHCP = 0; 93 94 @Before setUp()95 public void setUp() { 96 MockitoAnnotations.initMocks(this); 97 mContext = RuntimeEnvironment.application; 98 when(mConfigUiBase.getContext()).thenReturn(mContext); 99 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_PSK); 100 mView = LayoutInflater.from(mContext).inflate(R.layout.wifi_dialog, null); 101 final Spinner ipSettingsSpinner = mView.findViewById(R.id.ip_settings); 102 mHiddenSettingsSpinner = mView.findViewById(R.id.hidden_settings); 103 ipSettingsSpinner.setSelection(DHCP); 104 105 mController = new TestWifiConfigController2(mConfigUiBase, mView, mWifiEntry, 106 WifiConfigUiBase2.MODE_CONNECT); 107 } 108 109 @Test ssidExceeds32Bytes_shouldShowSsidTooLongWarning()110 public void ssidExceeds32Bytes_shouldShowSsidTooLongWarning() { 111 mController = new TestWifiConfigController2(mConfigUiBase, mView, null /* wifiEntry */, 112 WifiConfigUiBase2.MODE_CONNECT); 113 final TextView ssid = mView.findViewById(R.id.ssid); 114 assertThat(ssid).isNotNull(); 115 ssid.setText("☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎☎"); 116 mController.showWarningMessagesIfAppropriate(); 117 118 assertThat(mView.findViewById(R.id.ssid_too_long_warning).getVisibility()) 119 .isEqualTo(View.VISIBLE); 120 } 121 122 @Test ssidShorterThan32Bytes_shouldNotShowSsidTooLongWarning()123 public void ssidShorterThan32Bytes_shouldNotShowSsidTooLongWarning() { 124 mController = new TestWifiConfigController2(mConfigUiBase, mView, null /* wifiEntry */, 125 WifiConfigUiBase2.MODE_CONNECT); 126 127 final TextView ssid = mView.findViewById(R.id.ssid); 128 assertThat(ssid).isNotNull(); 129 ssid.setText("123456789012345678901234567890"); 130 mController.showWarningMessagesIfAppropriate(); 131 132 assertThat(mView.findViewById(R.id.ssid_too_long_warning).getVisibility()) 133 .isEqualTo(View.GONE); 134 135 ssid.setText("123"); 136 mController.showWarningMessagesIfAppropriate(); 137 138 assertThat(mView.findViewById(R.id.ssid_too_long_warning).getVisibility()) 139 .isEqualTo(View.GONE); 140 } 141 142 @Test isSubmittable_noSSID_shouldReturnFalse()143 public void isSubmittable_noSSID_shouldReturnFalse() { 144 final TextView ssid = mView.findViewById(R.id.ssid); 145 assertThat(ssid).isNotNull(); 146 ssid.setText(""); 147 assertThat(mController.isSubmittable()).isFalse(); 148 } 149 150 @Test isSubmittable_longPsk_shouldReturnFalse()151 public void isSubmittable_longPsk_shouldReturnFalse() { 152 final TextView password = mView.findViewById(R.id.password); 153 assertThat(password).isNotNull(); 154 password.setText(LONG_PSK); 155 assertThat(mController.isSubmittable()).isFalse(); 156 } 157 158 @Test isSubmittable_shortPsk_shouldReturnFalse()159 public void isSubmittable_shortPsk_shouldReturnFalse() { 160 final TextView password = mView.findViewById(R.id.password); 161 assertThat(password).isNotNull(); 162 password.setText(SHORT_PSK); 163 assertThat(mController.isSubmittable()).isFalse(); 164 } 165 166 @Test isSubmittable_goodPsk_shouldReturnTrue()167 public void isSubmittable_goodPsk_shouldReturnTrue() { 168 final TextView password = mView.findViewById(R.id.password); 169 assertThat(password).isNotNull(); 170 password.setText(GOOD_PSK); 171 assertThat(mController.isSubmittable()).isTrue(); 172 } 173 174 @Test isSubmittable_hexPsk_shouldReturnTrue()175 public void isSubmittable_hexPsk_shouldReturnTrue() { 176 final TextView password = mView.findViewById(R.id.password); 177 assertThat(password).isNotNull(); 178 password.setText(HEX_PSK); 179 assertThat(mController.isSubmittable()).isTrue(); 180 } 181 182 @Test isSubmittable_savedConfigZeroLengthPassword_shouldReturnTrue()183 public void isSubmittable_savedConfigZeroLengthPassword_shouldReturnTrue() { 184 final TextView password = mView.findViewById(R.id.password); 185 assertThat(password).isNotNull(); 186 password.setText(""); 187 when(mWifiEntry.isSaved()).thenReturn(true); 188 assertThat(mController.isSubmittable()).isTrue(); 189 } 190 191 @Test isSubmittable_nullWifiEntry_noException()192 public void isSubmittable_nullWifiEntry_noException() { 193 mController = new TestWifiConfigController2(mConfigUiBase, mView, null, 194 WifiConfigUiBase2.MODE_CONNECT); 195 mController.isSubmittable(); 196 } 197 198 @Test isSubmittable_EapToPskWithValidPassword_shouldReturnTrue()199 public void isSubmittable_EapToPskWithValidPassword_shouldReturnTrue() { 200 mController = new TestWifiConfigController2(mConfigUiBase, mView, null, 201 WifiConfigUiBase2.MODE_CONNECT); 202 final TextView ssid = mView.findViewById(R.id.ssid); 203 final TextView password = mView.findViewById(R.id.password); 204 final Spinner securitySpinner = mView.findViewById(R.id.security); 205 assertThat(password).isNotNull(); 206 assertThat(securitySpinner).isNotNull(); 207 when(mWifiEntry.isSaved()).thenReturn(true); 208 209 // Change it from EAP to PSK 210 mController.onItemSelected(securitySpinner, null, WifiEntry.SECURITY_EAP, 0); 211 mController.onItemSelected(securitySpinner, null, WifiEntry.SECURITY_PSK, 0); 212 password.setText(GOOD_PSK); 213 ssid.setText(GOOD_SSID); 214 215 assertThat(mController.isSubmittable()).isTrue(); 216 } 217 218 @Test isSubmittable_EapWithAkaMethod_shouldReturnTrue()219 public void isSubmittable_EapWithAkaMethod_shouldReturnTrue() { 220 when(mWifiEntry.isSaved()).thenReturn(true); 221 mController.mWifiEntrySecurity = WifiEntry.SECURITY_EAP; 222 mView.findViewById(R.id.l_ca_cert).setVisibility(View.GONE); 223 224 assertThat(mController.isSubmittable()).isTrue(); 225 } 226 227 @Test getSignalString_notReachable_shouldHaveNoSignalString()228 public void getSignalString_notReachable_shouldHaveNoSignalString() { 229 when(mWifiEntry.getLevel()).thenReturn(WifiEntry.WIFI_LEVEL_UNREACHABLE); 230 231 assertThat(mController.getSignalString()).isNull(); 232 } 233 234 @Test loadCertificates_keyStoreListFail_shouldNotCrash()235 public void loadCertificates_keyStoreListFail_shouldNotCrash() { 236 // Set up 237 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 238 when(mKeyStore.list(anyString())) 239 .thenThrow(new ServiceSpecificException(-1, "permission error")); 240 241 mController = new TestWifiConfigController2(mConfigUiBase, mView, mWifiEntry, 242 WifiConfigUiBase2.MODE_CONNECT); 243 244 // Verify that the EAP method menu is visible. 245 assertThat(mView.findViewById(R.id.eap).getVisibility()).isEqualTo(View.VISIBLE); 246 // No Crash 247 } 248 249 @Test loadCertificates_undesiredCertificates_shouldNotLoadUndesiredCertificates()250 public void loadCertificates_undesiredCertificates_shouldNotLoadUndesiredCertificates() { 251 final Spinner spinner = new Spinner(mContext); 252 when(mKeyStore.list(anyString())).thenReturn(WifiConfigController.UNDESIRED_CERTIFICATES); 253 254 mController.loadCertificates(spinner, 255 "prefix", 256 "doNotProvideEapUserCertString", 257 false /* showMultipleCerts */, 258 false /* showUsePreinstalledCertOption */); 259 260 assertThat(spinner.getAdapter().getCount()).isEqualTo(1); // doNotProvideEapUserCertString 261 } 262 263 @Test ssidGetFocus_addNewNetwork_shouldReturnTrue()264 public void ssidGetFocus_addNewNetwork_shouldReturnTrue() { 265 mController = new TestWifiConfigController2(mConfigUiBase, mView, null /* wifiEntry */, 266 WifiConfigUiBase2.MODE_CONNECT); 267 final TextView ssid = mView.findViewById(R.id.ssid); 268 // Verify ssid text get focus when add new network (wifiEntry is null) 269 assertThat(ssid.isFocused()).isTrue(); 270 } 271 272 @Test passwordGetFocus_connectSecureWifi_shouldReturnTrue()273 public void passwordGetFocus_connectSecureWifi_shouldReturnTrue() { 274 final TextView password = mView.findViewById(R.id.password); 275 // Verify password get focus when connect to secure wifi without eap type 276 assertThat(password.isFocused()).isTrue(); 277 } 278 279 @Test hiddenWarning_warningVisibilityProperlyUpdated()280 public void hiddenWarning_warningVisibilityProperlyUpdated() { 281 View warningView = mView.findViewById(R.id.hidden_settings_warning); 282 mController.onItemSelected(mHiddenSettingsSpinner, null, mController.HIDDEN_NETWORK, 0); 283 assertThat(warningView.getVisibility()).isEqualTo(View.VISIBLE); 284 285 mController.onItemSelected(mHiddenSettingsSpinner, null, mController.NOT_HIDDEN_NETWORK, 0); 286 assertThat(warningView.getVisibility()).isEqualTo(View.GONE); 287 } 288 289 @Test hiddenField_visibilityUpdatesCorrectly()290 public void hiddenField_visibilityUpdatesCorrectly() { 291 View hiddenField = mView.findViewById(R.id.hidden_settings_field); 292 assertThat(hiddenField.getVisibility()).isEqualTo(View.GONE); 293 294 mController = new TestWifiConfigController2(mConfigUiBase, mView, null /* wifiEntry */, 295 WifiConfigUiBase2.MODE_CONNECT); 296 assertThat(hiddenField.getVisibility()).isEqualTo(View.VISIBLE); 297 } 298 299 @Test securitySpinner_saeSuitebAndOweNotVisible()300 public void securitySpinner_saeSuitebAndOweNotVisible() { 301 securitySpinnerTestHelper(false, false, false); 302 } 303 304 @Test securitySpinner_saeSuitebAndOweVisible()305 public void securitySpinner_saeSuitebAndOweVisible() { 306 securitySpinnerTestHelper(true, true, true); 307 } 308 309 @Test securitySpinner_saeVisible_suitebAndOweNotVisible()310 public void securitySpinner_saeVisible_suitebAndOweNotVisible() { 311 securitySpinnerTestHelper(true, false, false); 312 } 313 314 @Test securitySpinner_oweVisible_suitebAndSaeNotVisible()315 public void securitySpinner_oweVisible_suitebAndSaeNotVisible() { 316 securitySpinnerTestHelper(false, false, true); 317 } 318 securitySpinnerTestHelper(boolean saeVisible, boolean suitebVisible, boolean oweVisible)319 private void securitySpinnerTestHelper(boolean saeVisible, boolean suitebVisible, 320 boolean oweVisible) { 321 WifiManager wifiManager = mock(WifiManager.class); 322 when(wifiManager.isWpa3SaeSupported()).thenReturn(saeVisible); 323 when(wifiManager.isWpa3SuiteBSupported()).thenReturn(suitebVisible); 324 when(wifiManager.isEnhancedOpenSupported()).thenReturn(oweVisible); 325 326 mController = new TestWifiConfigController2(mConfigUiBase, mView, null /* wifiEntry */, 327 WifiConfigUiBase2.MODE_MODIFY, wifiManager); 328 329 final Spinner securitySpinner = mView.findViewById(R.id.security); 330 final ArrayAdapter<String> adapter = (ArrayAdapter) securitySpinner.getAdapter(); 331 boolean saeFound = false; 332 boolean suitebFound = false; 333 boolean oweFound = false; 334 for (int i = 0; i < adapter.getCount(); i++) { 335 String val = adapter.getItem(i); 336 337 if (val.compareTo(mContext.getString(R.string.wifi_security_sae)) == 0) { 338 saeFound = true; 339 } 340 341 if (val.compareTo(mContext.getString(R.string.wifi_security_eap_suiteb)) == 0) { 342 suitebFound = true; 343 } 344 345 if (val.compareTo(mContext.getString(R.string.wifi_security_owe)) == 0) { 346 oweFound = true; 347 } 348 } 349 350 if (saeVisible) { 351 assertThat(saeFound).isTrue(); 352 } else { 353 assertThat(saeFound).isFalse(); 354 } 355 if (suitebVisible) { 356 assertThat(suitebFound).isTrue(); 357 } else { 358 assertThat(suitebFound).isFalse(); 359 } 360 if (oweVisible) { 361 assertThat(oweFound).isTrue(); 362 } else { 363 assertThat(oweFound).isFalse(); 364 } 365 } 366 367 public class TestWifiConfigController2 extends WifiConfigController2 { 368 TestWifiConfigController2( WifiConfigUiBase2 parent, View view, WifiEntry wifiEntry, int mode)369 private TestWifiConfigController2( 370 WifiConfigUiBase2 parent, View view, WifiEntry wifiEntry, int mode) { 371 super(parent, view, wifiEntry, mode); 372 } 373 TestWifiConfigController2( WifiConfigUiBase2 parent, View view, WifiEntry wifiEntry, int mode, WifiManager wifiManager)374 private TestWifiConfigController2( 375 WifiConfigUiBase2 parent, View view, WifiEntry wifiEntry, int mode, 376 WifiManager wifiManager) { 377 super(parent, view, wifiEntry, mode, wifiManager); 378 } 379 380 @Override isSplitSystemUser()381 boolean isSplitSystemUser() { 382 return false; 383 } 384 385 @Override getKeyStore()386 KeyStore getKeyStore() { 387 return mKeyStore; 388 } 389 } 390 391 @Test loadMacRandomizedValue_shouldPersistentAsDefault()392 public void loadMacRandomizedValue_shouldPersistentAsDefault() { 393 final Spinner privacySetting = mView.findViewById(R.id.privacy_settings); 394 final int prefPersist = 395 WifiPrivacyPreferenceController.translateMacRandomizedValueToPrefValue( 396 WifiConfiguration.RANDOMIZATION_PERSISTENT); 397 398 assertThat(privacySetting.getVisibility()).isEqualTo(View.VISIBLE); 399 assertThat(privacySetting.getSelectedItemPosition()).isEqualTo(prefPersist); 400 } 401 402 @Test loadSavedMacRandomizedPersistentValue_shouldCorrectMacValue()403 public void loadSavedMacRandomizedPersistentValue_shouldCorrectMacValue() { 404 checkSavedMacRandomizedValue(WifiConfiguration.RANDOMIZATION_PERSISTENT); 405 } 406 407 @Test loadSavedMacRandomizedNoneValue_shouldCorrectMacValue()408 public void loadSavedMacRandomizedNoneValue_shouldCorrectMacValue() { 409 checkSavedMacRandomizedValue(WifiConfiguration.RANDOMIZATION_NONE); 410 } 411 checkSavedMacRandomizedValue(int macRandomizedValue)412 private void checkSavedMacRandomizedValue(int macRandomizedValue) { 413 when(mWifiEntry.isSaved()).thenReturn(true); 414 final WifiConfiguration mockWifiConfig = mock(WifiConfiguration.class); 415 when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class)); 416 when(mWifiEntry.getWifiConfiguration()).thenReturn(mockWifiConfig); 417 mockWifiConfig.macRandomizationSetting = macRandomizedValue; 418 mController = new TestWifiConfigController2(mConfigUiBase, mView, mWifiEntry, 419 WifiConfigUiBase2.MODE_CONNECT); 420 421 final Spinner privacySetting = mView.findViewById(R.id.privacy_settings); 422 final int expectedPrefValue = 423 WifiPrivacyPreferenceController.translateMacRandomizedValueToPrefValue( 424 macRandomizedValue); 425 426 assertThat(privacySetting.getVisibility()).isEqualTo(View.VISIBLE); 427 assertThat(privacySetting.getSelectedItemPosition()).isEqualTo(expectedPrefValue); 428 } 429 430 @Test saveMacRandomizedValue_noChanged_shouldPersistentAsDefault()431 public void saveMacRandomizedValue_noChanged_shouldPersistentAsDefault() { 432 WifiConfiguration config = mController.getConfig(); 433 assertThat(config.macRandomizationSetting).isEqualTo( 434 WifiConfiguration.RANDOMIZATION_PERSISTENT); 435 } 436 437 @Test saveMacRandomizedValue_ChangedToNone_shouldGetNone()438 public void saveMacRandomizedValue_ChangedToNone_shouldGetNone() { 439 final Spinner privacySetting = mView.findViewById(R.id.privacy_settings); 440 final int prefMacNone = 441 WifiPrivacyPreferenceController.translateMacRandomizedValueToPrefValue( 442 WifiConfiguration.RANDOMIZATION_NONE); 443 privacySetting.setSelection(prefMacNone); 444 445 WifiConfiguration config = mController.getConfig(); 446 assertThat(config.macRandomizationSetting).isEqualTo(WifiConfiguration.RANDOMIZATION_NONE); 447 } 448 449 @Test replaceTtsString_whenTargetMatched_shouldSuccess()450 public void replaceTtsString_whenTargetMatched_shouldSuccess() { 451 final CharSequence[] display = {"PEAP", "AKA1", "AKA2'"}; 452 final CharSequence[] target = {"AKA1", "AKA2'"}; 453 final CharSequence[] ttsString = {"AKA1_TTS", "AKA2_TTS"}; 454 455 final CharSequence[] resultTts = mController.findAndReplaceTargetStrings(display, target, 456 ttsString); 457 458 assertThat(resultTts[0]).isEqualTo("PEAP"); 459 assertThat(resultTts[1]).isEqualTo("AKA1_TTS"); 460 assertThat(resultTts[2]).isEqualTo("AKA2_TTS"); 461 } 462 463 @Test replaceTtsString_whenNoTargetStringMatched_originalStringShouldNotChanged()464 public void replaceTtsString_whenNoTargetStringMatched_originalStringShouldNotChanged() { 465 final CharSequence[] display = {"PEAP", "AKA1", "AKA2"}; 466 final CharSequence[] target = {"WEP1", "WEP2'"}; 467 final CharSequence[] ttsString = {"WEP1_TTS", "WEP2_TTS"}; 468 469 final CharSequence[] resultTts = mController.findAndReplaceTargetStrings(display, target, 470 ttsString); 471 472 assertThat(resultTts[0]).isEqualTo("PEAP"); 473 assertThat(resultTts[1]).isEqualTo("AKA1"); 474 assertThat(resultTts[2]).isEqualTo("AKA2"); 475 } 476 477 @Test checktEapMethodTargetAndTtsArraylength_shouldHaveSameCount()478 public void checktEapMethodTargetAndTtsArraylength_shouldHaveSameCount() { 479 final Resources resources = mContext.getResources(); 480 final String[] targetStringArray = resources.getStringArray( 481 R.array.wifi_eap_method_target_strings); 482 final String[] ttsStringArray = resources.getStringArray( 483 R.array.wifi_eap_method_tts_strings); 484 485 assertThat(targetStringArray.length).isEqualTo(ttsStringArray.length); 486 } 487 488 @Test selectSecurity_wpa3Eap192bit_eapMethodTls()489 public void selectSecurity_wpa3Eap192bit_eapMethodTls() { 490 final WifiManager wifiManager = mock(WifiManager.class); 491 when(wifiManager.isWpa3SuiteBSupported()).thenReturn(true); 492 mController = new TestWifiConfigController2(mConfigUiBase, mView, null /* wifiEntry */, 493 WifiConfigUiBase2.MODE_MODIFY, wifiManager); 494 final Spinner securitySpinner = mView.findViewById(R.id.security); 495 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 496 int wpa3Eap192bitPosition = -1; 497 final int securityCount = mController.mSecurityInPosition.length; 498 for (int i = 0; i < securityCount; i++) { 499 if (mController.mSecurityInPosition[i] != null 500 && mController.mSecurityInPosition[i] == WifiEntry.SECURITY_EAP_SUITE_B) { 501 wpa3Eap192bitPosition = i; 502 } 503 } 504 505 mController.onItemSelected(securitySpinner, /* view */ null, wpa3Eap192bitPosition, 506 /* id */ 0); 507 508 final int selectedItemPosition = eapMethodSpinner.getSelectedItemPosition(); 509 assertThat(eapMethodSpinner.getSelectedItem().toString()).isEqualTo("TLS"); 510 } 511 512 @Test checkImeStatus_whenAdvancedToggled_shouldBeHide()513 public void checkImeStatus_whenAdvancedToggled_shouldBeHide() { 514 final InputMethodManager inputMethodManager = mContext 515 .getSystemService(InputMethodManager.class); 516 final ShadowInputMethodManager shadowImm = Shadows.shadowOf(inputMethodManager); 517 final CheckBox advButton = mView.findViewById(R.id.wifi_advanced_togglebox); 518 519 inputMethodManager.showSoftInput(null /* view */, 0 /* flags */); 520 advButton.performClick(); 521 522 assertThat(shadowImm.isSoftInputVisible()).isFalse(); 523 } 524 525 @Test selectEapMethod_savedWifiEntry_shouldGetCorrectPosition()526 public void selectEapMethod_savedWifiEntry_shouldGetCorrectPosition() { 527 setUpModifyingSavedPeapConfigController(); 528 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 529 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 530 WifiConfiguration wifiConfiguration; 531 532 // Test EAP method PEAP 533 eapMethodSpinner.setSelection(Eap.PEAP); 534 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_MSCHAPV2); 535 wifiConfiguration = mController.getConfig(); 536 537 assertThat(wifiConfiguration.enterpriseConfig.getEapMethod()).isEqualTo(Eap.PEAP); 538 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo( 539 Phase2.MSCHAPV2); 540 541 // Test EAP method TTLS 542 eapMethodSpinner.setSelection(Eap.TTLS); 543 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_MSCHAPV2); 544 wifiConfiguration = mController.getConfig(); 545 546 assertThat(wifiConfiguration.enterpriseConfig.getEapMethod()).isEqualTo(Eap.TTLS); 547 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo( 548 Phase2.MSCHAPV2); 549 } 550 551 @Test getHiddenSettingsPosition_whenAdvancedToggled_shouldBeFirst()552 public void getHiddenSettingsPosition_whenAdvancedToggled_shouldBeFirst() { 553 final LinearLayout advancedFieldsLayout = mView.findViewById(R.id.wifi_advanced_fields); 554 final LinearLayout hiddenSettingLayout = mView.findViewById(R.id.hidden_settings_field); 555 556 final LinearLayout firstChild = (LinearLayout) advancedFieldsLayout.getChildAt(0); 557 558 assertThat(firstChild).isEqualTo(hiddenSettingLayout); 559 } 560 561 @Test getAdvancedOptionContentDescription_whenViewInitialed_shouldBeCorrect()562 public void getAdvancedOptionContentDescription_whenViewInitialed_shouldBeCorrect() { 563 final CheckBox advButton = mView.findViewById(R.id.wifi_advanced_togglebox); 564 565 assertThat(advButton.getContentDescription()).isEqualTo( 566 mContext.getString(R.string.wifi_advanced_toggle_description)); 567 } 568 569 @Test getWepConfig_withNumberAndCharacterKey_shouldContainTheSameKey()570 public void getWepConfig_withNumberAndCharacterKey_shouldContainTheSameKey() { 571 final TextView password = mView.findViewById(R.id.password); 572 password.setText(NUMBER_AND_CHARACTER_KEY); 573 mController.mWifiEntrySecurity = WifiEntry.SECURITY_WEP; 574 575 WifiConfiguration wifiConfiguration = mController.getConfig(); 576 577 assertThat(wifiConfiguration.wepKeys[0]).isEqualTo(NUMBER_AND_CHARACTER_KEY); 578 } 579 580 @Test getWepConfig_withPartialNumberAndCharacterKey_shouldContainDifferentKey()581 public void getWepConfig_withPartialNumberAndCharacterKey_shouldContainDifferentKey() { 582 final TextView password = mView.findViewById(R.id.password); 583 password.setText(PARTIAL_NUMBER_AND_CHARACTER_KEY); 584 mController.mWifiEntrySecurity = WifiEntry.SECURITY_WEP; 585 586 WifiConfiguration wifiConfiguration = mController.getConfig(); 587 588 assertThat(wifiConfiguration.wepKeys[0]).isNotEqualTo(PARTIAL_NUMBER_AND_CHARACTER_KEY); 589 } 590 591 @Test getPskConfig_withValidHexKey_shouldContainTheSameKey()592 public void getPskConfig_withValidHexKey_shouldContainTheSameKey() { 593 final TextView password = mView.findViewById(R.id.password); 594 password.setText(VALID_HEX_PSK); 595 mController.mWifiEntrySecurity = WifiEntry.SECURITY_PSK; 596 597 WifiConfiguration wifiConfiguration = mController.getConfig(); 598 599 assertThat(wifiConfiguration.preSharedKey).isEqualTo(VALID_HEX_PSK); 600 } 601 602 @Test getPskConfig_withInvalidHexKey_shouldContainDifferentKey()603 public void getPskConfig_withInvalidHexKey_shouldContainDifferentKey() { 604 final TextView password = mView.findViewById(R.id.password); 605 password.setText(INVALID_HEX_PSK); 606 mController.mWifiEntrySecurity = WifiEntry.SECURITY_PSK; 607 608 WifiConfiguration wifiConfiguration = mController.getConfig(); 609 610 assertThat(wifiConfiguration.preSharedKey).isNotEqualTo(INVALID_HEX_PSK); 611 } 612 613 @Test getEapConfig_withPhase2Gtc_shouldContainGtcMethod()614 public void getEapConfig_withPhase2Gtc_shouldContainGtcMethod() { 615 setUpModifyingSavedPeapConfigController(); 616 617 // Test EAP method PEAP 618 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 619 eapMethodSpinner.setSelection(Eap.PEAP); 620 621 // Test phase2 GTC 622 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 623 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_GTC); 624 625 WifiConfiguration wifiConfiguration = mController.getConfig(); 626 627 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.GTC); 628 } 629 630 @Test getEapConfig_withPhase2Sim_shouldContainSimMethod()631 public void getEapConfig_withPhase2Sim_shouldContainSimMethod() { 632 setUpModifyingSavedPeapConfigController(); 633 634 // Test EAP method PEAP 635 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 636 eapMethodSpinner.setSelection(Eap.PEAP); 637 638 // Test phase2 SIM 639 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 640 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_SIM); 641 642 WifiConfiguration wifiConfiguration = mController.getConfig(); 643 644 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.SIM); 645 } 646 647 @Test getEapConfig_withPhase2Aka_shouldContainAkaMethod()648 public void getEapConfig_withPhase2Aka_shouldContainAkaMethod() { 649 setUpModifyingSavedPeapConfigController(); 650 651 // Test EAP method PEAP 652 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 653 eapMethodSpinner.setSelection(Eap.PEAP); 654 655 // Test phase2 AKA 656 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 657 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_AKA); 658 659 WifiConfiguration wifiConfiguration = mController.getConfig(); 660 661 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.AKA); 662 } 663 664 @Test getEapConfig_withPhase2AkaPrime_shouldContainAkaPrimeMethod()665 public void getEapConfig_withPhase2AkaPrime_shouldContainAkaPrimeMethod() { 666 setUpModifyingSavedPeapConfigController(); 667 668 // Test EAP method PEAP 669 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 670 eapMethodSpinner.setSelection(Eap.PEAP); 671 672 // Test phase2 AKA PRIME 673 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 674 phase2Spinner.setSelection(WifiConfigController2.WIFI_PEAP_PHASE2_AKA_PRIME); 675 676 WifiConfiguration wifiConfiguration = mController.getConfig(); 677 678 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo( 679 Phase2.AKA_PRIME); 680 } 681 682 683 @Test getEapConfig_withPeapPhase2Unknown_shouldContainNoneMethod()684 public void getEapConfig_withPeapPhase2Unknown_shouldContainNoneMethod() { 685 setUpModifyingSavedPeapConfigController(); 686 687 // Test EAP method PEAP 688 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 689 eapMethodSpinner.setSelection(Eap.PEAP); 690 691 // Test phase2 Unknown 692 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 693 phase2Spinner.setSelection(-1); 694 695 WifiConfiguration wifiConfiguration = mController.getConfig(); 696 697 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.NONE); 698 } 699 700 @Test getEapConfig_withTTLSPhase2Pap_shouldContainPapMethod()701 public void getEapConfig_withTTLSPhase2Pap_shouldContainPapMethod() { 702 setUpModifyingSavedPeapConfigController(); 703 704 // Test EAP method TTLS 705 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 706 eapMethodSpinner.setSelection(Eap.TTLS); 707 708 // Test phase2 PAP 709 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 710 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_PAP); 711 712 WifiConfiguration wifiConfiguration = mController.getConfig(); 713 714 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.PAP); 715 } 716 717 @Test getEapConfig_withTTLSPhase2Mschap_shouldContainMschapMethod()718 public void getEapConfig_withTTLSPhase2Mschap_shouldContainMschapMethod() { 719 setUpModifyingSavedPeapConfigController(); 720 721 // Test EAP method TTLS 722 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 723 eapMethodSpinner.setSelection(Eap.TTLS); 724 725 // Test phase2 MSCHAP 726 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 727 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_MSCHAP); 728 729 WifiConfiguration wifiConfiguration = mController.getConfig(); 730 731 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.MSCHAP); 732 } 733 734 @Test getEapConfig_withTTLSPhase2Gtc_shouldContainGtcMethod()735 public void getEapConfig_withTTLSPhase2Gtc_shouldContainGtcMethod() { 736 setUpModifyingSavedPeapConfigController(); 737 738 // Test EAP method TTLS 739 final Spinner eapMethodSpinner = mView.findViewById(R.id.method); 740 eapMethodSpinner.setSelection(Eap.TTLS); 741 742 // Test phase2 GTC 743 final Spinner phase2Spinner = mView.findViewById(R.id.phase2); 744 phase2Spinner.setSelection(WifiConfigController2.WIFI_TTLS_PHASE2_GTC); 745 746 WifiConfiguration wifiConfiguration = mController.getConfig(); 747 748 assertThat(wifiConfiguration.enterpriseConfig.getPhase2Method()).isEqualTo(Phase2.GTC); 749 } 750 setUpModifyingSavedPeapConfigController()751 private void setUpModifyingSavedPeapConfigController() { 752 when(mWifiEntry.isSaved()).thenReturn(true); 753 when(mWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP); 754 final WifiConfiguration mockWifiConfig = mock(WifiConfiguration.class); 755 when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class)); 756 final WifiEnterpriseConfig mockWifiEnterpriseConfig = mock(WifiEnterpriseConfig.class); 757 when(mockWifiEnterpriseConfig.getEapMethod()).thenReturn(Eap.PEAP); 758 mockWifiConfig.enterpriseConfig = mockWifiEnterpriseConfig; 759 when(mWifiEntry.getWifiConfiguration()).thenReturn(mockWifiConfig); 760 mController = new TestWifiConfigController2(mConfigUiBase, mView, mWifiEntry, 761 WifiConfigUiBase2.MODE_MODIFY); 762 } 763 } 764