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