Update the Connectivity Manager test suit to use InstrumentationTestCase.

- Remove ConnectivityManagerTestActivity as the test activity could be destroyed
  after a system config change, which cause test failure in the wifi stress test.
- Update all tests to use InstrumentationTestCase, which instruments the test package.

Bug : 10426067

Change-Id: Ibf6f1f7cffd7a7eabc4cc63c7e033b59274b724e

11 files changed, 277 insertions, 430 deletions

diff --git a/core/tests/ConnectivityManagerTest/AndroidManifest.xml b/core/tests/ConnectivityManagerTest/AndroidManifest.xml
index b76c8be..1649268 100644
--- a/core/tests/ConnectivityManagerTest/AndroidManifest.xml
+++ b/core/tests/ConnectivityManagerTest/AndroidManifest.xml
@@ -23,13 +23,6 @@
          which is needed when building test cases. -->
     <application>
         <uses-library android:name="android.test.runner" />
-        <activity android:name="ConnectivityManagerTestActivity"
-          android:label="@string/app_name">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
     </application>
 
     <!--
@@ -87,4 +80,6 @@
     <uses-permission android:name="android.permission.INTERACT_ACROSS_USERS_FULL" />
     <uses-permission android:name="android.permission.INTERACT_ACROSS_USERS" />
     <uses-permission android:name="android.permission.INJECT_EVENTS" />
+    <uses-permission android:name="android.permission.DEVICE_POWER" />
+
 </manifest>
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/AccessPointParserHelper.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/AccessPointParserHelper.java
index 0461c0b..b942eb6 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/AccessPointParserHelper.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/AccessPointParserHelper.java
@@ -32,13 +32,11 @@ import android.net.wifi.WifiEnterpriseConfig;
 import android.net.LinkAddress;
 import android.net.LinkProperties;
 import android.net.RouteInfo;
-import android.util.Log;
 
 import java.io.InputStream;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 
 
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestActivity.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestBase.java
index a0cb1bb..30eda75 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestActivity.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestBase.java
@@ -16,7 +16,7 @@
 
 package com.android.connectivitymanagertest;
 
-import android.app.Activity;
+import android.app.KeyguardManager;
 import android.content.Context;
 import android.content.BroadcastReceiver;
 import android.content.Intent;
@@ -26,21 +26,14 @@ import android.net.NetworkInfo;
 import android.net.NetworkInfo.State;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
-import android.net.wifi.WifiInfo;
-import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration.KeyMgmt;
-import android.os.Bundle;
 import android.os.Handler;
-import android.os.IPowerManager;
 import android.os.Message;
 import android.os.PowerManager;
-import android.os.ServiceManager;
 import android.os.SystemClock;
-import android.os.UserHandle;
-import android.provider.Settings;
+import android.test.InstrumentationTestCase;
 import android.util.Log;
 import android.view.KeyEvent;
-import android.widget.LinearLayout;
 
 import com.android.internal.util.AsyncChannel;
 
@@ -52,13 +45,17 @@ import java.util.List;
 
 
 /**
- * An activity registered with connectivity manager broadcast
- * provides network connectivity information and
- * can be used to set device states: Cellular, Wifi, Airplane mode.
+ * Base InstrumentationTestCase for Connectivity Manager (CM) test suite
+ *
+ * It registers connectivity manager broadcast and WiFi broadcast to provide
+ * network connectivity information, also provides a set of utility functions
+ * to modify and verify connectivity states.
+ *
+ * A CM test case should extend this base class.
  */
