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

am e12a1a09: Merge "Port wi-fi stress test into GB DO NOT MERGE" into gingerbread

Browse Source 
* commit 'e12a1a0949ceaff3e4d203ab6897501fb7bdfb98':
  Port wi-fi stress test into GB DO NOT MERGE
This commit is contained in:
Xia Wang
2011-03-17 16:21:28 -07:00
committed by Android Git Automerger
parent 3a90ec4e6b e12a1a0949
commit 01a111486d
6 changed files with 487 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/tests/ConnectivityManagerTest/Android.mk
View File

@@ -25,6 +25,6 @@ LOCAL_SRC_FILES := $(call all-java-files-under, src)
LOCAL_PACKAGE_NAME := ConnectivityManagerTest
#LOCAL_INSTRUMENTATION_FOR := connectivitymanagertest
LOCAL_CERTIFICATE := platform
include $(BUILD_PACKAGE)

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

@@ -16,7 +16,8 @@
<!-- package name must be unique so suffix with "tests" so package loader doesn't ignore us -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.android.connectivitymanagertest">
package="com.android.connectivitymanagertest"
android:sharedUserId="com.android.uid.test">
<!-- We add an application tag here just so that we can indicate that
this package needs to link against the android.test library,
@@ -67,5 +68,9 @@
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.WRITE_SETTINGS" />
<uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.DEVICE_POWER" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
</manifest>

54
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerStressTestRunner.java
View File

@@ -19,8 +19,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.stress.WifiApStress;
import com.android.connectivitymanagertest.stress.WifiStressTest;
import junit.framework.TestSuite;
@@ -34,10 +34,18 @@ import junit.framework.TestSuite;
*/
public class ConnectivityManagerStressTestRunner extends InstrumentationTestRunner {
public int mSoftapIterations = 100;
public int mScanIterations = 100;
public int mReconnectIterations = 100;
public int mSleepTime = 30 * 1000; // default sleep time is 30 seconds
public String mReconnectSsid = "securenetdhcp";
public String mReconnectPassword = "androidwifi";
@Override
public TestSuite getAllTests() {
TestSuite suite = new InstrumentationTestSuite(this);
suite.addTestSuite(WifiApStress.class);
suite.addTestSuite(WifiStressTest.class);
return suite;
}
@@ -49,14 +57,46 @@ public class ConnectivityManagerStressTestRunner extends InstrumentationTestRunn
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
String stressValue = (String) icicle.get("stressnum");
if (stressValue != null) {
int iteration = Integer.parseInt(stressValue);
String valueStr = (String) icicle.get("softap_iterations");
if (valueStr != null) {
int iteration = Integer.parseInt(valueStr);
if (iteration > 0) {
numStress = iteration;
mSoftapIterations = iteration;
}
}
String scanIterationStr = (String) icicle.get("scan_iterations");
if (scanIterationStr != null) {
int scanIteration = Integer.parseInt(scanIterationStr);
if (scanIteration > 0) {
mScanIterations = scanIteration;
}
}
String ssidStr= (String) icicle.get("reconnect_ssid");
if (ssidStr != null) {
mReconnectSsid = ssidStr;
}
String passwordStr = (String) icicle.get("reconnect_password");
if (passwordStr != null) {
mReconnectPassword = passwordStr;
}
String reconnectStr = (String) icicle.get("reconnect_iterations");
if (reconnectStr != null) {
int iteration = Integer.parseInt(reconnectStr);
if (iteration > 0) {
mReconnectIterations = iteration;
}
}
String sleepTimeStr = (String) icicle.get("sleep_time");
if (sleepTimeStr != null) {
int sleepTime = Integer.parseInt(sleepTimeStr);
if (sleepTime > 0) {
mSleepTime = 1000 * sleepTime;
}
}
}
public int numStress = 100;
}

144
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestActivity.java
View File

