Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Update the Connectivity Manager test suit to use InstrumentationTestCase." into klp-dev

Browse Source
This commit is contained in:
Xia Wang
2013-09-16 21:11:30 +00:00
committed by Android (Google) Code Review
parent 98d18bbc5e 19306af73a
commit 326f4505e0
11 changed files with 277 additions and 430 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
core/tests/ConnectivityManagerTest/AndroidManifest.xml
View File

@@ -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>

2
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/AccessPointParserHelper.java
View File

@@ -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;

147
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestActivity.java → core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestBase.java
View File

@@ -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);
mContext.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;
}
return super.onKeyDown(keyCode, event);
super.tearDown();
}
private void log(String message) {

2
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerUnitTestRunner.java
View File

@@ -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;

317
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/ConnectivityManagerMobileTest.java
View File

@@ -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));
}
}

33
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiAssociationTest.java
View File

@@ -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) {

64
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiConnectionTest.java
View File

@@ -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 + " -- ");
}
}

38
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiApStress.java
View File

@@ -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;

81
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiStressTest.java
View File

@@ -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",

6
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiClientTest.java
View File

@@ -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
*/

8
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/unit/WifiSoftAPTest.java
View File

@@ -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;
/**