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