@@ -24,11 +24,17 @@ import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.IPowerManager;
import android.os.PowerManager;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.provider.Settings;
import android.util.Log;
import android.view.KeyEvent;
import java.io.IOException;
import java.io.InputStream;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@@ -54,7 +60,7 @@ public class ConnectivityManagerTestActivity extends Activity {
public static final String LOG_TAG = "ConnectivityManagerTestActivity";
public static final int WAIT_FOR_SCAN_RESULT = 10 * 1000; //10 seconds
public static final int WIFI_SCAN_TIMEOUT = 20 * 1000;
public static final int WIFI_SCAN_TIMEOUT = 50 * 1000;
public static final int SHORT_TIMEOUT = 5 * 1000;
public static final long LONG_TIMEOUT = 50 * 1000;
public static final int SUCCESS = 0; // for Wifi tethering state change
@@ -64,6 +70,7 @@ public class ConnectivityManagerTestActivity extends Activity {
public ConnectivityReceiver mConnectivityReceiver = null;
public WifiReceiver mWifiReceiver = null;
private AccessPointParserHelper mParseHelper = null;
public boolean scanResultAvailable = false;
/*
* Track network connectivity information
*/
@@ -79,7 +86,7 @@ public class ConnectivityManagerTestActivity extends Activity {
public int mWifiState;
public NetworkInfo mWifiNetworkInfo;
public String mBssid;
public String mPowerSsid = "GoogleGuest"; //Default power SSID
public String mPowerSsid = "opennet"; //Default power SSID
private Context mContext;
/*
@@ -104,7 +111,7 @@ public class ConnectivityManagerTestActivity extends Activity {
private class ConnectivityReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Log.v(LOG_TAG, "ConnectivityReceiver: onReceive() is called with " + intent);
log("ConnectivityReceiver: onReceive() is called with " + intent);
String action = intent.getAction();
if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
Log.v("ConnectivityReceiver", "onReceive() called with " + intent);
@@ -129,9 +136,9 @@ public class ConnectivityManagerTestActivity extends Activity {
mReason = intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
mIsFailOver = intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false);
Log.v(LOG_TAG, "mNetworkInfo: " + mNetworkInfo.toString());
log("mNetworkInfo: " + mNetworkInfo.toString());
if (mOtherNetworkInfo != null) {
Log.v(LOG_TAG, "mOtherNetworkInfo: " + mOtherNetworkInfo.toString());
log("mOtherNetworkInfo: " + mOtherNetworkInfo.toString());
}
recordNetworkState(mNetworkInfo.getType(), mNetworkInfo.getState());
if (mOtherNetworkInfo != null) {
@@ -151,7 +158,7 @@ public class ConnectivityManagerTestActivity extends Activity {
} else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
mWifiNetworkInfo =
(NetworkInfo) intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
Log.v(LOG_TAG, "mWifiNetworkInfo: " + mWifiNetworkInfo.toString());
log("mWifiNetworkInfo: " + mWifiNetworkInfo.toString());
if (mWifiNetworkInfo.getState() == State.CONNECTED) {
mBssid = intent.getStringExtra(WifiManager.EXTRA_BSSID);
}
@@ -159,7 +166,7 @@ public class ConnectivityManagerTestActivity extends Activity {
} else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
mWifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
WifiManager.WIFI_STATE_UNKNOWN);
Log.v(LOG_TAG, "mWifiState: " + mWifiState);
log("mWifiState: " + mWifiState);
notifyWifiState();
} else if (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)) {
notifyWifiAPState();
@@ -180,12 +187,13 @@ public class ConnectivityManagerTestActivity extends Activity {
public ConnectivityManagerTestActivity() {
mState = State.UNKNOWN;
scanResultAvailable = false;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.v(LOG_TAG, "onCreate, inst=" + Integer.toHexString(hashCode()));
log("onCreate, inst=" + Integer.toHexString(hashCode()));
// Create a simple layout
LinearLayout contentView = new LinearLayout(this);
@@ -216,7 +224,7 @@ public class ConnectivityManagerTestActivity extends Activity {
initializeNetworkStates();
if (mWifiManager.isWifiEnabled()) {
Log.v(LOG_TAG, "Clear Wifi before we start the test.");
log("Clear Wifi before we start the test.");
removeConfiguredNetworksAndDisableWifi();
}
mWifiRegexs = mCM.getTetherableWifiRegexs();
@@ -240,9 +248,9 @@ public class ConnectivityManagerTestActivity extends Activity {
private void printNetConfig(String[] configuration) {
for (int i = 0; i < configuration.length; i++) {
if (i == 0) {
Log.v(LOG_TAG, "SSID: " + configuration[0]);
log("SSID: " + configuration[0]);
} else {
Log.v(LOG_TAG, " " + configuration[i]);
log(" " + configuration[i]);
}
}
}
@@ -251,14 +259,14 @@ public class ConnectivityManagerTestActivity extends Activity {
public void initializeNetworkStates() {
for (int networkType = NUM_NETWORK_TYPES - 1; networkType >=0; networkType--) {
connectivityState[networkType] = new NetworkState();
Log.v(LOG_TAG, "Initialize network state for " + networkType + ": " +
log("Initialize network state for " + networkType + ": " +
connectivityState[networkType].toString());
}
}
// deposit a network state
public void recordNetworkState(int networkType, State networkState) {
Log.v(LOG_TAG, "record network state for network " + networkType +
log("record network state for network " + networkType +
", state is " + networkState);
connectivityState[networkType].recordState(networkState);
}
@@ -272,40 +280,41 @@ public class ConnectivityManagerTestActivity extends Activity {
// Validate the states recorded
public boolean validateNetworkStates(int networkType) {
Log.v(LOG_TAG, "validate network state for " + networkType + ": ");
log("validate network state for " + networkType + ": ");
return connectivityState[networkType].validateStateTransition();
}
// return result from network state validation
public String getTransitionFailureReason(int networkType) {
Log.v(LOG_TAG, "get network state transition failure reason for " + networkType + ": " +
log("get network state transition failure reason for " + networkType + ": " +
connectivityState[networkType].toString());
return connectivityState[networkType].getReason();
}
private void notifyNetworkConnectivityChange() {
synchronized(connectivityObject) {
Log.v(LOG_TAG, "notify network connectivity changed");
log("notify network connectivity changed");
connectivityObject.notifyAll();
}
}
private void notifyScanResult() {
synchronized (this) {
Log.v(LOG_TAG, "notify that scan results are available");
log("notify that scan results are available");
scanResultAvailable = true;
this.notify();
}
}
private void notifyWifiState() {
synchronized (wifiObject) {
Log.v(LOG_TAG, "notify wifi state changed");
log("notify wifi state changed");
wifiObject.notify();
}
}
private void notifyWifiAPState() {
synchronized (this) {
Log.v(LOG_TAG, "notify wifi AP state changed");
log("notify wifi AP state changed");
this.notify();
}
}
@@ -319,7 +328,7 @@ public class ConnectivityManagerTestActivity extends Activity {
for (Object obj: tethered) {
String str = (String)obj;
for (String tethRex: mWifiRegexs) {
Log.v(LOG_TAG, "str: " + str +"tethRex: " + tethRex);
log("str: " + str +"tethRex: " + tethRex);
if (str.matches(tethRex)) {
wifiTethered = true;
}
@@ -329,7 +338,7 @@ public class ConnectivityManagerTestActivity extends Activity {
for (Object obj: errored) {
String str = (String)obj;
for (String tethRex: mWifiRegexs) {
Log.v(LOG_TAG, "error: str: " + str +"tethRex: " + tethRex);
log("error: str: " + str +"tethRex: " + tethRex);
if (str.matches(tethRex)) {
wifiErrored = true;
}
@@ -341,7 +350,7 @@ public class ConnectivityManagerTestActivity extends Activity {
} else if (wifiErrored) {
mWifiTetherResult = FAILURE; // wifi tethering failed
}
Log.v(LOG_TAG, "mWifiTetherResult: " + mWifiTetherResult);
log("mWifiTetherResult: " + mWifiTetherResult);
this.notify();
}
}
@@ -357,12 +366,12 @@ public class ConnectivityManagerTestActivity extends Activity {
return false;
} else {
// the broadcast has been sent out. the state has been changed.
Log.v(LOG_TAG, "networktype: " + networkType + " state: " +
log("networktype: " + networkType + " state: " +
mCM.getNetworkInfo(networkType));
return true;
}
}
Log.v(LOG_TAG, "Wait for the connectivity state for network: " + networkType +
log("Wait for the connectivity state for network: " + networkType +
" to be " + expectedState.toString());
synchronized (connectivityObject) {
try {
@@ -372,7 +381,7 @@ public class ConnectivityManagerTestActivity extends Activity {
}
if ((mNetworkInfo.getType() != networkType) ||
(mNetworkInfo.getState() != expectedState)) {
Log.v(LOG_TAG, "network state for " + mNetworkInfo.getType() +
log("network state for " + mNetworkInfo.getType() +
"is: " + mNetworkInfo.getState());
continue;
}
@@ -393,7 +402,7 @@ public class ConnectivityManagerTestActivity extends Activity {
return true;
}
}
Log.v(LOG_TAG, "Wait for wifi state to be: " + expectedState);
log("Wait for wifi state to be: " + expectedState);
synchronized (wifiObject) {
try {
wifiObject.wait(SHORT_TIMEOUT);
@@ -401,7 +410,7 @@ public class ConnectivityManagerTestActivity extends Activity {
e.printStackTrace();
}
if (mWifiState != expectedState) {
Log.v(LOG_TAG, "Wifi state is: " + mWifiState);
log("Wifi state is: " + mWifiState);
continue;
}
return true;
@@ -421,7 +430,7 @@ public class ConnectivityManagerTestActivity extends Activity {
return true;
}
}
Log.v(LOG_TAG, "Wait for wifi AP state to be: " + expectedState);
log("Wait for wifi AP state to be: " + expectedState);
synchronized (wifiObject) {
try {
wifiObject.wait(SHORT_TIMEOUT);
@@ -429,7 +438,7 @@ public class ConnectivityManagerTestActivity extends Activity {
e.printStackTrace();
}
if (mWifiManager.getWifiApState() != expectedState) {
Log.v(LOG_TAG, "Wifi state is: " + mWifiManager.getWifiApState());
log("Wifi state is: " + mWifiManager.getWifiApState());
continue;
}
return true;
@@ -449,7 +458,7 @@ public class ConnectivityManagerTestActivity extends Activity {
if ((System.currentTimeMillis() - startTime) > timeout) {
return mWifiTetherResult;
}
Log.v(LOG_TAG, "Wait for wifi tethering result.");
log("Wait for wifi tethering result.");
synchronized (this) {
try {
this.wait(SHORT_TIMEOUT);
@@ -479,6 +488,64 @@ public class ConnectivityManagerTestActivity extends Activity {
return mWifiManager.setWifiEnabled(true);
}
// Turn screen off
public void turnScreenOff() {
log("Turn screen off");
PowerManager pm =
(PowerManager) getSystemService(Context.POWER_SERVICE);
pm.goToSleep(SystemClock.uptimeMillis() + 100);
}
// Turn screen on
public void turnScreenOn() {
log("Turn screen on");
IPowerManager mPowerManagerService = IPowerManager.Stub.asInterface(
ServiceManager.getService("power"));;
try {
mPowerManagerService.userActivityWithForce(SystemClock.uptimeMillis(), false, true);
} catch (Exception e) {
log(e.toString());
}
}
/**
* @param pingServerList a list of servers that can be used for ping test, can be null
* @return true if the ping test is successful, false otherwise.
*/
public boolean pingTest(String[] pingServerList) {
boolean result = false;
String[] hostList = {"www.google.com", "www.yahoo.com",
"www.bing.com", "www.facebook.com", "www.ask.com"};
if (pingServerList != null) {
hostList = pingServerList;
}
try {
// assume the chance that all servers are down is very small
for (int i = 0; i < hostList.length; i++ ) {
String host = hostList[i];
log("Start ping test, ping " + host);
Process p = Runtime.getRuntime().exec("ping -c 10 -w 100 " + host);
int status = p.waitFor();
if (status == 0) {
// if any of the ping test is successful, return true
result = true;
break;
} else {
result = false;
log("ping " + host + " failed.");
}
}
} catch (UnknownHostException e) {
log("Ping test Fail: Unknown Host");
} catch (IOException e) {
log("Ping test Fail: IOException");
} catch (InterruptedException e) {
log("Ping test Fail: InterruptedException");
}
log("return");
return result;
}
/**
* Associate the device to given SSID
* If the device is already associated with a WiFi, disconnect and forget it,
@@ -503,13 +570,13 @@ public class ConnectivityManagerTestActivity extends Activity {
//If Wifi is not enabled, enable it
if (!mWifiManager.isWifiEnabled()) {
Log.v(LOG_TAG, "Wifi is not enabled, enable it");
log("Wifi is not enabled, enable it");
mWifiManager.setWifiEnabled(true);
}
List<ScanResult> netList = mWifiManager.getScanResults();
if (netList == null) {
Log.v(LOG_TAG, "scan results are null");
log("scan results are null");
// if no scan results are available, start active scan
mWifiManager.startScanActive();
mScanResultIsAvailable = false;
@@ -540,7 +607,7 @@ public class ConnectivityManagerTestActivity extends Activity {
for (int i = 0; i < netList.size(); i++) {
ScanResult sr= netList.get(i);
if (sr.SSID.equals(ssid)) {
Log.v(LOG_TAG, "found " + ssid + " in the scan result list");
log("found " + ssid + " in the scan result list");
int networkId = mWifiManager.addNetwork(config);
// Connect to network by disabling others.
mWifiManager.enableNetwork(networkId, true);
@@ -552,7 +619,7 @@ public class ConnectivityManagerTestActivity extends Activity {
List<WifiConfiguration> netConfList = mWifiManager.getConfiguredNetworks();
if (netConfList.size() <= 0) {
Log.v(LOG_TAG, ssid + " is not available");
log(ssid + " is not available");
return false;
}
return true;
@@ -575,7 +642,7 @@ public class ConnectivityManagerTestActivity extends Activity {
// remove other saved networks
List<WifiConfiguration> netConfList = mWifiManager.getConfiguredNetworks();
if (netConfList != null) {
Log.v(LOG_TAG, "remove configured network ids");
log("remove configured network ids");
for (int i = 0; i < netConfList.size(); i++) {
WifiConfiguration conf = new WifiConfiguration();
conf = netConfList.get(i);
@@ -640,7 +707,7 @@ public class ConnectivityManagerTestActivity extends Activity {
if (mWifiReceiver != null) {
unregisterReceiver(mWifiReceiver);
}
Log.v(LOG_TAG, "onDestroy, inst=" + Integer.toHexString(hashCode()));
log("onDestroy, inst=" + Integer.toHexString(hashCode()));
}
@Override
@@ -682,5 +749,8 @@ public class ConnectivityManagerTestActivity extends Activity {
}
return super.onKeyDown(keyCode, event);
}
}
private void log(String message) {
Log.v(LOG_TAG, message);
}
}

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

@@ -19,25 +19,33 @@ package com.android.connectivitymanagertest.stress;
import com.android.connectivitymanagertest.ConnectivityManagerStressTestRunner;
import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
import com.android.connectivitymanagertest.ConnectivityManagerTestRunner;
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.test.ActivityInstrumentationTestCase2;
import android.test.suitebuilder.annotation.LargeTest;
import android.util.Log;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
/**
* Stress the wifi driver as access point.
*/
public class WifiApStress
extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
private final static String TAG = "WifiApStress";
private ConnectivityManagerTestActivity mAct;
private static String NETWORK_ID = "AndroidAPTest";
private static String PASSWD = "androidwifi";
private int max_num;
private final static String OUTPUT_FILE = "WifiStressTestOutput.txt";
private ConnectivityManagerTestActivity mAct;
private int iterations;
private BufferedWriter mOutputWriter = null;
private int mLastIteration = 0;
public WifiApStress() {
super(ConnectivityManagerTestActivity.class);
@@ -47,11 +55,20 @@ public class WifiApStress
public void setUp() throws Exception {
super.setUp();
mAct = getActivity();
max_num = ((ConnectivityManagerStressTestRunner)getInstrumentation()).numStress;
ConnectivityManagerStressTestRunner mRunner =
(ConnectivityManagerStressTestRunner)getInstrumentation();
iterations = mRunner.mSoftapIterations;
mAct.turnScreenOn();
}
@Override
public void tearDown() throws Exception {
// write the total number of iterations into output file
mOutputWriter = new BufferedWriter(new FileWriter(new File(
Environment.getExternalStorageDirectory(), OUTPUT_FILE)));
mOutputWriter.write(String.format("iteration %d out of %d\n", mLastIteration, iterations));
mOutputWriter.flush();
mOutputWriter.close();
super.tearDown();
}
@@ -67,22 +84,38 @@ public class WifiApStress
if (mAct.mWifiManager.isWifiEnabled()) {
mAct.disableWifi();
}
for (int i = 0; i < max_num; i++) {
int i;
for (i = 0; i < iterations; i++) {
Log.v(TAG, "iteration: " + i);
mLastIteration = i;
// enable Wifi tethering
assertTrue(mAct.mWifiManager.setWifiApEnabled(config, true));
// Wait for wifi ap state to be ENABLED
assertTrue(mAct.waitForWifiAPState(mAct.mWifiManager.WIFI_AP_STATE_ENABLED,
mAct.LONG_TIMEOUT));
assertTrue(mAct.waitForWifiAPState(WifiManager.WIFI_AP_STATE_ENABLED,
ConnectivityManagerTestActivity.LONG_TIMEOUT));
// Wait for wifi tethering result
assertEquals(mAct.SUCCESS, mAct.waitForTetherStateChange(2*mAct.SHORT_TIMEOUT));
assertEquals(ConnectivityManagerTestActivity.SUCCESS,
mAct.waitForTetherStateChange(2*ConnectivityManagerTestActivity.SHORT_TIMEOUT));
// Allow the wifi tethering to be enabled for 10 seconds
try {
Thread.sleep(2 * ConnectivityManagerTestActivity.SHORT_TIMEOUT);
} catch (Exception e) {
fail("thread in sleep is interrupted");
}
assertTrue("no uplink data connection after Wi-Fi tethering", mAct.pingTest(null));
// Disable soft AP
assertTrue(mAct.mWifiManager.setWifiApEnabled(config, false));
// Wait for 30 seconds until Wi-Fi tethering is stopped
try {
Thread.sleep(30 * 1000);
Log.v(TAG, "wait for Wi-Fi tethering to be disabled.");
} catch (Exception e) {
fail("thread in sleep is interrupted");
}
assertFalse("Wi-Fi AP disable failed", mAct.mWifiManager.isWifiApEnabled());
}
if (i == iterations) {
mLastIteration = iterations;
}
}

285
core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/stress/WifiStressTest.java Normal file
View File

@@ -0,0 +1,285 @@
/*
* Copyright (C) 2010, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.connectivitymanagertest.stress;
import com.android.connectivitymanagertest.ConnectivityManagerStressTestRunner;
import com.android.connectivitymanagertest.ConnectivityManagerTestActivity;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo.State;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiConfiguration.KeyMgmt;
import android.net.wifi.WifiManager;
import android.os.Environment;
import android.os.PowerManager;
import android.provider.Settings;
import android.test.ActivityInstrumentationTestCase2;
import android.test.suitebuilder.annotation.LargeTest;
import android.util.Log;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.List;
/**
* Stress Wi-Fi connection, scanning and reconnection after sleep.
*
* To run this stress test suite, type
* adb shell am instrument -e class com.android.connectivitymanagertest.stress.WifiStressTest
* -w com.android.connectivitymanagertest/.ConnectivityManagerStressTestRunner
*/
public class WifiStressTest
extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> {
private final static String TAG = "WifiStressTest";
/**
* Wi-Fi idle time for default sleep policy
*/
private final static long WIFI_IDLE_MS = 60 * 1000;
/**
* The delay for Wi-Fi to get into idle, after screen off + WIFI_IDEL_MS + WIFI_IDLE_DELAY
* the Wi-Fi should be in idle mode and device should be in cellular mode.
*/
private final static long WIFI_IDLE_DELAY = 3 * 1000;
private final static String OUTPUT_FILE = "WifiStressTestOutput.txt";
private ConnectivityManagerTestActivity mAct;
private int mReconnectIterations;
private int mWifiSleepTime;
private int mScanIterations;
private String mSsid;
private String mPassword;
private ConnectivityManagerStressTestRunner mRunner;
private BufferedWriter mOutputWriter = null;
public WifiStressTest() {
super(ConnectivityManagerTestActivity.class);
}
@Override
public void setUp() throws Exception {
super.setUp();
mAct = getActivity();
mRunner = (ConnectivityManagerStressTestRunner) getInstrumentation();
mReconnectIterations = mRunner.mReconnectIterations;
mSsid = mRunner.mReconnectSsid;
mPassword = mRunner.mReconnectPassword;
mScanIterations = mRunner.mScanIterations;
mWifiSleepTime = mRunner.mSleepTime;
mOutputWriter = new BufferedWriter(new FileWriter(new File(
Environment.getExternalStorageDirectory(), OUTPUT_FILE), true));
if (!mAct.mWifiManager.isWifiEnabled()) {
if (!mAct.enableWifi()) {
tearDown();
fail("enable wifi failed.");
}
sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT,
"Interruped while waiting for wifi on");
}
}
@Override
public void tearDown() throws Exception {
log("tearDown()");
if (mOutputWriter != null) {
mOutputWriter.close();
}
super.tearDown();
}
private void writeOutput(String s) {
log("write message: " + s);
if (mOutputWriter == null) {
log("no writer attached to file " + OUTPUT_FILE);
return;
}
try {
mOutputWriter.write(s + "\n");
mOutputWriter.flush();
} catch (IOException e) {
log("failed to write output.");
}
}
public void log(String message) {
Log.v(TAG, message);
}
private void sleep(long sometime, String errorMsg) {
try {
Thread.sleep(sometime);
} catch (InterruptedException e) {
fail(errorMsg);
}
}
/**
* Stress Wifi Scanning
* TODO: test the scanning quality for each frequency band
*/
@LargeTest
public void testWifiScanning() {
int scanTimeSum = 0;
int i;
int ssidAppearInScanResultsCount = 0; // count times of given ssid appear in scan results.
for (i = 0; i < mScanIterations; i++) {
log("testWifiScanning: iteration: " + i);
int averageScanTime = 0;
if (i > 0) {
averageScanTime = scanTimeSum/i;
}
writeOutput(String.format("iteration %d out of %d",
i, mScanIterations));
writeOutput(String.format("average scanning time is %d", averageScanTime));
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.startScanActive());
while (true) {
if ((System.currentTimeMillis() - startTime) >
ConnectivityManagerTestActivity.WIFI_SCAN_TIMEOUT) {
fail("Wifi scanning takes more than " +
ConnectivityManagerTestActivity.WIFI_SCAN_TIMEOUT + " ms");
}
synchronized(mAct) {
try {
mAct.wait(ConnectivityManagerTestActivity.WAIT_FOR_SCAN_RESULT);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (mAct.scanResultAvailable) {
long scanTime = (System.currentTimeMillis() - startTime);
scanTimeSum += scanTime;
break;
}
}
}
if ((mAct.mWifiManager.getScanResults() == null) ||
(mAct.mWifiManager.getScanResults().size() <= 0)) {
fail("Scan results are empty ");
}
List<ScanResult> netList = mAct.mWifiManager.getScanResults();
if (netList != null) {
log("size of scan result list: " + netList.size());
for (int s = 0; s < netList.size(); s++) {
ScanResult sr= netList.get(s);
log(String.format("scan result for %s is: %s", sr.SSID, sr.toString()));
log(String.format("signal level for %s is %d ", sr.SSID, sr.level));
if (sr.SSID.equals(mSsid)) {
ssidAppearInScanResultsCount += 1;
log("Number of times " + mSsid + " appear in the scan list: " +
ssidAppearInScanResultsCount);
break;
}
}
}
}
if (i == mScanIterations) {
writeOutput(String.format("iteration %d out of %d",
i, mScanIterations));
writeOutput(String.format("average scanning time is %d", scanTimeSum/mScanIterations));
writeOutput(String.format("ssid appear %d out of %d scan iterations",
ssidAppearInScanResultsCount, mScanIterations));
}
}
// Stress Wifi reconnection to secure net after sleep
@LargeTest
public void testWifiReconnectionAfterSleep() {
int value = Settings.System.getInt(mRunner.getContext().getContentResolver(),
Settings.System.WIFI_SLEEP_POLICY, -1);
if (value < 0) {
Settings.System.putInt(mRunner.getContext().getContentResolver(),
Settings.System.WIFI_SLEEP_POLICY, Settings.System.WIFI_SLEEP_POLICY_DEFAULT);
log("set wifi sleep policy to default value");
}
Settings.Secure.putLong(mRunner.getContext().getContentResolver(),
Settings.Secure.WIFI_IDLE_MS, WIFI_IDLE_MS);
// Connect to a Wi-Fi network
WifiConfiguration config = new WifiConfiguration();
config.SSID = mSsid;
config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
if (mPassword.matches("[0-9A-Fa-f]{64}")) {
config.preSharedKey = mPassword;
} else {
config.preSharedKey = '"' + mPassword + '"';
}
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.LONG_TIMEOUT));
// Run ping test to verify the data connection
assertTrue("Wi-Fi is connected, but no data connection.", mAct.pingTest(null));
int i;
for (i = 0; i < mReconnectIterations; i++) {
// 1. Put device into sleep mode
// 2. Wait for the device to sleep for sometime, verify wi-fi is off and mobile is on.
// 3. Maintain the sleep mode for some time,
// 4. Verify the Wi-Fi is still off, and data is on
// 5. Wake up the device, verify Wi-Fi is enabled and connected.
writeOutput(String.format("iteration %d out of %d",
i, mReconnectIterations));
log("iteration: " + i);
mAct.turnScreenOff();
PowerManager pm =
(PowerManager)mRunner.getContext().getSystemService(Context.POWER_SERVICE);
assertFalse(pm.isScreenOn());
sleep(WIFI_IDLE_MS, "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));
// use long timeout as the pppd startup may take several retries.
assertTrue("Wait for cellular connection timeout",
mAct.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED,
ConnectivityManagerTestActivity.LONG_TIMEOUT));
sleep(mWifiSleepTime + WIFI_IDLE_DELAY, "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());
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));
// Turn screen on again
mAct.turnScreenOn();
assertTrue("Wait for Wi-Fi enable timeout after wake up",
mAct.waitForWifiState(WifiManager.WIFI_STATE_ENABLED,
ConnectivityManagerTestActivity.SHORT_TIMEOUT));
assertTrue("Wait for Wi-Fi connection timeout after wake up",
mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED,
ConnectivityManagerTestActivity.LONG_TIMEOUT));
assertTrue("Reconnect to Wi-Fi network, but no data connection.", mAct.pingTest(null));
}
if (i == mReconnectIterations) {
writeOutput(String.format("iteration %d out of %d",
i, mReconnectIterations));
}
}
}