ConnectivityManagerMobileTest.java revision 8efaeb03ea1ecd633f61bdb03bb90393887f08df 
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;
20
21import android.content.Intent;
22import android.content.Context;
23import android.os.PowerManager;
24import android.os.PowerManager.WakeLock;
25import android.app.Instrumentation;
26import android.os.Handler;
27import android.os.Message;
28import android.provider.Settings;
29import android.net.ConnectivityManager;
30import android.net.NetworkInfo;
31import android.net.NetworkInfo.State;
32import android.net.NetworkInfo.DetailedState;
33import android.net.wifi.WifiManager;
34
35import android.test.suitebuilder.annotation.LargeTest;
36import android.test.ActivityInstrumentationTestCase2;
37import com.android.connectivitymanagertest.ConnectivityManagerTestRunner;
38import com.android.connectivitymanagertest.NetworkState;
39import android.util.Log;
40
41public class ConnectivityManagerMobileTest
42    extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
43    private static final String LOG_TAG = "ConnectivityManagerMobileTest";
44    private static final String PKG_NAME = "com.android.connectivitymanagertest";
45
46    private String TEST_ACCESS_POINT;
47    private ConnectivityManagerTestActivity cmActivity;
48    private WakeLock wl;
49
50    public ConnectivityManagerMobileTest() {
51        super(PKG_NAME, ConnectivityManagerTestActivity.class);
52    }
53
54    @Override
55    public void setUp() throws Exception {
56        super.setUp();
57        cmActivity = getActivity();
58        ConnectivityManagerTestRunner mRunner =
59                (ConnectivityManagerTestRunner)getInstrumentation();
60        TEST_ACCESS_POINT = mRunner.TEST_SSID;
61        PowerManager pm = (PowerManager)getInstrumentation().
62                getContext().getSystemService(Context.POWER_SERVICE);
63        wl = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "CMWakeLock");
64        wl.acquire();
65        // Each test case will start with cellular connection
66        if (!cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
67                ConnectivityManagerTestActivity.LONG_TIMEOUT)) {
68            // Note: When the test fails in setUp(), tearDown is not called. In that case,
69            // the activity is destroyed which blocks the next test at "getActivity()".
70            // tearDown() is called hear to avoid that situation.
71            tearDown();
72            fail("Device is not connected to Mobile, setUp failed");
73        }
74    }
75
76    @Override
77    public void tearDown() throws Exception {
78        cmActivity.finish();
79        Log.v(LOG_TAG, "tear down ConnectivityManagerTestActivity");
80        wl.release();
81        cmActivity.removeConfiguredNetworksAndDisableWifi();
82        // if airplane mode is set, disable it.
83        if (Settings.System.getInt(getInstrumentation().getContext().getContentResolver(),
84                Settings.System.AIRPLANE_MODE_ON) == 1) {
85            cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
86        }
87        super.tearDown();
88    }
89
90    // help function to verify 3G connection
91    public void verifyCellularConnection() {
92        NetworkInfo extraNetInfo = cmActivity.mCM.getActiveNetworkInfo();
93        assertEquals("network type is not MOBILE", ConnectivityManager.TYPE_MOBILE,
94                extraNetInfo.getType());
95        assertTrue("not connected to cellular network", extraNetInfo.isConnected());
96        assertTrue("no data connection", cmActivity.mState.equals(State.CONNECTED));
97    }
98
99    // Test case 1: Test enabling Wifi without associating with any AP
100    @LargeTest
101    public void test3GToWifiNotification() {
102        // To avoid UNKNOWN state when device boots up
103        cmActivity.enableWifi();
104        try {
105            Thread.sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
106        } catch (Exception e) {
107            Log.v(LOG_TAG, "exception: " + e.toString());
108        }
109
110        cmActivity.disableWifi();
111        // As Wifi stays in DISCONNECTED, the connectivity manager will not broadcast
112        // any network connectivity event for Wifi
113        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
114        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, networkInfo.getState(),
115                NetworkState.DO_NOTHING, State.CONNECTED);
116        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
117        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
118                NetworkState.DO_NOTHING, State.DISCONNECTED);
119        // Eanble Wifi
120        cmActivity.enableWifi();
121        try {
122            Thread.sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
123        } catch (Exception e) {
124            Log.v(LOG_TAG, "exception: " + e.toString());
125        }
126
127        // validate state and broadcast
128        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
129            Log.v(LOG_TAG, "the state for WIFI is changed");
130            Log.v(LOG_TAG, "reason: " +
131                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
132            assertTrue("state validation fail", false);
133        }
134        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
135            Log.v(LOG_TAG, "the state for MOBILE is changed");
136            Log.v(LOG_TAG, "reason: " +
137                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
138            assertTrue("state validation fail", false);
139        }
140        // Verify that the device is still connected to MOBILE
141        verifyCellularConnection();
142    }
143
144    // Test case 2: test connection to a given AP
145    @LargeTest
146    public void testConnectToWifi() {
147        assertNotNull("SSID is null", TEST_ACCESS_POINT);
148        //Prepare for connectivity verification
149        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
150        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE, networkInfo.getState(),
151                NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
152        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
153        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
154                NetworkState.TO_CONNECTION, State.CONNECTED);
155
156        // Enable Wifi and connect to a test access point
157        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
158                cmActivity.connectToWifi(TEST_ACCESS_POINT));
159
160        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
161                ConnectivityManagerTestActivity.LONG_TIMEOUT));
162        Log.v(LOG_TAG, "wifi state is enabled");
163        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
164                ConnectivityManagerTestActivity.LONG_TIMEOUT));
165        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.DISCONNECTED,
166                ConnectivityManagerTestActivity.LONG_TIMEOUT));
167
168        // validate states
169        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
170            Log.v(LOG_TAG, "Wifi state transition validation failed.");
171            Log.v(LOG_TAG, "reason: " +
172                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
173            assertTrue(false);
174        }
175        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
176            Log.v(LOG_TAG, "Mobile state transition validation failed.");
177            Log.v(LOG_TAG, "reason: " +
178                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
179            assertTrue(false);
180        }
181    }
182
183    // Test case 3: connect to Wifi with known AP
184    @LargeTest
185    public void testConnectToWifWithKnownAP() {
186        assertNotNull("SSID is null", TEST_ACCESS_POINT);
187        // Connect to TEST_ACCESS_POINT
188        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
189                cmActivity.connectToWifi(TEST_ACCESS_POINT));
190        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
191                ConnectivityManagerTestActivity.LONG_TIMEOUT));
192        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
193                ConnectivityManagerTestActivity.LONG_TIMEOUT));
194
195        try {
196            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
197        } catch (Exception e) {
198            Log.v(LOG_TAG, "exception: " + e.toString());
199        }
200
201        // Disable Wifi
202        Log.v(LOG_TAG, "Disable Wifi");
203        if (!cmActivity.disableWifi()) {
204            Log.v(LOG_TAG, "disable Wifi failed");
205            return;
206        }
207
208        // Wait for the Wifi state to be DISABLED
209        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED,
210                ConnectivityManagerTestActivity.LONG_TIMEOUT));
211        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
212                ConnectivityManagerTestActivity.LONG_TIMEOUT));
213        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
214                ConnectivityManagerTestActivity.LONG_TIMEOUT));
215
216        //Prepare for connectivity state verification
217        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
218        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
219                                              networkInfo.getState(), NetworkState.DO_NOTHING,
220                                              State.DISCONNECTED);
221        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
222        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
223                NetworkState.TO_CONNECTION, State.CONNECTED);
224
225        // Enable Wifi again
226        Log.v(LOG_TAG, "Enable Wifi again");
227        cmActivity.enableWifi();
228
229        // Wait for Wifi to be connected and mobile to be disconnected
230        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
231                ConnectivityManagerTestActivity.LONG_TIMEOUT));
232        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.DISCONNECTED,
233                ConnectivityManagerTestActivity.LONG_TIMEOUT));
234
235        // validate wifi states
236        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
237            Log.v(LOG_TAG, "Wifi state transition validation failed.");
238            Log.v(LOG_TAG, "reason: " +
239                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
240            assertTrue(false);
241        }
242    }
243
244    // Test case 4:  test disconnect Wifi
245    @LargeTest
246    public void testDisconnectWifi() {
247        assertNotNull("SSID is null", TEST_ACCESS_POINT);
248
249        // connect to Wifi
250        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
251                   cmActivity.connectToWifi(TEST_ACCESS_POINT));
252
253        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
254            ConnectivityManagerTestActivity.LONG_TIMEOUT));
255
256        // Wait for a few seconds to avoid the state that both Mobile and Wifi is connected
257        try {
258            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
259        } catch (Exception e) {
260            Log.v(LOG_TAG, "exception: " + e.toString());
261        }
262
263        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
264        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
265                                              networkInfo.getState(),
266                                              NetworkState.TO_CONNECTION,
267                                              State.CONNECTED);
268        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
269        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
270                NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
271
272        // clear Wifi
273        cmActivity.removeConfiguredNetworksAndDisableWifi();
274
275        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
276                ConnectivityManagerTestActivity.LONG_TIMEOUT));
277        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
278                ConnectivityManagerTestActivity.LONG_TIMEOUT));
279
280        // validate states
281        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
282            Log.v(LOG_TAG, "Wifi state transition validation failed.");
283            Log.v(LOG_TAG, "reason: " +
284                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
285            assertTrue(false);
286        }
287        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
288            Log.v(LOG_TAG, "Mobile state transition validation failed.");
289            Log.v(LOG_TAG, "reason: " +
290                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
291            assertTrue(false);
292        }
293    }
294
295    // Test case 5: test connectivity from 3G to airplane mode, then to 3G again
296    @LargeTest
297    public void testDataConnectionWith3GToAmTo3G() {
298        //Prepare for state verification
299        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
300        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
301                                              networkInfo.getState(),
302                                              NetworkState.TO_DISCONNECTION,
303                                              State.DISCONNECTED);
304        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
305        assertEquals(State.DISCONNECTED, networkInfo.getState());
306
307        // Enable airplane mode
308        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
309        try {
310            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
311        } catch (Exception e) {
312            Log.v(LOG_TAG, "exception: " + e.toString());
313        }
314
315        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
316        assertEquals(State.DISCONNECTED, networkInfo.getState());
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}
488