1 /* 2 * Copyright (C) 2010 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.connectivitymanagertest.functional; 18 19 import android.content.Context; 20 import android.net.ConnectivityManager; 21 import android.net.NetworkInfo; 22 import android.net.NetworkInfo.State; 23 import android.net.wifi.WifiManager; 24 import android.os.PowerManager; 25 import android.os.PowerManager.WakeLock; 26 import android.provider.Settings; 27 import android.test.ActivityInstrumentationTestCase2; 28 import android.test.suitebuilder.annotation.LargeTest; 29 import android.util.Log; 30 31 import com.android.connectivitymanagertest.ConnectivityManagerTestActivity; 32 import com.android.connectivitymanagertest.ConnectivityManagerTestRunner; 33 import com.android.connectivitymanagertest.NetworkState; 34 35 public class ConnectivityManagerMobileTest extends 36 ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> { 37 private static final String LOG_TAG = "ConnectivityManagerMobileTest"; 38 39 private String mTestAccessPoint; 40 private ConnectivityManagerTestActivity cmActivity; 41 private WakeLock wl; 42 private boolean mWifiOnlyFlag; 43 44 public ConnectivityManagerMobileTest() { 45 super(ConnectivityManagerTestActivity.class); 46 } 47 48 @Override 49 public void setUp() throws Exception { 50 super.setUp(); 51 cmActivity = getActivity(); 52 ConnectivityManagerTestRunner mRunner = 53 (ConnectivityManagerTestRunner)getInstrumentation(); 54 mTestAccessPoint = mRunner.mTestSsid; 55 mWifiOnlyFlag = mRunner.mWifiOnlyFlag; 56 57 PowerManager pm = (PowerManager)getInstrumentation(). 58 getContext().getSystemService(Context.POWER_SERVICE); 59 wl = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "CMWakeLock"); 60 wl.acquire(); 61 // Each test case will start with cellular connection 62 if (Settings.System.getInt(getInstrumentation().getContext().getContentResolver(), 63 Settings.System.AIRPLANE_MODE_ON) == 1) { 64 log("airplane is not disabled, disable it."); 65 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 66 } 67 68 if (!mWifiOnlyFlag) { 69 if (!cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED, 70 ConnectivityManagerTestActivity.LONG_TIMEOUT)) { 71 // Note: When the test fails in setUp(), tearDown is not called. In that case, 72 // the activity is destroyed which blocks the next test at "getActivity()". 73 // tearDown() is called here to avoid that situation. 74 tearDown(); 75 fail("Device is not connected to Mobile, setUp failed"); 76 } 77 } 78 } 79 80 @Override 81 public void tearDown() throws Exception { 82 cmActivity.finish(); 83 log("tear down ConnectivityManagerTestActivity"); 84 wl.release(); 85 cmActivity.removeConfiguredNetworksAndDisableWifi(); 86 // if airplane mode is set, disable it. 87 if (Settings.System.getInt(getInstrumentation().getContext().getContentResolver(), 88 Settings.System.AIRPLANE_MODE_ON) == 1) { 89 log("disable airplane mode if it is enabled"); 90 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 91 } 92 super.tearDown(); 93 } 94 95 // help function to verify 3G connection 96 public void verifyCellularConnection() { 97 NetworkInfo extraNetInfo = cmActivity.mCM.getActiveNetworkInfo(); 98 assertEquals("network type is not MOBILE", ConnectivityManager.TYPE_MOBILE, 99 extraNetInfo.getType()); 100 assertTrue("not connected to cellular network", extraNetInfo.isConnected()); 101 } 102 103 private void log(String message) { 104 Log.v(LOG_TAG, message); 105 } 106 107 private void sleep(long sleeptime) { 108 try { 109 Thread.sleep(sleeptime); 110 } catch (InterruptedException e) {} 111 } 112 113 // Test case 1: Test enabling Wifi without associating with any AP, no broadcast on network 114 // event should be expected. 115 @LargeTest 116 public void test3GToWifiNotification() { 117 if (mWifiOnlyFlag) { 118 Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test"); 119 return; 120 } 121 // Enable Wi-Fi to avoid initial UNKNOWN state 122 cmActivity.enableWifi(); 123 sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT); 124 125 // Wi-Fi is disabled 126 cmActivity.disableWifi(); 127 128 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, 129 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 130 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 131 State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 132 // Wait for 10 seconds for broadcasts to be sent out 133 sleep(10 * 1000); 134 135 // As Wifi stays in DISCONNETED, Mobile statys in CONNECTED, 136 // the connectivity manager will not broadcast any network connectivity event for Wifi 137 NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 138 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 139 networkInfo.getState(), NetworkState.DO_NOTHING, State.CONNECTED); 140 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 141 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 142 NetworkState.DO_NOTHING, State.DISCONNECTED); 143 // Eanble Wifi without associating with any AP 144 cmActivity.enableWifi(); 145 sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT); 146 147 // validate state and broadcast 148 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 149 log("the state for WIFI is changed"); 150 log("reason: " + 151 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 152 assertTrue("state validation fail", false); 153 } 154 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 155 log("the state for MOBILE is changed"); 156 log("reason: " + 157 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 158 assertTrue("state validation fail", false); 159 } 160 // Verify that the device is still connected to MOBILE 161 verifyCellularConnection(); 162 } 163 164 // Test case 2: test connection to a given AP 165 @LargeTest 166 public void testConnectToWifi() { 167 assertNotNull("SSID is null", mTestAccessPoint); 168 NetworkInfo networkInfo; 169 if (!mWifiOnlyFlag) { 170 //Prepare for connectivity verification 171 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 172 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 173 networkInfo.getState(), NetworkState.TO_DISCONNECTION, State.DISCONNECTED); 174 } 175 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 176 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 177 NetworkState.TO_CONNECTION, State.CONNECTED); 178 179 // Enable Wifi and connect to a test access point 180 assertTrue("failed to connect to " + mTestAccessPoint, 181 cmActivity.connectToWifi(mTestAccessPoint)); 182 183 assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED, 184 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 185 log("wifi state is enabled"); 186 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 187 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 188 if (!mWifiOnlyFlag) { 189 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 190 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 191 } 192 193 // validate states 194 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 195 log("Wifi state transition validation failed."); 196 log("reason: " + 197 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 198 assertTrue(false); 199 } 200 if (!mWifiOnlyFlag) { 201 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 202 log("Mobile state transition validation failed."); 203 log("reason: " + 204 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 205 assertTrue(false); 206 } 207 } 208 } 209 210 // Test case 3: connect to Wifi with known AP 211 @LargeTest 212 public void testConnectToWifWithKnownAP() { 213 assertNotNull("SSID is null", mTestAccessPoint); 214 // Connect to mTestAccessPoint 215 assertTrue("failed to connect to " + mTestAccessPoint, 216 cmActivity.connectToWifi(mTestAccessPoint)); 217 assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED, 218 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 219 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 220 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 221 222 sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 223 // Disable Wifi 224 log("Disable Wifi"); 225 if (!cmActivity.disableWifi()) { 226 log("disable Wifi failed"); 227 return; 228 } 229 230 // Wait for the Wifi state to be DISABLED 231 assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED, 232 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 233 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, 234 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 235 if (!mWifiOnlyFlag) { 236 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 237 State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 238 } 239 240 NetworkInfo networkInfo; 241 if (!mWifiOnlyFlag) { 242 //Prepare for connectivity state verification 243 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 244 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 245 networkInfo.getState(), NetworkState.DO_NOTHING, 246 State.DISCONNECTED); 247 } 248 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 249 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 250 NetworkState.TO_CONNECTION, State.CONNECTED); 251 252 // wait for 2 minutes before restart wifi 253 sleep(ConnectivityManagerTestActivity.WIFI_STOP_START_INTERVAL); 254 // Enable Wifi again 255 log("Enable Wifi again"); 256 cmActivity.enableWifi(); 257 258 // Wait for Wifi to be connected and mobile to be disconnected 259 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 260 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 261 if (!mWifiOnlyFlag) { 262 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 263 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 264 } 265 266 // validate wifi states 267 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 268 log("Wifi state transition validation failed."); 269 log("reason: " + 270 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 271 assertTrue(false); 272 } 273 } 274 275 // Test case 4: test disconnect Wifi 276 @LargeTest 277 public void testDisconnectWifi() { 278 assertNotNull("SSID is null", mTestAccessPoint); 279 280 // connect to Wifi 281 assertTrue("failed to connect to " + mTestAccessPoint, 282 cmActivity.connectToWifi(mTestAccessPoint)); 283 284 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 285 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 286 287 // Wait for a few seconds to avoid the state that both Mobile and Wifi is connected 288 sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 289 290 NetworkInfo networkInfo; 291 if (!mWifiOnlyFlag) { 292 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 293 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 294 networkInfo.getState(), 295 NetworkState.TO_CONNECTION, 296 State.CONNECTED); 297 } 298 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 299 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 300 NetworkState.TO_DISCONNECTION, State.DISCONNECTED); 301 302 // clear Wifi 303 cmActivity.removeConfiguredNetworksAndDisableWifi(); 304 305 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED, 306 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 307 if (!mWifiOnlyFlag) { 308 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 309 State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 310 } 311 312 // validate states 313 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 314 log("Wifi state transition validation failed."); 315 log("reason: " + 316 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 317 assertTrue(false); 318 } 319 if (!mWifiOnlyFlag) { 320 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 321 log("Mobile state transition validation failed."); 322 log("reason: " + 323 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 324 assertTrue(false); 325 } 326 } 327 } 328 329 // Test case 5: test connectivity from 3G to airplane mode, then to 3G again 330 @LargeTest 331 public void testDataConnectionWith3GToAmTo3G() { 332 if (mWifiOnlyFlag) { 333 Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test"); 334 return; 335 } 336 //Prepare for state verification 337 NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 338 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 339 networkInfo.getState(), 340 NetworkState.TO_DISCONNECTION, 341 State.DISCONNECTED); 342 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 343 assertEquals(State.DISCONNECTED, networkInfo.getState()); 344 345 // Enable airplane mode 346 log("Enable airplane mode"); 347 cmActivity.setAirplaneMode(getInstrumentation().getContext(), true); 348 sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 349 350 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 351 assertEquals(State.DISCONNECTED, networkInfo.getState()); 352 // wait until mobile is turn off 353 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 354 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 355 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 356 log("Mobile state transition validation failed."); 357 log("reason: " + 358 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 359 assertTrue(false); 360 } 361 362 // reset state recorder 363 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 364 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 365 networkInfo.getState(), 366 NetworkState.TO_CONNECTION, 367 State.CONNECTED); 368 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 369 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 370 NetworkState.DO_NOTHING, State.DISCONNECTED); 371 372 // disable airplane mode 373 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 374 375 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED, 376 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 377 378 // Validate the state transition 379 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 380 log("Mobile state transition validation failed."); 381 log("reason: " + 382 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 383 assertTrue(false); 384 } 385 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 386 log("Wifi state transition validation failed."); 387 log("reason: " + 388 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 389 assertTrue(false); 390 } 391 } 392 393 // Test case 6: test connectivity with airplane mode Wifi connected 394 @LargeTest 395 public void testDataConnectionOverAMWithWifi() { 396 if (mWifiOnlyFlag) { 397 Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test"); 398 return; 399 } 400 assertNotNull("SSID is null", mTestAccessPoint); 401 // Eanble airplane mode 402 log("Enable airplane mode"); 403 cmActivity.setAirplaneMode(getInstrumentation().getContext(), true); 404 405 NetworkInfo networkInfo; 406 if (!mWifiOnlyFlag) { 407 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 408 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 409 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 410 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 411 networkInfo.getState(), 412 NetworkState.DO_NOTHING, 413 State.DISCONNECTED); 414 } 415 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 416 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 417 NetworkState.TO_CONNECTION, State.CONNECTED); 418 419 // Connect to Wifi 420 assertTrue("failed to connect to " + mTestAccessPoint, 421 cmActivity.connectToWifi(mTestAccessPoint)); 422 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 423 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 424 425 // validate state and broadcast 426 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 427 log("state validate for Wifi failed"); 428 log("reason: " + 429 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 430 assertTrue("State validation failed", false); 431 } 432 if (!mWifiOnlyFlag) { 433 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 434 log("state validation for Mobile failed"); 435 log("reason: " + 436 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 437 assertTrue("state validation failed", false); 438 } 439 } 440 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 441 } 442 443 // Test case 7: test connectivity while transit from Wifi->AM->Wifi 444 @LargeTest 445 public void testDataConnectionWithWifiToAMToWifi () { 446 if (mWifiOnlyFlag) { 447 Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test"); 448 return; 449 } 450 // Connect to mTestAccessPoint 451 assertNotNull("SSID is null", mTestAccessPoint); 452 // Connect to Wifi 453 assertTrue("failed to connect to " + mTestAccessPoint, 454 cmActivity.connectToWifi(mTestAccessPoint)); 455 456 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 457 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 458 459 try { 460 Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 461 } catch (Exception e) { 462 log("exception: " + e.toString()); 463 } 464 465 // Enable airplane mode without clearing Wifi 466 cmActivity.setAirplaneMode(getInstrumentation().getContext(), true); 467 468 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED, 469 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 470 471 try { 472 Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 473 } catch (Exception e) { 474 log("exception: " + e.toString()); 475 } 476 477 // Prepare for state validation 478 NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 479 assertEquals(State.DISCONNECTED, networkInfo.getState()); 480 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, 481 networkInfo.getState(), NetworkState.TO_CONNECTION, State.CONNECTED); 482 483 // Disable airplane mode 484 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 485 486 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 487 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 488 if (!mWifiOnlyFlag) { 489 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 490 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 491 } 492 493 // validate the state transition 494 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 495 log("Wifi state transition validation failed."); 496 log("reason: " + 497 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 498 assertTrue(false); 499 } 500 } 501 502 // Test case 8: test wifi state change while connecting/disconnecting to/from an AP 503 @LargeTest 504 public void testWifiStateChange () { 505 assertNotNull("SSID is null", mTestAccessPoint); 506 //Connect to mTestAccessPoint 507 assertTrue("failed to connect to " + mTestAccessPoint, 508 cmActivity.connectToWifi(mTestAccessPoint)); 509 assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED, 510 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 511 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 512 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 513 assertNotNull("Not associated with any AP", 514 cmActivity.mWifiManager.getConnectionInfo().getBSSID()); 515 516 try { 517 Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 518 } catch (Exception e) { 519 log("exception: " + e.toString()); 520 } 521 522 // Disconnect from the current AP 523 log("disconnect from the AP"); 524 if (!cmActivity.disconnectAP()) { 525 log("failed to disconnect from " + mTestAccessPoint); 526 } 527 528 // Verify the connectivity state for Wifi is DISCONNECTED 529 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED, 530 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 531 532 if (!cmActivity.disableWifi()) { 533 log("disable Wifi failed"); 534 return; 535 } 536 assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED, 537 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 538 } 539 } 540
