ConnectivityManagerMobileTest.java revision b97435c94f4d35a70d63e5dcba5415b0110cf2c9 
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.v(LOG_TAG, "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.v(LOG_TAG, "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.v(LOG_TAG, "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    // Test case 1: Test enabling Wifi without associating with any AP
108    @LargeTest
109    public void test3GToWifiNotification() {
110        cmActivity.enableWifi();
111        try {
112            Thread.sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
113        } catch (Exception e) {
114            Log.v(LOG_TAG, "exception: " + e.toString());
115        }
116
117        cmActivity.disableWifi();
118
119        cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI,
120                State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT);
121        // As Wifi stays in DISCONNETED, the connectivity manager will not broadcast
122        // any network connectivity event for Wifi
123        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
124        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
125                networkInfo.getState(), NetworkState.DO_NOTHING, State.CONNECTED);
126        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
127        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
128                NetworkState.DO_NOTHING, State.DISCONNECTED);
129        // Eanble Wifi
130        cmActivity.enableWifi();
131        try {
132            Thread.sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
133        } catch (Exception e) {
134            Log.v(LOG_TAG, "exception: " + e.toString());
135        }
136
137        // validate state and broadcast
138        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
139            Log.v(LOG_TAG, "the state for WIFI is changed");
140            Log.v(LOG_TAG, "reason: " +
141                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
142            assertTrue("state validation fail", false);
143        }
144        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
145            Log.v(LOG_TAG, "the state for MOBILE is changed");
146            Log.v(LOG_TAG, "reason: " +
147                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
148            assertTrue("state validation fail", false);
149        }
150        // Verify that the device is still connected to MOBILE
151        verifyCellularConnection();
152    }
153
154    // Test case 2: test connection to a given AP
155    @LargeTest
156    public void testConnectToWifi() {
157        assertNotNull("SSID is null", TEST_ACCESS_POINT);
158        NetworkInfo networkInfo;
159        if (!UtilHelper.isWifiOnly()) {
160            //Prepare for connectivity verification
161            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
162            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
163                    networkInfo.getState(), NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
164        }
165        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
166        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
167                NetworkState.TO_CONNECTION, State.CONNECTED);
168
169        // Enable Wifi and connect to a test access point
170        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
171                cmActivity.connectToWifi(TEST_ACCESS_POINT));
172
173        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
174                ConnectivityManagerTestActivity.LONG_TIMEOUT));
175        Log.v(LOG_TAG, "wifi state is enabled");
176        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
177                ConnectivityManagerTestActivity.LONG_TIMEOUT));
178        if (!UtilHelper.isWifiOnly()) {
179            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
180                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
181        }
182
183        // validate states
184        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
185            Log.v(LOG_TAG, "Wifi state transition validation failed.");
186            Log.v(LOG_TAG, "reason: " +
187                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
188            assertTrue(false);
189        }
190        if (!UtilHelper.isWifiOnly()) {
191            if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
192                Log.v(LOG_TAG, "Mobile state transition validation failed.");
193                Log.v(LOG_TAG, "reason: " +
194                        cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
195                assertTrue(false);
196            }
197        }
198    }
199
200    // Test case 3: connect to Wifi with known AP
201    @LargeTest
202    public void testConnectToWifWithKnownAP() {
203        assertNotNull("SSID is null", TEST_ACCESS_POINT);
204        // Connect to TEST_ACCESS_POINT
205        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
206                cmActivity.connectToWifi(TEST_ACCESS_POINT));
207        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
208                ConnectivityManagerTestActivity.LONG_TIMEOUT));
209        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
210                ConnectivityManagerTestActivity.LONG_TIMEOUT));
211
212        try {
213            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
214        } catch (Exception e) {
215            Log.v(LOG_TAG, "exception: " + e.toString());
216        }
217
218        // Disable Wifi
219        Log.v(LOG_TAG, "Disable Wifi");
220        if (!cmActivity.disableWifi()) {
221            Log.v(LOG_TAG, "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 (!UtilHelper.isWifiOnly()) {
231            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
232                    State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
233        }
234
235        NetworkInfo networkInfo;
236        if (!UtilHelper.isWifiOnly()) {
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        // Enable Wifi again
248        Log.v(LOG_TAG, "Enable Wifi again");
249        cmActivity.enableWifi();
250
251        // Wait for Wifi to be connected and mobile to be disconnected
252        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
253                ConnectivityManagerTestActivity.LONG_TIMEOUT));
254        if (!UtilHelper.isWifiOnly()) {
255            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
256                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
257        }
258
259        // validate wifi states
260        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
261            Log.v(LOG_TAG, "Wifi state transition validation failed.");
262            Log.v(LOG_TAG, "reason: " +
263                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
264            assertTrue(false);
265        }
266    }
267
268    // Test case 4:  test disconnect Wifi
269    @LargeTest
270    public void testDisconnectWifi() {
271        assertNotNull("SSID is null", TEST_ACCESS_POINT);
272
273        // connect to Wifi
274        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
275                   cmActivity.connectToWifi(TEST_ACCESS_POINT));
276
277        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
278            ConnectivityManagerTestActivity.LONG_TIMEOUT));
279
280        // Wait for a few seconds to avoid the state that both Mobile and Wifi is connected
281        try {
282            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
283        } catch (Exception e) {
284            Log.v(LOG_TAG, "exception: " + e.toString());
285        }
286
287        NetworkInfo networkInfo;
288        if (!UtilHelper.isWifiOnly()) {
289            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
290            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
291                                                  networkInfo.getState(),
292                                                  NetworkState.TO_CONNECTION,
293                                                  State.CONNECTED);
294        }
295        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
296        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
297                NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
298
299        // clear Wifi
300        cmActivity.removeConfiguredNetworksAndDisableWifi();
301
302        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
303                ConnectivityManagerTestActivity.LONG_TIMEOUT));
304        if (!UtilHelper.isWifiOnly()) {
305            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
306                    State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
307        }
308
309        // validate states
310        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
311            Log.v(LOG_TAG, "Wifi state transition validation failed.");
312            Log.v(LOG_TAG, "reason: " +
313                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
314            assertTrue(false);
315        }
316        if (!UtilHelper.isWifiOnly()) {
317            if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
318                Log.v(LOG_TAG, "Mobile state transition validation failed.");
319                Log.v(LOG_TAG, "reason: " +
320                        cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
321                assertTrue(false);
322            }
323        }
324    }
325
326    // Test case 5: test connectivity from 3G to airplane mode, then to 3G again
327    @LargeTest
328    public void testDataConnectionWith3GToAmTo3G() {
329        //Prepare for state verification
330        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
331        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
332                                              networkInfo.getState(),
333                                              NetworkState.TO_DISCONNECTION,
334                                              State.DISCONNECTED);
335        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
336        assertEquals(State.DISCONNECTED, networkInfo.getState());
337
338        // Enable airplane mode
339        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
340        try {
341            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
342        } catch (Exception e) {
343            Log.v(LOG_TAG, "exception: " + e.toString());
344        }
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.v(LOG_TAG, "Mobile state transition validation failed.");
351            Log.v(LOG_TAG, "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.v(LOG_TAG, "Mobile state transition validation failed.");
375            Log.v(LOG_TAG, "reason: " +
376                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
377            assertTrue(false);
378        }
379        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
380          Log.v(LOG_TAG, "Wifi state transition validation failed.");
381          Log.v(LOG_TAG, "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        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
393
394        NetworkInfo networkInfo;
395        if (!UtilHelper.isWifiOnly()) {
396            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
397                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
398            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
399            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
400                                                  networkInfo.getState(),
401                                                  NetworkState.DO_NOTHING,
402                                                  State.DISCONNECTED);
403        }
404        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
405        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
406                                              NetworkState.TO_CONNECTION, State.CONNECTED);
407
408        // Connect to Wifi
409        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
410                   cmActivity.connectToWifi(TEST_ACCESS_POINT));
411        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
412                            ConnectivityManagerTestActivity.LONG_TIMEOUT));
413
414        // validate state and broadcast
415        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
416            Log.v(LOG_TAG, "state validate for Wifi failed");
417            Log.v(LOG_TAG, "reason: " +
418                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
419            assertTrue("State validation failed", false);
420        }
421        if (!UtilHelper.isWifiOnly()) {
422            if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
423                Log.v(LOG_TAG, "state validation for Mobile failed");
424                Log.v(LOG_TAG, "reason: " +
425                        cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
426                assertTrue("state validation failed", false);
427            }
428        }
429        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
430    }
431
432    // Test case 7: test connectivity while transit from Wifi->AM->Wifi
433    @LargeTest
434    public void testDataConnectionWithWifiToAMToWifi () {
435        // Connect to TEST_ACCESS_POINT
436        assertNotNull("SSID is null", TEST_ACCESS_POINT);
437        // Connect to Wifi
438        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
439                cmActivity.connectToWifi(TEST_ACCESS_POINT));
440
441        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
442                ConnectivityManagerTestActivity.LONG_TIMEOUT));
443
444        try {
445            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
446        } catch (Exception e) {
447            Log.v(LOG_TAG, "exception: " + e.toString());
448        }
449
450        // Enable airplane mode without clearing Wifi
451        cmActivity.setAirplaneMode(getInstrumentation().getContext(), true);
452
453        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
454                ConnectivityManagerTestActivity.LONG_TIMEOUT));
455
456        try {
457            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
458        } catch (Exception e) {
459            Log.v(LOG_TAG, "exception: " + e.toString());
460        }
461
462        // Prepare for state validation
463        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
464        assertEquals(State.DISCONNECTED, networkInfo.getState());
465        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI,
466                networkInfo.getState(), NetworkState.TO_CONNECTION, State.CONNECTED);
467
468        // Disable airplane mode
469        cmActivity.setAirplaneMode(getInstrumentation().getContext(), false);
470
471        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
472                            ConnectivityManagerTestActivity.LONG_TIMEOUT));
473        if (!UtilHelper.isWifiOnly()) {
474            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
475                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
476        }
477
478        // validate the state transition
479        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
480            Log.v(LOG_TAG, "Wifi state transition validation failed.");
481            Log.v(LOG_TAG, "reason: " +
482                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
483            assertTrue(false);
484        }
485    }
486
487    // Test case 8: test wifi state change while connecting/disconnecting to/from an AP
488    @LargeTest
489    public void testWifiStateChange () {
490        assertNotNull("SSID is null", TEST_ACCESS_POINT);
491        //Connect to TEST_ACCESS_POINT
492        assertTrue("failed to connect to " + TEST_ACCESS_POINT,
493                   cmActivity.connectToWifi(TEST_ACCESS_POINT));
494        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
495                ConnectivityManagerTestActivity.LONG_TIMEOUT));
496        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
497                            ConnectivityManagerTestActivity.LONG_TIMEOUT));
498        assertNotNull("Not associated with any AP",
499                      cmActivity.mWifiManager.getConnectionInfo().getBSSID());
500
501        try {
502            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
503        } catch (Exception e) {
504            Log.v(LOG_TAG, "exception: " + e.toString());
505        }
506
507        // Disconnect from the current AP
508        Log.v(LOG_TAG, "disconnect from the AP");
509        if (!cmActivity.disconnectAP()) {
510            Log.v(LOG_TAG, "failed to disconnect from " + TEST_ACCESS_POINT);
511        }
512
513        // Verify the connectivity state for Wifi is DISCONNECTED
514        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
515                ConnectivityManagerTestActivity.LONG_TIMEOUT));
516
517        if (!cmActivity.disableWifi()) {
518            Log.v(LOG_TAG, "disable Wifi failed");
519            return;
520        }
521        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED,
522                ConnectivityManagerTestActivity.LONG_TIMEOUT));
523    }
524}
525