ConnectivityManagerMobileTest.java revision ca1f2b1a1e8cb785be5ebbcf7ded7c921cbf80a7 
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.net.ConnectivityManager;
29import android.net.NetworkInfo;
30import android.net.NetworkInfo.State;
31import android.net.NetworkInfo.DetailedState;
32import android.net.wifi.WifiManager;
33
34import android.test.suitebuilder.annotation.LargeTest;
35import android.test.ActivityInstrumentationTestCase2;
36import com.android.connectivitymanagertest.ConnectivityManagerTestRunner;
37import com.android.connectivitymanagertest.NetworkState;
38import android.util.Log;
39
40public 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}
488