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 17package com.android.connectivitymanagertest.functional; 18 19import com.android.connectivitymanagertest.ConnectivityManagerTestActivity; 20import com.android.connectivitymanagertest.UtilHelper; 21 22import android.content.Intent; 23import android.content.Context; 24import android.os.PowerManager; 25import android.os.PowerManager.WakeLock; 26import android.app.Instrumentation; 27import android.os.Handler; 28import android.os.Message; 29import android.provider.Settings; 30import android.net.ConnectivityManager; 31import android.net.NetworkInfo; 32import android.net.NetworkInfo.State; 33import android.net.NetworkInfo.DetailedState; 34import android.net.wifi.WifiManager; 35 36import android.test.suitebuilder.annotation.LargeTest; 37import android.test.ActivityInstrumentationTestCase2; 38import com.android.connectivitymanagertest.ConnectivityManagerTestRunner; 39import com.android.connectivitymanagertest.NetworkState; 40import android.util.Log; 41 42public class ConnectivityManagerMobileTest 43 extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> { 44 private static final String LOG_TAG = "ConnectivityManagerMobileTest"; 45 private static final String PKG_NAME = "com.android.connectivitymanagertest"; 46 47 private String TEST_ACCESS_POINT; 48 private ConnectivityManagerTestActivity cmActivity; 49 private WakeLock wl; 50 51 public ConnectivityManagerMobileTest() { 52 super(ConnectivityManagerTestActivity.class); 53 } 54 55 @Override 56 public void setUp() throws Exception { 57 super.setUp(); 58 cmActivity = getActivity(); 59 ConnectivityManagerTestRunner mRunner = 60 (ConnectivityManagerTestRunner)getInstrumentation(); 61 TEST_ACCESS_POINT = mRunner.TEST_SSID; 62 PowerManager pm = (PowerManager)getInstrumentation(). 63 getContext().getSystemService(Context.POWER_SERVICE); 64 wl = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "CMWakeLock"); 65 wl.acquire(); 66 // Each test case will start with cellular connection 67 if (Settings.System.getInt(getInstrumentation().getContext().getContentResolver(), 68 Settings.System.AIRPLANE_MODE_ON) == 1) { 69 log("airplane is not disabled, disable it."); 70 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 71 } 72 if (!UtilHelper.isWifiOnly()) { 73 if (!cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED, 74 ConnectivityManagerTestActivity.LONG_TIMEOUT)) { 75 // Note: When the test fails in setUp(), tearDown is not called. In that case, 76 // the activity is destroyed which blocks the next test at "getActivity()". 77 // tearDown() is called here to avoid that situation. 78 tearDown(); 79 fail("Device is not connected to Mobile, setUp failed"); 80 } 81 } 82 } 83 84 @Override 85 public void tearDown() throws Exception { 86 cmActivity.finish(); 87 log("tear down ConnectivityManagerTestActivity"); 88 wl.release(); 89 cmActivity.removeConfiguredNetworksAndDisableWifi(); 90 // if airplane mode is set, disable it. 91 if (Settings.System.getInt(getInstrumentation().getContext().getContentResolver(), 92 Settings.System.AIRPLANE_MODE_ON) == 1) { 93 log("disable airplane mode if it is enabled"); 94 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 95 } 96 super.tearDown(); 97 } 98 99 // help function to verify 3G connection 100 public void verifyCellularConnection() { 101 NetworkInfo extraNetInfo = cmActivity.mCM.getActiveNetworkInfo(); 102 assertEquals("network type is not MOBILE", ConnectivityManager.TYPE_MOBILE, 103 extraNetInfo.getType()); 104 assertTrue("not connected to cellular network", extraNetInfo.isConnected()); 105 } 106 107 private void log(String message) { 108 Log.v(LOG_TAG, message); 109 } 110 111 private void sleep(long sleeptime) { 112 try { 113 Thread.sleep(sleeptime); 114 } catch (InterruptedException e) {} 115 } 116 117 // Test case 1: Test enabling Wifi without associating with any AP, no broadcast on network 118 // event should be expected. 119 @LargeTest 120 public void test3GToWifiNotification() { 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", TEST_ACCESS_POINT); 168 NetworkInfo networkInfo; 169 if (!UtilHelper.isWifiOnly()) { 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 " + TEST_ACCESS_POINT, 181 cmActivity.connectToWifi(TEST_ACCESS_POINT)); 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 (!UtilHelper.isWifiOnly()) { 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 (!UtilHelper.isWifiOnly()) { 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", TEST_ACCESS_POINT); 214 // Connect to TEST_ACCESS_POINT 215 assertTrue("failed to connect to " + TEST_ACCESS_POINT, 216 cmActivity.connectToWifi(TEST_ACCESS_POINT)); 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 (!UtilHelper.isWifiOnly()) { 236 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 237 State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 238 } 239 240 NetworkInfo networkInfo; 241 if (!UtilHelper.isWifiOnly()) { 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 (!UtilHelper.isWifiOnly()) { 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", TEST_ACCESS_POINT); 279 280 // connect to Wifi 281 assertTrue("failed to connect to " + TEST_ACCESS_POINT, 282 cmActivity.connectToWifi(TEST_ACCESS_POINT)); 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 (!UtilHelper.isWifiOnly()) { 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 (!UtilHelper.isWifiOnly()) { 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 (!UtilHelper.isWifiOnly()) { 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 //Prepare for state verification 333 NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 334 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 335 networkInfo.getState(), 336 NetworkState.TO_DISCONNECTION, 337 State.DISCONNECTED); 338 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 339 assertEquals(State.DISCONNECTED, networkInfo.getState()); 340 341 // Enable airplane mode 342 log("Enable airplane mode"); 343 cmActivity.setAirplaneMode(getInstrumentation().getContext(), true); 344 sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 345 346 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 347 assertEquals(State.DISCONNECTED, networkInfo.getState()); 348 349 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 350 log("Mobile state transition validation failed."); 351 log("reason: " + 352 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 353 assertTrue(false); 354 } 355 356 // reset state recorder 357 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 358 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 359 networkInfo.getState(), 360 NetworkState.TO_CONNECTION, 361 State.CONNECTED); 362 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 363 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 364 NetworkState.DO_NOTHING, State.DISCONNECTED); 365 366 // disable airplane mode 367 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 368 369 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED, 370 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 371 372 // Validate the state transition 373 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 374 log("Mobile state transition validation failed."); 375 log("reason: " + 376 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 377 assertTrue(false); 378 } 379 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 380 log("Wifi state transition validation failed."); 381 log("reason: " + 382 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 383 assertTrue(false); 384 } 385 } 386 387 // Test case 6: test connectivity with airplane mode Wifi connected 388 @LargeTest 389 public void testDataConnectionOverAMWithWifi() { 390 assertNotNull("SSID is null", TEST_ACCESS_POINT); 391 // Eanble airplane mode 392 log("Enable airplane mode"); 393 cmActivity.setAirplaneMode(getInstrumentation().getContext(), true); 394 395 NetworkInfo networkInfo; 396 if (!UtilHelper.isWifiOnly()) { 397 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 398 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 399 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 400 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, 401 networkInfo.getState(), 402 NetworkState.DO_NOTHING, 403 State.DISCONNECTED); 404 } 405 networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 406 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(), 407 NetworkState.TO_CONNECTION, State.CONNECTED); 408 409 // Connect to Wifi 410 assertTrue("failed to connect to " + TEST_ACCESS_POINT, 411 cmActivity.connectToWifi(TEST_ACCESS_POINT)); 412 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 413 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 414 415 // validate state and broadcast 416 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 417 log("state validate for Wifi failed"); 418 log("reason: " + 419 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 420 assertTrue("State validation failed", false); 421 } 422 if (!UtilHelper.isWifiOnly()) { 423 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) { 424 log("state validation for Mobile failed"); 425 log("reason: " + 426 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE)); 427 assertTrue("state validation failed", false); 428 } 429 } 430 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 431 } 432 433 // Test case 7: test connectivity while transit from Wifi->AM->Wifi 434 @LargeTest 435 public void testDataConnectionWithWifiToAMToWifi () { 436 // Connect to TEST_ACCESS_POINT 437 assertNotNull("SSID is null", TEST_ACCESS_POINT); 438 // Connect to Wifi 439 assertTrue("failed to connect to " + TEST_ACCESS_POINT, 440 cmActivity.connectToWifi(TEST_ACCESS_POINT)); 441 442 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 443 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 444 445 try { 446 Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 447 } catch (Exception e) { 448 log("exception: " + e.toString()); 449 } 450 451 // Enable airplane mode without clearing Wifi 452 cmActivity.setAirplaneMode(getInstrumentation().getContext(), true); 453 454 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED, 455 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 456 457 try { 458 Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 459 } catch (Exception e) { 460 log("exception: " + e.toString()); 461 } 462 463 // Prepare for state validation 464 NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 465 assertEquals(State.DISCONNECTED, networkInfo.getState()); 466 cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, 467 networkInfo.getState(), NetworkState.TO_CONNECTION, State.CONNECTED); 468 469 // Disable airplane mode 470 cmActivity.setAirplaneMode(getInstrumentation().getContext(), false); 471 472 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 473 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 474 if (!UtilHelper.isWifiOnly()) { 475 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, 476 State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT)); 477 } 478 479 // validate the state transition 480 if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) { 481 log("Wifi state transition validation failed."); 482 log("reason: " + 483 cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI)); 484 assertTrue(false); 485 } 486 } 487 488 // Test case 8: test wifi state change while connecting/disconnecting to/from an AP 489 @LargeTest 490 public void testWifiStateChange () { 491 assertNotNull("SSID is null", TEST_ACCESS_POINT); 492 //Connect to TEST_ACCESS_POINT 493 assertTrue("failed to connect to " + TEST_ACCESS_POINT, 494 cmActivity.connectToWifi(TEST_ACCESS_POINT)); 495 assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED, 496 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 497 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 498 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 499 assertNotNull("Not associated with any AP", 500 cmActivity.mWifiManager.getConnectionInfo().getBSSID()); 501 502 try { 503 Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT); 504 } catch (Exception e) { 505 log("exception: " + e.toString()); 506 } 507 508 // Disconnect from the current AP 509 log("disconnect from the AP"); 510 if (!cmActivity.disconnectAP()) { 511 log("failed to disconnect from " + TEST_ACCESS_POINT); 512 } 513 514 // Verify the connectivity state for Wifi is DISCONNECTED 515 assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED, 516 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 517 518 if (!cmActivity.disableWifi()) { 519 log("disable Wifi failed"); 520 return; 521 } 522 assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED, 523 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 524 } 525} 526