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;
34
35public class ConnectivityManagerMobileTest extends
36        ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
37    private static final String LOG_TAG = "ConnectivityManagerMobileTest";
38
39    private String mTestAccessPoint;
40    private ConnectivityManagerTestActivity cmActivity;
41    private WakeLock wl;
42    private boolean mWifiOnlyFlag;
43
44    public ConnectivityManagerMobileTest() {
45        super(ConnectivityManagerTestActivity.class);
46    }
47
48    @Override
49    public void setUp() throws Exception {
50        super.setUp();
51        cmActivity = getActivity();
52        ConnectivityManagerTestRunner mRunner =
53                (ConnectivityManagerTestRunner)getInstrumentation();
54        mTestAccessPoint = mRunner.mTestSsid;
55        mWifiOnlyFlag = mRunner.mWifiOnlyFlag;
56
57        PowerManager pm = (PowerManager)getInstrumentation().
58                getContext().getSystemService(Context.POWER_SERVICE);
59        wl = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "CMWakeLock");
60        wl.acquire();
61        // Each test case will start with cellular connection
62        if (Settings.Global.getInt(getInstrumentation().getContext().getContentResolver(),
63                Settings.Global.AIRPLANE_MODE_ON) == 1) {
64            log("airplane is not disabled, disable it.");
65            cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
66        }
67
68        if (!mWifiOnlyFlag) {
69            if (!cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
70                    ConnectivityManagerTestActivity.LONG_TIMEOUT)) {
71                // Note: When the test fails in setUp(), tearDown is not called. In that case,
72                // the activity is destroyed which blocks the next test at "getActivity()".
73                // tearDown() is called here to avoid that situation.
74                tearDown();
75                fail("Device is not connected to Mobile, setUp failed");
76            }
77        }
78    }
79
80    @Override
81    public void tearDown() throws Exception {
82        cmActivity.finish();
83        log("tear down ConnectivityManagerTestActivity");
84        wl.release();
85        cmActivity.removeConfiguredNetworksAndDisableWifi();
86        // if airplane mode is set, disable it.
87        if (Settings.Global.getInt(getInstrumentation().getContext().getContentResolver(),
88                Settings.Global.AIRPLANE_MODE_ON) == 1) {
89            log("disable airplane mode if it is enabled");
90            cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
91        }
92        super.tearDown();
93    }
94
95    // help function to verify 3G connection
96    public void verifyCellularConnection() {
97        NetworkInfo extraNetInfo = cmActivity.mCM.getActiveNetworkInfo();
98        assertEquals("network type is not MOBILE", ConnectivityManager.TYPE_MOBILE,
99                extraNetInfo.getType());
100        assertTrue("not connected to cellular network", extraNetInfo.isConnected());
101    }
102
103    private void log(String message) {
104        Log.v(LOG_TAG, message);
105    }
106
107    private void sleep(long sleeptime) {
108        try {
109            Thread.sleep(sleeptime);
110        } catch (InterruptedException e) {}
111    }
112
113    // Test case 1: Test enabling Wifi without associating with any AP, no broadcast on network
114    //              event should be expected.
115    @LargeTest
116    public void test3GToWifiNotification() {
117        if (mWifiOnlyFlag) {
118            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
119            return;
120        }
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", mTestAccessPoint);
168        NetworkInfo networkInfo;
169        if (!mWifiOnlyFlag) {
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 " + mTestAccessPoint,
181                cmActivity.connectToWifi(mTestAccessPoint));
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 (!mWifiOnlyFlag) {
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 (!mWifiOnlyFlag) {
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", mTestAccessPoint);
214        // Connect to mTestAccessPoint
215        assertTrue("failed to connect to " + mTestAccessPoint,
216                cmActivity.connectToWifi(mTestAccessPoint));
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 (!mWifiOnlyFlag) {
236            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
237                    State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
238        }
239
240        NetworkInfo networkInfo;
241        if (!mWifiOnlyFlag) {
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 (!mWifiOnlyFlag) {
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", mTestAccessPoint);
279
280        // connect to Wifi
281        assertTrue("failed to connect to " + mTestAccessPoint,
282                   cmActivity.connectToWifi(mTestAccessPoint));
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 (!mWifiOnlyFlag) {
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 (!mWifiOnlyFlag) {
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 (!mWifiOnlyFlag) {
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        if (mWifiOnlyFlag) {
333            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
334            return;
335        }
336        //Prepare for state verification
337        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
338        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
339                                              networkInfo.getState(),
340                                              NetworkState.TO_DISCONNECTION,
341                                              State.DISCONNECTED);
342        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
343        assertEquals(State.DISCONNECTED, networkInfo.getState());
344
345        // Enable airplane mode
346        log("Enable airplane mode");
347        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
348        sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
349
350        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
351        assertEquals(State.DISCONNECTED, networkInfo.getState());
352        // wait until mobile is turn off
353        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
354                State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
355        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
356            log("Mobile state transition validation failed.");
357            log("reason: " +
358                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
359            assertTrue(false);
360        }
361
362        // reset state recorder
363        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
364        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
365                                              networkInfo.getState(),
366                                              NetworkState.TO_CONNECTION,
367                                              State.CONNECTED);
368        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
369        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
370                NetworkState.DO_NOTHING, State.DISCONNECTED);
371
372        // disable airplane mode
373        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
374
375        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
376                ConnectivityManagerTestActivity.LONG_TIMEOUT));
377
378        // Validate the state transition
379        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
380            log("Mobile state transition validation failed.");
381            log("reason: " +
382                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
383            assertTrue(false);
384        }
385        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
386          log("Wifi state transition validation failed.");
387          log("reason: " +
388                  cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
389          assertTrue(false);
390        }
391    }
392
393    // Test case 6: test connectivity with airplane mode Wifi connected
394    @LargeTest
395    public void testDataConnectionOverAMWithWifi() {
396        if (mWifiOnlyFlag) {
397            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
398            return;
399        }
400        assertNotNull("SSID is null", mTestAccessPoint);
401        // Eanble airplane mode
402        log("Enable airplane mode");
403        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
404
405        NetworkInfo networkInfo;
406        if (!mWifiOnlyFlag) {
407            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
408                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
409            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
410            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
411                                                  networkInfo.getState(),
412                                                  NetworkState.DO_NOTHING,
413                                                  State.DISCONNECTED);
414        }
415        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
416        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
417                                              NetworkState.TO_CONNECTION, State.CONNECTED);
418
419        // Connect to Wifi
420        assertTrue("failed to connect to " + mTestAccessPoint,
421                   cmActivity.connectToWifi(mTestAccessPoint));
422        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
423                            ConnectivityManagerTestActivity.LONG_TIMEOUT));
424
425        // validate state and broadcast
426        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
427            log("state validate for Wifi failed");
428            log("reason: " +
429                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
430            assertTrue("State validation failed", false);
431        }
432        if (!mWifiOnlyFlag) {
433            if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
434                log("state validation for Mobile failed");
435                log("reason: " +
436                        cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
437                assertTrue("state validation failed", false);
438            }
439        }
440        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
441    }
442
443    // Test case 7: test connectivity while transit from Wifi->AM->Wifi
444    @LargeTest
445    public void testDataConnectionWithWifiToAMToWifi () {
446        if (mWifiOnlyFlag) {
447            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
448            return;
449        }
450        // Connect to mTestAccessPoint
451        assertNotNull("SSID is null", mTestAccessPoint);
452        // Connect to Wifi
453        assertTrue("failed to connect to " + mTestAccessPoint,
454                cmActivity.connectToWifi(mTestAccessPoint));
455
456        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
457                ConnectivityManagerTestActivity.LONG_TIMEOUT));
458
459        try {
460            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
461        } catch (Exception e) {
462            log("exception: " + e.toString());
463        }
464
465        // Enable airplane mode without clearing Wifi
466        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
467
468        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
469                ConnectivityManagerTestActivity.LONG_TIMEOUT));
470
471        try {
472            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
473        } catch (Exception e) {
474            log("exception: " + e.toString());
475        }
476
477        // Prepare for state validation
478        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
479        assertEquals(State.DISCONNECTED, networkInfo.getState());
480        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI,
481                networkInfo.getState(), NetworkState.TO_CONNECTION, State.CONNECTED);
482
483        // Disable airplane mode
484        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
485
486        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
487                            ConnectivityManagerTestActivity.LONG_TIMEOUT));
488        if (!mWifiOnlyFlag) {
489            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
490                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
491        }
492
493        // validate the state transition
494        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
495            log("Wifi state transition validation failed.");
496            log("reason: " +
497                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
498            assertTrue(false);
499        }
500    }
501
502    // Test case 8: test wifi state change while connecting/disconnecting to/from an AP
503    @LargeTest
504    public void testWifiStateChange () {
505        assertNotNull("SSID is null", mTestAccessPoint);
506        //Connect to mTestAccessPoint
507        assertTrue("failed to connect to " + mTestAccessPoint,
508                   cmActivity.connectToWifi(mTestAccessPoint));
509        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
510                ConnectivityManagerTestActivity.LONG_TIMEOUT));
511        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
512                            ConnectivityManagerTestActivity.LONG_TIMEOUT));
513        assertNotNull("Not associated with any AP",
514                      cmActivity.mWifiManager.getConnectionInfo().getBSSID());
515
516        try {
517            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
518        } catch (Exception e) {
519            log("exception: " + e.toString());
520        }
521
522        // Disconnect from the current AP
523        log("disconnect from the AP");
524        if (!cmActivity.disconnectAP()) {
525            log("failed to disconnect from " + mTestAccessPoint);
526        }
527
528        // Verify the connectivity state for Wifi is DISCONNECTED
529        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
530                ConnectivityManagerTestActivity.LONG_TIMEOUT));
531
532        if (!cmActivity.disableWifi()) {
533            log("disable Wifi failed");
534            return;
535        }
536        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED,
537                ConnectivityManagerTestActivity.LONG_TIMEOUT));
538    }
539}
540