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