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