frameworks/base/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/ConnectivityManagerMobileTest.java

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