-public class ConnectivityManagerTestActivity extends Activity {
+public class ConnectivityManagerTestBase extends InstrumentationTestCase {
 
-    public static final String LOG_TAG = "ConnectivityManagerTestActivity";
+    public static final String LOG_TAG = "ConnectivityManagerTestBase";
     public static final int WAIT_FOR_SCAN_RESULT = 10 * 1000; //10 seconds
     public static final int WIFI_SCAN_TIMEOUT = 50 * 1000; // 50 seconds
     public static final int SHORT_TIMEOUT = 5 * 1000; // 5 seconds
@@ -94,14 +91,9 @@ public class ConnectivityManagerTestActivity extends Activity {
     private Context mContext;
     public boolean scanResultAvailable = false;
 
-    /*
-     * Control Wifi States
-     */
+    /* Control Wifi States */
     public WifiManager mWifiManager;
-
-    /*
-     * Verify connectivity state
-     */
+    /* Verify connectivity state */
     public static final int NUM_NETWORK_TYPES = ConnectivityManager.MAX_NETWORK_TYPE + 1;
     NetworkState[] connectivityState = new NetworkState[NUM_NETWORK_TYPES];
 
@@ -208,26 +200,28 @@ public class ConnectivityManagerTestActivity extends Activity {
         }
     }
 
-    public ConnectivityManagerTestActivity() {
+    @Override
+    public void setUp() throws Exception {
         mState = State.UNKNOWN;
         scanResultAvailable = false;
-    }
+        mContext = getInstrumentation().getContext();
 
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        log("onCreate, inst=" + Integer.toHexString(hashCode()));
+        // Get an instance of ConnectivityManager
+        mCM = (ConnectivityManager)mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
+        // Get an instance of WifiManager
+        mWifiManager =(WifiManager)mContext.getSystemService(Context.WIFI_SERVICE);
 
-        // Create a simple layout
-        LinearLayout contentView = new LinearLayout(this);
-        contentView.setOrientation(LinearLayout.VERTICAL);
-        setContentView(contentView);
-        setTitle("ConnectivityManagerTestActivity");
+        if (mWifiManager.isWifiApEnabled()) {
+            // if soft AP is enabled, disable it
+            mWifiManager.setWifiApEnabled(null, false);
+            log("Disable soft ap");
+        }
 
+        initializeNetworkStates();
 
         // register a connectivity receiver for CONNECTIVITY_ACTION;
         mConnectivityReceiver = new ConnectivityReceiver();
-        registerReceiver(mConnectivityReceiver,
+        mContext.registerReceiver(mConnectivityReceiver,
                 new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
 
         mWifiReceiver = new WifiReceiver();
@@ -238,28 +232,15 @@ public class ConnectivityManagerTestActivity extends Activity {
         mIntentFilter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
         mIntentFilter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION);
         mIntentFilter.addAction(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
-        registerReceiver(mWifiReceiver, mIntentFilter);
+        mContext.registerReceiver(mWifiReceiver, mIntentFilter);
 
-        // Get an instance of ConnectivityManager
-        mCM = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
-        // Get an instance of WifiManager
-        mWifiManager =(WifiManager)getSystemService(Context.WIFI_SERVICE);
-        mContext = this;
-
-        if (mWifiManager.isWifiApEnabled()) {
-            // if soft AP is enabled, disable it
-            mWifiManager.setWifiApEnabled(null, false);
-            log("Disable soft ap");
-        }
-
-        initializeNetworkStates();
         log("Clear Wifi before we start the test.");
         removeConfiguredNetworksAndDisableWifi();
         mWifiRegexs = mCM.getTetherableWifiRegexs();
      }
 
     public List<WifiConfiguration> loadNetworkConfigurations() throws Exception {
-        InputStream in = getAssets().open(ACCESS_POINT_FILE);
+        InputStream in = mContext.getAssets().open(ACCESS_POINT_FILE);
         mParseHelper = new AccessPointParserHelper(in);
         return mParseHelper.getNetworkConfigurations();
     }
@@ -277,6 +258,12 @@ public class ConnectivityManagerTestActivity extends Activity {
     public void recordNetworkState(int networkType, State networkState) {
         log("record network state for network " +  networkType +
                 ", state is " + networkState);
+        if (connectivityState == null) {
+             log("ConnectivityState is null");
+        }
+        if (connectivityState[networkType] == null) {
+             log("connectivityState[networkType] is null");
+        }
         connectivityState[networkType].recordState(networkState);
     }
 
@@ -503,7 +490,7 @@ public class ConnectivityManagerTestActivity extends Activity {
     public void turnScreenOff() {
         log("Turn screen off");
         PowerManager pm =
-            (PowerManager) getSystemService(Context.POWER_SERVICE);
+            (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
         pm.goToSleep(SystemClock.uptimeMillis());
     }
 
@@ -511,8 +498,13 @@ public class ConnectivityManagerTestActivity extends Activity {
     public void turnScreenOn() {
         log("Turn screen on");
         PowerManager pm =
-                (PowerManager) getSystemService(Context.POWER_SERVICE);
+                (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
         pm.wakeUp(SystemClock.uptimeMillis());
+        // disable lock screen
+        KeyguardManager km = (KeyguardManager) mContext.getSystemService(Context.KEYGUARD_SERVICE);
+        if (km.inKeyguardRestrictedInputMode()) {
+            sendKeys(KeyEvent.KEYCODE_MENU);
+        }
     }
 
     /**
@@ -607,7 +599,12 @@ public class ConnectivityManagerTestActivity extends Activity {
             mWifiManager.setWifiEnabled(true);
             sleep(SHORT_TIMEOUT);
         }
+
         List<WifiConfiguration> wifiConfigList = mWifiManager.getConfiguredNetworks();
+        if (wifiConfigList == null) {
+            log("no configuration list is null");
+            return true;
+        }
         log("size of wifiConfigList: " + wifiConfigList.size());
         for (WifiConfiguration wifiConfig: wifiConfigList) {
             log("remove wifi configuration: " + wifiConfig.networkId);
@@ -656,57 +653,15 @@ public class ConnectivityManagerTestActivity extends Activity {
     }
 
     @Override
-    protected void onDestroy() {
-        super.onDestroy();
-
+    public void tearDown() throws Exception{
         //Unregister receiver
         if (mConnectivityReceiver != null) {
-            unregisterReceiver(mConnectivityReceiver);
+          mContext.unregisterReceiver(mConnectivityReceiver);
         }
         if (mWifiReceiver != null) {
-            unregisterReceiver(mWifiReceiver);
-        }
-        log("onDestroy, inst=" + Integer.toHexString(hashCode()));
-    }
-
-    @Override
-    public void onStart() {
-        super.onStart();
-        mContext = this;
-        Bundle bundle = this.getIntent().getExtras();
-        if (bundle != null){
-            mPowerSsid = bundle.getString("power_ssid");
-        }
-    }
-    //A thread to set the device into airplane mode then turn on wifi.
-    Thread setDeviceWifiAndAirplaneThread = new Thread(new Runnable() {
-        public void run() {
-            mCM.setAirplaneMode(true);
-            connectToWifi(mPowerSsid);
-        }
-    });
-
-    //A thread to set the device into wifi
-    Thread setDeviceInWifiOnlyThread = new Thread(new Runnable() {
-        public void run() {
-            connectToWifi(mPowerSsid);
-        }
-    });
-
-    @Override
-    public boolean onKeyDown(int keyCode, KeyEvent event) {
-        switch (keyCode) {
-            //This is a tricky way for the scripted monkey to
-            //set the device in wifi and wifi in airplane mode.
-            case KeyEvent.KEYCODE_1:
-                setDeviceWifiAndAirplaneThread.start();
-                break;
-
-            case KeyEvent.KEYCODE_2:
-                setDeviceInWifiOnlyThread.start();
-                break;
+          mContext.unregisterReceiver(mWifiReceiver);
         }
-        return super.onKeyDown(keyCode, event);
+        super.tearDown();
     }
 
     private void log(String message) {
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerUnitTestRunner.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerUnitTestRunner.java
index 3a78f26..0e57a00 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerUnitTestRunner.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerUnitTestRunner.java
@@ -16,10 +16,8 @@
 
 package com.android.connectivitymanagertest;
 
-import android.os.Bundle;
 import android.test.InstrumentationTestRunner;
 import android.test.InstrumentationTestSuite;
-import android.util.Log;
 import com.android.connectivitymanagertest.unit.WifiClientTest;
 import com.android.connectivitymanagertest.unit.WifiSoftAPTest;
 
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/ConnectivityManagerMobileTest.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/ConnectivityManagerMobileTest.java
index 729e1d2..05462b4 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/ConnectivityManagerMobileTest.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/ConnectivityManagerMobileTest.java
@@ -24,31 +24,24 @@ import android.net.wifi.WifiManager;
 import android.os.PowerManager;
 import android.os.PowerManager.WakeLock;
 import android.provider.Settings;
-import android.test.ActivityInstrumentationTestCase2;
 import android.test.suitebuilder.annotation.LargeTest;
 import android.util.Log;
 
-import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
+import com.android.connectivitymanagertest.ConnectivityManagerTestBase;
 import com.android.connectivitymanagertest.ConnectivityManagerTestRunner;
 import com.android.connectivitymanagertest.NetworkState;
 
 public class ConnectivityManagerMobileTest extends
-        ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
-    private static final String LOG_TAG = "ConnectivityManagerMobileTest";
+        ConnectivityManagerTestBase {
+    private static final String TAG = "ConnectivityManagerMobileTest";
 
     private String mTestAccessPoint;
-    private ConnectivityManagerTestActivity cmActivity;
     private WakeLock wl;
     private boolean mWifiOnlyFlag;
 
-    public ConnectivityManagerMobileTest() {
-        super(ConnectivityManagerTestActivity.class);
-    }
-
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        cmActivity = getActivity();
         ConnectivityManagerTestRunner mRunner =
                 (ConnectivityManagerTestRunner)getInstrumentation();
         mTestAccessPoint = mRunner.mTestSsid;
@@ -62,12 +55,12 @@ public class ConnectivityManagerMobileTest extends
         if (Settings.Global.getInt(getInstrumentation().getContext().getContentResolver(),
                 Settings.Global.AIRPLANE_MODE_ON) == 1) {
             log("airplane is not disabled, disable it.");
-            cmActivity.mCM.setAirplaneMode(false);
+            mCM.setAirplaneMode(false);
         }
 
         if (!mWifiOnlyFlag) {
-            if (!cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
-                    ConnectivityManagerTestActivity.LONG_TIMEOUT)) {
+            if (!waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                    State.CONNECTED, LONG_TIMEOUT)) {
                 // Note: When the test fails in setUp(), tearDown is not called. In that case,
                 // the activity is destroyed which blocks the next test at "getActivity()".
                 // tearDown() is called here to avoid that situation.
@@ -79,29 +72,22 @@ public class ConnectivityManagerMobileTest extends
 
     @Override
     public void tearDown() throws Exception {
-        cmActivity.finish();
-        log("tear down ConnectivityManagerTestActivity");
         wl.release();
-        cmActivity.removeConfiguredNetworksAndDisableWifi();
-        // if airplane mode is set, disable it.
-        if (Settings.Global.getInt(getInstrumentation().getContext().getContentResolver(),
-                Settings.Global.AIRPLANE_MODE_ON) == 1) {
-            log("disable airplane mode if it is enabled");
-            cmActivity.mCM.setAirplaneMode(false);
-        }
+        removeConfiguredNetworksAndDisableWifi();
+        mCM.setAirplaneMode(false);
         super.tearDown();
     }
 
     // help function to verify 3G connection
     public void verifyCellularConnection() {
-        NetworkInfo extraNetInfo = cmActivity.mCM.getActiveNetworkInfo();
+        NetworkInfo extraNetInfo = mCM.getActiveNetworkInfo();
         assertEquals("network type is not MOBILE", ConnectivityManager.TYPE_MOBILE,
                 extraNetInfo.getType());
         assertTrue("not connected to cellular network", extraNetInfo.isConnected());
     }
 
     private void log(String message) {
-        Log.v(LOG_TAG, message);
+        Log.v(TAG, message);
     }
 
     private void sleep(long sleeptime) {
@@ -115,46 +101,46 @@ public class ConnectivityManagerMobileTest extends
     @LargeTest
     public void test3GToWifiNotification() {
         if (mWifiOnlyFlag) {
-            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
+            Log.v(TAG, this.getName() + " is excluded for wifi-only test");
             return;
         }
         // Enable Wi-Fi to avoid initial UNKNOWN state
-        cmActivity.enableWifi();
-        sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+        enableWifi();
+        sleep(2 * SHORT_TIMEOUT);
 
         // Wi-Fi is disabled
-        cmActivity.disableWifi();
+        disableWifi();
 
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI,
-                State.DISCONNECTED,  ConnectivityManagerTestActivity.LONG_TIMEOUT));
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI,
+                State.DISCONNECTED, LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                State.CONNECTED, LONG_TIMEOUT));
         // Wait for 10 seconds for broadcasts to be sent out
         sleep(10 * 1000);
 
         // As Wifi stays in DISCONNETED, Mobile statys in CONNECTED,
         // the connectivity manager will not broadcast any network connectivity event for Wifi
-        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
+        NetworkInfo networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
                 networkInfo.getState(), NetworkState.DO_NOTHING, State.CONNECTED);
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
                 NetworkState.DO_NOTHING, State.DISCONNECTED);
         // Eanble Wifi without associating with any AP
-        cmActivity.enableWifi();
-        sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+        enableWifi();
+        sleep(2 * SHORT_TIMEOUT);
 
         // validate state and broadcast
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
             log("the state for WIFI is changed");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
             assertTrue("state validation fail", false);
         }
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
             log("the state for MOBILE is changed");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
             assertTrue("state validation fail", false);
         }
         // Verify that the device is still connected to MOBILE
@@ -168,40 +154,39 @@ public class ConnectivityManagerMobileTest extends
         NetworkInfo networkInfo;
         if (!mWifiOnlyFlag) {
             //Prepare for connectivity verification
-            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
-            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
+            networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+            setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
                     networkInfo.getState(), NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
         }
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
                 NetworkState.TO_CONNECTION, State.CONNECTED);
 
         // Enable Wifi and connect to a test access point
         assertTrue("failed to connect to " + mTestAccessPoint,
-                cmActivity.connectToWifi(mTestAccessPoint));
+                connectToWifi(mTestAccessPoint));
 
-        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForWifiState(WifiManager.WIFI_STATE_ENABLED, LONG_TIMEOUT));
         log("wifi state is enabled");
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
         if (!mWifiOnlyFlag) {
-            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
+            assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                    State.DISCONNECTED, LONG_TIMEOUT));
         }
 
         // validate states
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
             log("Wifi state transition validation failed.");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
             assertTrue(false);
         }
         if (!mWifiOnlyFlag) {
-            if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
+            if (!validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
                 log("Mobile state transition validation failed.");
                 log("reason: " +
-                        cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
+                        getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
                 assertTrue(false);
             }
         }
@@ -213,61 +198,59 @@ public class ConnectivityManagerMobileTest extends
         assertNotNull("SSID is null", mTestAccessPoint);
         // Connect to mTestAccessPoint
         assertTrue("failed to connect to " + mTestAccessPoint,
-                cmActivity.connectToWifi(mTestAccessPoint));
-        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+                connectToWifi(mTestAccessPoint));
+        assertTrue(waitForWifiState(WifiManager.WIFI_STATE_ENABLED, LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
 
-        sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+        sleep(SHORT_TIMEOUT);
         // Disable Wifi
         log("Disable Wifi");
-        if (!cmActivity.disableWifi()) {
+        if (!disableWifi()) {
             log("disable Wifi failed");
             return;
         }
 
         // Wait for the Wifi state to be DISABLED
-        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI,
-                State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForWifiState(WifiManager.WIFI_STATE_DISABLED, LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI,
+                State.DISCONNECTED, LONG_TIMEOUT));
         if (!mWifiOnlyFlag) {
-            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                    State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
+            assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                    State.CONNECTED, LONG_TIMEOUT));
         }
 
         NetworkInfo networkInfo;
         if (!mWifiOnlyFlag) {
             //Prepare for connectivity state verification
-            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
-            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
+            networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+            setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
                                                   networkInfo.getState(), NetworkState.DO_NOTHING,
                                                   State.DISCONNECTED);
         }
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
                 NetworkState.TO_CONNECTION, State.CONNECTED);
 
         // wait for 2 minutes before restart wifi
-        sleep(ConnectivityManagerTestActivity.WIFI_STOP_START_INTERVAL);
+        sleep(WIFI_STOP_START_INTERVAL);
         // Enable Wifi again
         log("Enable Wifi again");
-        cmActivity.enableWifi();
+        enableWifi();
 
         // Wait for Wifi to be connected and mobile to be disconnected
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
         if (!mWifiOnlyFlag) {
-            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
+            assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                    State.DISCONNECTED, LONG_TIMEOUT));
         }
 
         // validate wifi states
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
             log("Wifi state transition validation failed.");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
             assertTrue(false);
         }
     }
@@ -279,48 +262,48 @@ public class ConnectivityManagerMobileTest extends
 
         // connect to Wifi
         assertTrue("failed to connect to " + mTestAccessPoint,
-                cmActivity.connectToWifi(mTestAccessPoint));
+                connectToWifi(mTestAccessPoint));
 
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
 
         // Wait for a few seconds to avoid the state that both Mobile and Wifi is connected
-        sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+        sleep(SHORT_TIMEOUT);
 
         NetworkInfo networkInfo;
         if (!mWifiOnlyFlag) {
-            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
-            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
+            networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+            setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
                                                   networkInfo.getState(),
                                                   NetworkState.TO_CONNECTION,
                                                   State.CONNECTED);
         }
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
                 NetworkState.TO_DISCONNECTION, State.DISCONNECTED);
 
         // clear Wifi
-        cmActivity.removeConfiguredNetworksAndDisableWifi();
+        removeConfiguredNetworksAndDisableWifi();
 
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI,
+                State.DISCONNECTED, LONG_TIMEOUT));
         if (!mWifiOnlyFlag) {
-            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                    State.CONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
+            assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                    State.CONNECTED, LONG_TIMEOUT));
         }
 
         // validate states
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
             log("Wifi state transition validation failed.");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
             assertTrue(false);
         }
         if (!mWifiOnlyFlag) {
-            if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
+            if (!validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
                 log("Mobile state transition validation failed.");
                 log("reason: " +
-                        cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
+                        getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
                 assertTrue(false);
             }
         }
@@ -330,62 +313,62 @@ public class ConnectivityManagerMobileTest extends
     @LargeTest
     public void testDataConnectionWith3GToAmTo3G() {
         if (mWifiOnlyFlag) {
-            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
+            Log.v(TAG, this.getName() + " is excluded for wifi-only test");
             return;
         }
         //Prepare for state verification
-        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
+        NetworkInfo networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
                                               networkInfo.getState(),
                                               NetworkState.TO_DISCONNECTION,
                                               State.DISCONNECTED);
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
         assertEquals(State.DISCONNECTED, networkInfo.getState());
 
         // Enable airplane mode
         log("Enable airplane mode");
-        cmActivity.mCM.setAirplaneMode(true);
-        sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+        mCM.setAirplaneMode(true);
+        sleep(SHORT_TIMEOUT);
 
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
         assertEquals(State.DISCONNECTED, networkInfo.getState());
         // wait until mobile is turn off
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                State.DISCONNECTED, LONG_TIMEOUT));
+        if (!validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
             log("Mobile state transition validation failed.");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
             assertTrue(false);
         }
 
         // reset state recorder
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
                                               networkInfo.getState(),
                                               NetworkState.TO_CONNECTION,
                                               State.CONNECTED);
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
                 NetworkState.DO_NOTHING, State.DISCONNECTED);
 
         // disable airplane mode
-        cmActivity.mCM.setAirplaneMode(false);
+        mCM.setAirplaneMode(false);
 
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                State.CONNECTED, LONG_TIMEOUT));
 
         // Validate the state transition
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
             log("Mobile state transition validation failed.");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
             assertTrue(false);
         }
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
           log("Wifi state transition validation failed.");
           log("reason: " +
-                  cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
+                  getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
           assertTrue(false);
         }
     }
@@ -394,107 +377,107 @@ public class ConnectivityManagerMobileTest extends
     @LargeTest
     public void testDataConnectionOverAMWithWifi() {
         if (mWifiOnlyFlag) {
-            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
+            Log.v(TAG, this.getName() + " is excluded for wifi-only test");
             return;
         }
         assertNotNull("SSID is null", mTestAccessPoint);
         // Eanble airplane mode
         log("Enable airplane mode");
-        cmActivity.mCM.setAirplaneMode(true);
+        mCM.setAirplaneMode(true);
 
         NetworkInfo networkInfo;
         if (!mWifiOnlyFlag) {
-            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
-            networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
-            cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
+            assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                    State.DISCONNECTED, LONG_TIMEOUT));
+            networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+            setStateTransitionCriteria(ConnectivityManager.TYPE_MOBILE,
                                                   networkInfo.getState(),
                                                   NetworkState.DO_NOTHING,
                                                   State.DISCONNECTED);
         }
-        networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
+        networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI, networkInfo.getState(),
                                               NetworkState.TO_CONNECTION, State.CONNECTED);
 
         // Connect to Wifi
         assertTrue("failed to connect to " + mTestAccessPoint,
-                cmActivity.connectToWifi(mTestAccessPoint));
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+                connectToWifi(mTestAccessPoint));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
 
         // validate state and broadcast
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
             log("state validate for Wifi failed");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
             assertTrue("State validation failed", false);
         }
         if (!mWifiOnlyFlag) {
-            if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
+            if (!validateNetworkStates(ConnectivityManager.TYPE_MOBILE)) {
                 log("state validation for Mobile failed");
                 log("reason: " +
-                        cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
+                        getTransitionFailureReason(ConnectivityManager.TYPE_MOBILE));
                 assertTrue("state validation failed", false);
             }
         }
-        cmActivity.mCM.setAirplaneMode(false);
+        mCM.setAirplaneMode(false);
     }
 
     // Test case 7: test connectivity while transit from Wifi->AM->Wifi
     @LargeTest
     public void testDataConnectionWithWifiToAMToWifi () {
         if (mWifiOnlyFlag) {
-            Log.v(LOG_TAG, this.getName() + " is excluded for wifi-only test");
+            Log.v(TAG, this.getName() + " is excluded for wifi-only test");
             return;
         }
         // Connect to mTestAccessPoint
         assertNotNull("SSID is null", mTestAccessPoint);
         // Connect to Wifi
         assertTrue("failed to connect to " + mTestAccessPoint,
-                cmActivity.connectToWifi(mTestAccessPoint));
+                connectToWifi(mTestAccessPoint));
 
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
 
         try {
-            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+            Thread.sleep(SHORT_TIMEOUT);
         } catch (Exception e) {
             log("exception: " + e.toString());
         }
 
         // Enable airplane mode without clearing Wifi
-        cmActivity.mCM.setAirplaneMode(true);
+        mCM.setAirplaneMode(true);
 
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI,
+                State.DISCONNECTED, LONG_TIMEOUT));
 
         try {
-            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+            Thread.sleep(SHORT_TIMEOUT);
         } catch (Exception e) {
             log("exception: " + e.toString());
         }
 
         // Prepare for state validation
-        NetworkInfo networkInfo = cmActivity.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        NetworkInfo networkInfo = mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
         assertEquals(State.DISCONNECTED, networkInfo.getState());
-        cmActivity.setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI,
+        setStateTransitionCriteria(ConnectivityManager.TYPE_WIFI,
                 networkInfo.getState(), NetworkState.TO_CONNECTION, State.CONNECTED);
 
         // Disable airplane mode
-        cmActivity.mCM.setAirplaneMode(false);
+        mCM.setAirplaneMode(false);
 
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
         if (!mWifiOnlyFlag) {
-            assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
-                    State.DISCONNECTED, ConnectivityManagerTestActivity.LONG_TIMEOUT));
+            assertTrue(waitForNetworkState(ConnectivityManager.TYPE_MOBILE,
+                    State.DISCONNECTED, LONG_TIMEOUT));
         }
 
         // validate the state transition
-        if (!cmActivity.validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
+        if (!validateNetworkStates(ConnectivityManager.TYPE_WIFI)) {
             log("Wifi state transition validation failed.");
             log("reason: " +
-                    cmActivity.getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
+                    getTransitionFailureReason(ConnectivityManager.TYPE_WIFI));
             assertTrue(false);
         }
     }
@@ -505,35 +488,33 @@ public class ConnectivityManagerMobileTest extends
         assertNotNull("SSID is null", mTestAccessPoint);
         //Connect to mTestAccessPoint
         assertTrue("failed to connect to " + mTestAccessPoint,
-                cmActivity.connectToWifi(mTestAccessPoint));
-        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+                connectToWifi(mTestAccessPoint));
+        assertTrue(waitForWifiState(WifiManager.WIFI_STATE_ENABLED, LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
         assertNotNull("Not associated with any AP",
-                      cmActivity.mWifiManager.getConnectionInfo().getBSSID());
+                      mWifiManager.getConnectionInfo().getBSSID());
 
         try {
-            Thread.sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+            Thread.sleep(SHORT_TIMEOUT);
         } catch (Exception e) {
             log("exception: " + e.toString());
         }
 
         // Disconnect from the current AP
         log("disconnect from the AP");
-        if (!cmActivity.disconnectAP()) {
+        if (!disconnectAP()) {
             log("failed to disconnect from " + mTestAccessPoint);
         }
 
         // Verify the connectivity state for Wifi is DISCONNECTED
-        assertTrue(cmActivity.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI,
+                State.DISCONNECTED, LONG_TIMEOUT));
 
-        if (!cmActivity.disableWifi()) {
+        if (!disableWifi()) {
             log("disable Wifi failed");
             return;
         }
-        assertTrue(cmActivity.waitForWifiState(WifiManager.WIFI_STATE_DISABLED,
-                ConnectivityManagerTestActivity.LONG_TIMEOUT));
+        assertTrue(waitForWifiState(WifiManager.WIFI_STATE_DISABLED, LONG_TIMEOUT));
     }
 }
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiAssociationTest.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiAssociationTest.java
index f12e62e..183f2a9 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiAssociationTest.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiAssociationTest.java
@@ -16,7 +16,7 @@
 
 package com.android.connectivitymanagertest.functional;
 
-import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
+import com.android.connectivitymanagertest.ConnectivityManagerTestBase;
 import com.android.connectivitymanagertest.WifiAssociationTestRunner;
 
 import android.content.Context;
@@ -32,7 +32,6 @@ import android.net.wifi.WifiManager;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo.State;
 import android.test.suitebuilder.annotation.LargeTest;
-import android.test.ActivityInstrumentationTestCase2;
 import android.util.Log;
 
 /**
@@ -43,30 +42,22 @@ import android.util.Log;
  * -w com.android.connectivitymanagertest/.WifiAssociationTestRunner"
  */
 public class WifiAssociationTest
-    extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
+        extends ConnectivityManagerTestBase {
     private static final String TAG = "WifiAssociationTest";
-    private ConnectivityManagerTestActivity mAct;
     private String mSsid = null;
     private String mPassword = null;
     private String mSecurityType = null;
     private String mFrequencyBand = null;
     private int mBand;
-    private WifiManager mWifiManager = null;
 
     enum SECURITY_TYPE {
         OPEN, WEP64, WEP128, WPA_TKIP, WPA2_AES
-    };
-
-    public WifiAssociationTest() {
-        super(ConnectivityManagerTestActivity.class);
     }
 
     @Override
     public void setUp() throws Exception {
         super.setUp();
         WifiAssociationTestRunner mRunner = (WifiAssociationTestRunner)getInstrumentation();
-        mWifiManager = (WifiManager) mRunner.getContext().getSystemService(Context.WIFI_SERVICE);
-        mAct = getActivity();
         Bundle arguments = mRunner.getArguments();
         mSecurityType = arguments.getString("security-type");
         mSsid = arguments.getString("ssid");
@@ -77,17 +68,15 @@ public class WifiAssociationTest
         assertNotNull("Ssid is empty", mSsid);
         validateFrequencyBand();
         // enable Wifi and verify wpa_supplicant is started
-        assertTrue("enable Wifi failed", mAct.enableWifi());
-        sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT,
-                "interrupted while waiting for WPA_SUPPLICANT to start");
-        WifiInfo mConnection = mAct.mWifiManager.getConnectionInfo();
+        assertTrue("enable Wifi failed", enableWifi());
+        sleep(2 * SHORT_TIMEOUT, "interrupted while waiting for WPA_SUPPLICANT to start");
+        WifiInfo mConnection = mWifiManager.getConnectionInfo();
         assertNotNull(mConnection);
-        assertTrue("wpa_supplicant is not started ", mAct.mWifiManager.pingSupplicant());
+        assertTrue("wpa_supplicant is not started ", mWifiManager.pingSupplicant());
     }
 
     @Override
     public void tearDown() throws Exception {
-        log("tearDown()");
         super.tearDown();
     }
 
@@ -107,16 +96,16 @@ public class WifiAssociationTest
     private void connectToWifi(WifiConfiguration config) {
         // step 1: connect to the test access point
         assertTrue("failed to associate with " + config.SSID,
-                mAct.connectToWifiWithConfiguration(config));
+                connectToWifiWithConfiguration(config));
 
         // step 2: verify Wifi state and network state;
         assertTrue("failed to connect with " + config.SSID,
-                mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI,
-                State.CONNECTED, ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+                waitForNetworkState(ConnectivityManager.TYPE_WIFI,
+                State.CONNECTED, WIFI_CONNECTION_TIMEOUT));
 
         // step 3: verify the current connected network is the given SSID
-        assertNotNull("Wifi connection returns null", mAct.mWifiManager.getConnectionInfo());
-        assertTrue(config.SSID.contains(mAct.mWifiManager.getConnectionInfo().getSSID()));
+        assertNotNull("Wifi connection returns null", mWifiManager.getConnectionInfo());
+        assertTrue(config.SSID.contains(mWifiManager.getConnectionInfo().getSSID()));
     }
 
     private void sleep(long sometime, String errorMsg) {
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiConnectionTest.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiConnectionTest.java
index de0298e..ad73ee1 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiConnectionTest.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiConnectionTest.java
@@ -16,35 +16,19 @@
 
 package com.android.connectivitymanagertest.functional;
 
-import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
+import com.android.connectivitymanagertest.ConnectivityManagerTestBase;
 import com.android.connectivitymanagertest.ConnectivityManagerTestRunner;
 
-import android.R;
-import android.app.Activity;
-import android.content.ContentResolver;
-import android.content.Intent;
 import android.content.Context;
-import android.content.res.Resources;
 import android.net.wifi.WifiConfiguration;
-import android.net.wifi.WifiConfiguration.KeyMgmt;
-import android.net.wifi.WifiConfiguration.Status;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.net.ConnectivityManager;
-import android.net.DhcpInfo;
-import android.net.NetworkInfo;
 import android.net.NetworkInfo.State;
-import android.os.Handler;
-import android.os.Message;
-import android.provider.Settings;
 import android.test.suitebuilder.annotation.LargeTest;
-import android.test.ActivityInstrumentationTestCase2;
 import android.util.Log;
 
-import com.android.internal.util.AsyncChannel;
-
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -56,39 +40,25 @@ import java.util.Set;
  *          -w com.android.connectivitymanagertest/.ConnectivityManagerTestRunner
  */
 public class WifiConnectionTest
-    extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
+    extends ConnectivityManagerTestBase {
     private static final String TAG = "WifiConnectionTest";
     private static final boolean DEBUG = false;
     private List<WifiConfiguration> networks = new ArrayList<WifiConfiguration>();
-    private ConnectivityManagerTestActivity mAct;
-    private ConnectivityManagerTestRunner mRunner;
-    private WifiManager mWifiManager = null;
-    private Set<WifiConfiguration> enabledNetworks = null;
-
-    public WifiConnectionTest() {
-        super(ConnectivityManagerTestActivity.class);
-    }
 
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        mRunner = ((ConnectivityManagerTestRunner)getInstrumentation());
-        mWifiManager = (WifiManager) mRunner.getContext().getSystemService(Context.WIFI_SERVICE);
-
-        mAct = getActivity();
-
-        networks = mAct.loadNetworkConfigurations();
+        networks = loadNetworkConfigurations();
         if (DEBUG) {
             printNetworkConfigurations();
         }
 
         // enable Wifi and verify wpa_supplicant is started
-        assertTrue("enable Wifi failed", mAct.enableWifi());
-        sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT,
-                "interrupted while waiting for WPA_SUPPLICANT to start");
-        WifiInfo mConnection = mAct.mWifiManager.getConnectionInfo();
+        assertTrue("enable Wifi failed", enableWifi());
+        sleep(2 * SHORT_TIMEOUT, "interrupted while waiting for WPA_SUPPLICANT to start");
+        WifiInfo mConnection = mWifiManager.getConnectionInfo();
         assertNotNull(mConnection);
-        assertTrue("wpa_supplicant is not started ", mAct.mWifiManager.pingSupplicant());
+        assertTrue("wpa_supplicant is not started ", mWifiManager.pingSupplicant());
     }
 
     private void printNetworkConfigurations() {
@@ -101,8 +71,7 @@ public class WifiConnectionTest
 
     @Override
     public void tearDown() throws Exception {
-        log("tearDown()");
-        mAct.removeConfiguredNetworksAndDisableWifi();
+        removeConfiguredNetworksAndDisableWifi();
         super.tearDown();
     }
 
@@ -114,20 +83,20 @@ public class WifiConnectionTest
     private void connectToWifi(WifiConfiguration config) {
         // step 1: connect to the test access point
         assertTrue("failed to connect to " + config.SSID,
-                mAct.connectToWifiWithConfiguration(config));
+                connectToWifiWithConfiguration(config));
 
         // step 2: verify Wifi state and network state;
-        assertTrue(mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI,
-                State.CONNECTED, ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI,
+                State.CONNECTED, WIFI_CONNECTION_TIMEOUT));
 
         // step 3: verify the current connected network is the given SSID
-        assertNotNull("Wifi connection returns null", mAct.mWifiManager.getConnectionInfo());
+        assertNotNull("Wifi connection returns null", mWifiManager.getConnectionInfo());
         if (DEBUG) {
             log("config.SSID = " + config.SSID);
-            log("mAct.mWifiManager.getConnectionInfo.getSSID()" +
-                    mAct.mWifiManager.getConnectionInfo().getSSID());
+            log("mWifiManager.getConnectionInfo.getSSID()" +
+                    mWifiManager.getConnectionInfo().getSSID());
         }
-        assertTrue(config.SSID.contains(mAct.mWifiManager.getConnectionInfo().getSSID()));
+        assertTrue(config.SSID.contains(mWifiManager.getConnectionInfo().getSSID()));
     }
 
     private void sleep(long sometime, String errorMsg) {
@@ -149,8 +118,7 @@ public class WifiConnectionTest
             log("-- START Wi-Fi connection test to : " + ssid + " --");
             connectToWifi(networks.get(i));
             // wait for 2 minutes between wifi stop and start
-            sleep(ConnectivityManagerTestActivity.WIFI_STOP_START_INTERVAL,
-                  "interruped while connected to wifi");
+            sleep(WIFI_STOP_START_INTERVAL, "interruped while connected to wifi");
             log("-- END Wi-Fi connection test to " + ssid + " -- ");
         }
     }
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiApStress.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiApStress.java
index 60595fb..790ca38 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiApStress.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiApStress.java
@@ -18,19 +18,13 @@ package com.android.connectivitymanagertest.stress;
 
 
 import com.android.connectivitymanagertest.ConnectivityManagerStressTestRunner;
-import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
+import com.android.connectivitymanagertest.ConnectivityManagerTestBase;
 
-import android.content.Context;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiConfiguration.KeyMgmt;
 import android.net.wifi.WifiConfiguration.AuthAlgorithm;
 import android.net.wifi.WifiManager;
 import android.os.Environment;
-import android.os.IPowerManager;
-import android.os.PowerManager;
-import android.os.ServiceManager;
-import android.os.SystemClock;
-import android.test.ActivityInstrumentationTestCase2;
 import android.test.suitebuilder.annotation.LargeTest;
 import android.util.Log;
 
@@ -42,30 +36,24 @@ import java.io.FileWriter;
  * Stress the wifi driver as access point.
  */
 public class WifiApStress
-    extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
+    extends ConnectivityManagerTestBase {
     private final static String TAG = "WifiApStress";
     private static String NETWORK_ID = "AndroidAPTest";
     private static String PASSWD = "androidwifi";
     private final static String OUTPUT_FILE = "WifiStressTestOutput.txt";
-    private ConnectivityManagerTestActivity mAct;
     private int iterations;
     private BufferedWriter mOutputWriter = null;
     private int mLastIteration = 0;
     private boolean mWifiOnlyFlag;
 
-    public WifiApStress() {
-        super(ConnectivityManagerTestActivity.class);
-    }
-
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        mAct = getActivity();
         ConnectivityManagerStressTestRunner mRunner =
             (ConnectivityManagerStressTestRunner)getInstrumentation();
         iterations = mRunner.mSoftapIterations;
         mWifiOnlyFlag = mRunner.mWifiOnlyFlag;
-        mAct.turnScreenOn();
+        turnScreenOn();
     }
 
     @Override
@@ -92,30 +80,28 @@ public class WifiApStress
         config.preSharedKey = PASSWD;
 
         // If Wifi is enabled, disable it
-        if (mAct.mWifiManager.isWifiEnabled()) {
-            mAct.disableWifi();
+        if (mWifiManager.isWifiEnabled()) {
+            disableWifi();
         }
         int i;
         for (i = 0; i < iterations; i++) {
             Log.v(TAG, "iteration: " + i);
             mLastIteration = i;
             // enable Wifi tethering
-            assertTrue(mAct.mWifiManager.setWifiApEnabled(config, true));
+            assertTrue(mWifiManager.setWifiApEnabled(config, true));
             // Wait for wifi ap state to be ENABLED
-            assertTrue(mAct.waitForWifiAPState(WifiManager.WIFI_AP_STATE_ENABLED,
-                    2 * ConnectivityManagerTestActivity.LONG_TIMEOUT));
+            assertTrue(waitForWifiAPState(WifiManager.WIFI_AP_STATE_ENABLED, 2 * LONG_TIMEOUT));
             // Wait for wifi tethering result
-            assertEquals(ConnectivityManagerTestActivity.SUCCESS,
-                    mAct.waitForTetherStateChange(2*ConnectivityManagerTestActivity.SHORT_TIMEOUT));
+            assertEquals(SUCCESS, waitForTetherStateChange(2 * SHORT_TIMEOUT));
             // Allow the wifi tethering to be enabled for 10 seconds
             try {
-                Thread.sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
+                Thread.sleep(2 * SHORT_TIMEOUT);
             } catch (Exception e) {
                 fail("thread in sleep is interrupted");
             }
-            assertTrue("no uplink data connection after Wi-Fi tethering", mAct.pingTest(null));
+            assertTrue("no uplink data connection after Wi-Fi tethering", pingTest(null));
             // Disable soft AP
-            assertTrue(mAct.mWifiManager.setWifiApEnabled(config, false));
+            assertTrue(mWifiManager.setWifiApEnabled(config, false));
             // Wait for 30 seconds until Wi-Fi tethering is stopped
             try {
                 Thread.sleep(30 * 1000);
@@ -123,7 +109,7 @@ public class WifiApStress
             } catch (Exception e) {
                 fail("thread in sleep is interrupted");
             }
-            assertFalse("Wi-Fi AP disable failed", mAct.mWifiManager.isWifiApEnabled());
+            assertFalse("Wi-Fi AP disable failed", mWifiManager.isWifiApEnabled());
         }
         if (i == iterations) {
             mLastIteration = iterations;
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiStressTest.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiStressTest.java
index e3c7cc4..04ce4b7 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiStressTest.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiStressTest.java
@@ -29,12 +29,11 @@ import android.os.Environment;
 import android.os.PowerManager;
 import android.provider.Settings;
 import android.view.KeyEvent;
-import android.test.ActivityInstrumentationTestCase2;
 import android.test.suitebuilder.annotation.LargeTest;
 import android.util.Log;
 
 import com.android.connectivitymanagertest.ConnectivityManagerStressTestRunner;
-import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
+import com.android.connectivitymanagertest.ConnectivityManagerTestBase;
 
 import java.io.BufferedWriter;
 import java.io.File;
@@ -50,7 +49,7 @@ import java.util.List;
  *                  -w com.android.connectivitymanagertest/.ConnectivityManagerStressTestRunner
  */
 public class WifiStressTest
-    extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
+        extends ConnectivityManagerTestBase {
     private final static String TAG = "WifiStressTest";
 
     /**
@@ -67,7 +66,6 @@ public class WifiStressTest
     private final static long WIFI_SHUTDOWN_DELAY = 2 * 60 * 1000;
 
     private final static String OUTPUT_FILE = "WifiStressTestOutput.txt";
-    private ConnectivityManagerTestActivity mAct;
     private int mReconnectIterations;
     private int mWifiSleepTime;
     private int mScanIterations;
@@ -77,15 +75,10 @@ public class WifiStressTest
     private BufferedWriter mOutputWriter = null;
     private boolean mWifiOnlyFlag;
 
-    public WifiStressTest() {
-        super(ConnectivityManagerTestActivity.class);
-    }
-
     @Override
     public void setUp() throws Exception {
         super.setUp();
 
-        mAct = getActivity();
         mRunner = (ConnectivityManagerStressTestRunner) getInstrumentation();
         mReconnectIterations = mRunner.mReconnectIterations;
         mSsid = mRunner.mReconnectSsid;
@@ -98,15 +91,14 @@ public class WifiStressTest
             mPassword, mScanIterations, mWifiSleepTime));
         mOutputWriter = new BufferedWriter(new FileWriter(new File(
                 Environment.getExternalStorageDirectory(), OUTPUT_FILE), true));
-        mAct.turnScreenOn();
-        if (!mAct.mWifiManager.isWifiEnabled()) {
+        turnScreenOn();
+        if (!mWifiManager.isWifiEnabled()) {
             log("Enable wi-fi before stress tests.");
-            if (!mAct.enableWifi()) {
+            if (!enableWifi()) {
                 tearDown();
                 fail("enable wifi failed.");
             }
-            sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT,
-                    "Interruped while waiting for wifi on");
+            sleep(SHORT_TIMEOUT, "Interruped while waiting for wifi on");
         }
     }
 
@@ -166,33 +158,32 @@ public class WifiStressTest
             writeOutput(String.format("ssid appear %d out of %d scan iterations",
                     ssidAppearInScanResultsCount, i));
             long startTime = System.currentTimeMillis();
-            mAct.scanResultAvailable = false;
-            assertTrue("start scan failed", mAct.mWifiManager.startScan());
+            scanResultAvailable = false;
+            assertTrue("start scan failed", mWifiManager.startScan());
             while (true) {
                 if ((System.currentTimeMillis() - startTime) >
-                ConnectivityManagerTestActivity.WIFI_SCAN_TIMEOUT) {
-                    fail("Wifi scanning takes more than " +
-                            ConnectivityManagerTestActivity.WIFI_SCAN_TIMEOUT + " ms");
+                WIFI_SCAN_TIMEOUT) {
+                    fail("Wifi scanning takes more than " + WIFI_SCAN_TIMEOUT + " ms");
                 }
-                synchronized(mAct) {
+                synchronized(this) {
                     try {
-                        mAct.wait(ConnectivityManagerTestActivity.WAIT_FOR_SCAN_RESULT);
+                        wait(WAIT_FOR_SCAN_RESULT);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
-                    if (mAct.scanResultAvailable) {
+                    if (scanResultAvailable) {
                         long scanTime = (System.currentTimeMillis() - startTime);
                         scanTimeSum += scanTime;
                         break;
                     }
                 }
             }
-            if ((mAct.mWifiManager.getScanResults() == null) ||
-                    (mAct.mWifiManager.getScanResults().size() <= 0)) {
+            if ((mWifiManager.getScanResults() == null) ||
+                    (mWifiManager.getScanResults().size() <= 0)) {
                 fail("Scan results are empty ");
             }
 
-            List<ScanResult> netList = mAct.mWifiManager.getScanResults();
+            List<ScanResult> netList = mWifiManager.getScanResults();
             if (netList != null) {
                 log("size of scan result list: " + netList.size());
                 for (int s = 0; s < netList.size(); s++) {
@@ -244,13 +235,13 @@ public class WifiStressTest
         config.proxySettings = ProxySettings.NONE;
 
         assertTrue("Failed to connect to Wi-Fi network: " + mSsid,
-                mAct.connectToWifiWithConfiguration(config));
-        assertTrue(mAct.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
-                ConnectivityManagerTestActivity.SHORT_TIMEOUT));
-        assertTrue(mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+                connectToWifiWithConfiguration(config));
+        assertTrue(waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
+                SHORT_TIMEOUT));
+        assertTrue(waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                WIFI_CONNECTION_TIMEOUT));
         // Run ping test to verify the data connection
-        assertTrue("Wi-Fi is connected, but no data connection.", mAct.pingTest(null));
+        assertTrue("Wi-Fi is connected, but no data connection.", pingTest(null));
 
         int i;
         long sum = 0;
@@ -263,33 +254,33 @@ public class WifiStressTest
             writeOutput(String.format("iteration %d out of %d",
                     i, mReconnectIterations));
             log("iteration: " + i);
-            mAct.turnScreenOff();
+            turnScreenOff();
             PowerManager pm =
                 (PowerManager)mRunner.getContext().getSystemService(Context.POWER_SERVICE);
             assertFalse(pm.isScreenOn());
             sleep(WIFI_IDLE_MS + WIFI_SHUTDOWN_DELAY, "Interruped while wait for wifi to be idle");
             assertTrue("Wait for Wi-Fi to idle timeout",
-                    mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
-                    6 * ConnectivityManagerTestActivity.SHORT_TIMEOUT));
+                    waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED,
+                    6 * SHORT_TIMEOUT));
             if (!mWifiOnlyFlag) {
                 // use long timeout as the pppd startup may take several retries.
                 assertTrue("Wait for cellular connection timeout",
-                        mAct.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
-                        2 * ConnectivityManagerTestActivity.LONG_TIMEOUT));
+                        waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
+                        2 * LONG_TIMEOUT));
             }
             sleep(mWifiSleepTime, "Interrupted while device is in sleep mode");
             // Verify the wi-fi is still off and data connection is on
             assertEquals("Wi-Fi is reconnected", State.DISCONNECTED,
-                    mAct.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState());
+                    mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState());
 
             if (!mWifiOnlyFlag) {
                 assertEquals("Cellular connection is down", State.CONNECTED,
-                             mAct.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState());
-                assertTrue("Mobile is connected, but no data connection.", mAct.pingTest(null));
+                             mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState());
+                assertTrue("Mobile is connected, but no data connection.", pingTest(null));
             }
 
             // Turn screen on again
-            mAct.turnScreenOn();
+            turnScreenOn();
             // Wait for 2 seconds for the lock screen
             sleep(2 * 1000, "wait 2 seconds for lock screen");
             // Disable lock screen by inject menu key event
@@ -298,16 +289,16 @@ public class WifiStressTest
             // Measure the time for Wi-Fi to get connected
             long startTime = System.currentTimeMillis();
             assertTrue("Wait for Wi-Fi enable timeout after wake up",
-                    mAct.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
-                    ConnectivityManagerTestActivity.SHORT_TIMEOUT));
+                    waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
+                    SHORT_TIMEOUT));
             assertTrue("Wait for Wi-Fi connection timeout after wake up",
-                    mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
-                    ConnectivityManagerTestActivity.WIFI_CONNECTION_TIMEOUT));
+                    waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
+                    WIFI_CONNECTION_TIMEOUT));
             long connectionTime = System.currentTimeMillis() - startTime;
             sum += connectionTime;
             log("average reconnection time is: " + sum/(i+1));
 
-            assertTrue("Reconnect to Wi-Fi network, but no data connection.", mAct.pingTest(null));
+            assertTrue("Reconnect to Wi-Fi network, but no data connection.", pingTest(null));
         }
         if (i == mReconnectIterations) {
             writeOutput(String.format("iteration %d out of %d",
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiClientTest.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiClientTest.java
index e44023b..7a9bc78 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiClientTest.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiClientTest.java
@@ -20,9 +20,6 @@ import android.content.BroadcastReceiver;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.Context;
-import android.app.Instrumentation;
-import android.os.Handler;
-import android.os.Message;
 import android.net.NetworkInfo;
 import android.net.wifi.WifiManager;
 import android.net.wifi.WifiConfiguration;
@@ -33,11 +30,8 @@ import android.net.wifi.SupplicantState;
 import android.test.suitebuilder.annotation.LargeTest;
 import android.test.AndroidTestCase;
 
-import java.util.ArrayList;
 import java.util.List;
 
-import android.util.Log;
-
 /**
  * Test wifi client
  */
diff --git a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiSoftAPTest.java b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiSoftAPTest.java
index 3f43e48..f202862 100644
--- a/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiSoftAPTest.java
+++ b/core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiSoftAPTest.java
@@ -16,13 +16,7 @@
 
 package com.android.connectivitymanagertest.unit;
 
-import android.content.BroadcastReceiver;
-import android.content.Intent;
 import android.content.Context;
-import android.app.Instrumentation;
-import android.os.Handler;
-import android.os.Message;
-import android.net.ConnectivityManager;
 import android.net.wifi.WifiManager;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiConfiguration.KeyMgmt;
@@ -30,8 +24,6 @@ import android.net.wifi.WifiConfiguration.KeyMgmt;
 import android.test.suitebuilder.annotation.LargeTest;
 import android.test.AndroidTestCase;
 
-import java.util.ArrayList;
-
 import android.util.Log;
 
 /**