WifiStressTest.java revision 4bc5c4a1f5ea529ef7c7b38ee3782c8f209f7b9c
1/* 2 * Copyright (C) 2010, The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.connectivitymanagertest.stress; 18 19import com.android.connectivitymanagertest.ConnectivityManagerStressTestRunner; 20import com.android.connectivitymanagertest.ConnectivityManagerTestActivity; 21import com.android.connectivitymanagertest.UtilHelper; 22 23import android.content.Context; 24import android.net.ConnectivityManager; 25import android.net.NetworkInfo.State; 26import android.net.wifi.ScanResult; 27import android.net.wifi.WifiConfiguration; 28import android.net.wifi.WifiConfiguration.IpAssignment; 29import android.net.wifi.WifiConfiguration.KeyMgmt; 30import android.net.wifi.WifiConfiguration.ProxySettings; 31import android.net.wifi.WifiManager; 32import android.os.Environment; 33import android.os.PowerManager; 34import android.os.IPowerManager; 35import android.os.SystemClock; 36import android.os.ServiceManager; 37import android.provider.Settings; 38import android.test.ActivityInstrumentationTestCase2; 39import android.test.suitebuilder.annotation.LargeTest; 40 41import android.util.Log; 42 43import java.io.BufferedWriter; 44import java.io.File; 45import java.io.FileWriter; 46import java.io.IOException; 47import java.util.List; 48 49/** 50 * Stress Wi-Fi connection, scanning and reconnection after sleep. 51 * 52 * To run this stress test suite, type 53 * adb shell am instrument -e class com.android.connectivitymanagertest.stress.WifiStressTest 54 * -w com.android.connectivitymanagertest/.ConnectivityManagerStressTestRunner 55 */ 56public class WifiStressTest 57 extends ActivityInstrumentationTestCase2<ConnectivityManagerTestActivity> { 58 private final static String TAG = "WifiStressTest"; 59 60 /** 61 * Wi-Fi idle time for default sleep policy 62 */ 63 private final static long WIFI_IDLE_MS = 60 * 1000; 64 65 /** 66 * The delay for Wi-Fi to get into idle, after screen off + WIFI_IDEL_MS + WIFI_IDLE_DELAY 67 * the Wi-Fi should be in idle mode and device should be in cellular mode. 68 */ 69 private final static long WIFI_IDLE_DELAY = 3 * 1000; 70 71 private final static String OUTPUT_FILE = "WifiStressTestOutput.txt"; 72 private ConnectivityManagerTestActivity mAct; 73 private int mReconnectIterations; 74 private int mWifiSleepTime; 75 private int mScanIterations; 76 private String mSsid; 77 private String mPassword; 78 private ConnectivityManagerStressTestRunner mRunner; 79 private BufferedWriter mOutputWriter = null; 80 81 public WifiStressTest() { 82 super(ConnectivityManagerTestActivity.class); 83 } 84 85 @Override 86 public void setUp() throws Exception { 87 super.setUp(); 88 mAct = getActivity(); 89 mRunner = (ConnectivityManagerStressTestRunner) getInstrumentation(); 90 mReconnectIterations = mRunner.mReconnectIterations; 91 mSsid = mRunner.mReconnectSsid; 92 mPassword = mRunner.mReconnectPassword; 93 mScanIterations = mRunner.mScanIterations; 94 mWifiSleepTime = mRunner.mSleepTime; 95 mOutputWriter = new BufferedWriter(new FileWriter(new File( 96 Environment.getExternalStorageDirectory(), OUTPUT_FILE), true)); 97 mAct.turnScreenOn(); 98 if (!mAct.mWifiManager.isWifiEnabled()) { 99 log("Enable wi-fi before stress tests."); 100 if (!mAct.enableWifi()) { 101 tearDown(); 102 fail("enable wifi failed."); 103 } 104 sleep(ConnectivityManagerTestActivity.SHORT_TIMEOUT, 105 "Interruped while waiting for wifi on"); 106 } 107 } 108 109 @Override 110 public void tearDown() throws Exception { 111 log("tearDown()"); 112 if (mOutputWriter != null) { 113 mOutputWriter.close(); 114 } 115 super.tearDown(); 116 } 117 118 private void writeOutput(String s) { 119 log("write message: " + s); 120 if (mOutputWriter == null) { 121 log("no writer attached to file " + OUTPUT_FILE); 122 return; 123 } 124 try { 125 mOutputWriter.write(s + "\n"); 126 mOutputWriter.flush(); 127 } catch (IOException e) { 128 log("failed to write output."); 129 } 130 } 131 132 public void log(String message) { 133 Log.v(TAG, message); 134 } 135 136 private void sleep(long sometime, String errorMsg) { 137 try { 138 Thread.sleep(sometime); 139 } catch (InterruptedException e) { 140 fail(errorMsg); 141 } 142 } 143 144 /** 145 * Stress Wifi Scanning 146 * TODO: test the scanning quality for each frequency band 147 */ 148 @LargeTest 149 public void testWifiScanning() { 150 int scanTimeSum = 0; 151 int i; 152 int ssidAppearInScanResultsCount = 0; // count times of given ssid appear in scan results. 153 for (i = 0; i < mScanIterations; i++) { 154 log("testWifiScanning: iteration: " + i); 155 int averageScanTime = 0; 156 if (i > 0) { 157 averageScanTime = scanTimeSum/i; 158 } 159 writeOutput(String.format("iteration %d out of %d", 160 i, mScanIterations)); 161 writeOutput(String.format("average scanning time is %d", averageScanTime)); 162 writeOutput(String.format("ssid appear %d out of %d scan iterations", 163 ssidAppearInScanResultsCount, i)); 164 long startTime = System.currentTimeMillis(); 165 mAct.scanResultAvailable = false; 166 assertTrue("start scan failed", mAct.mWifiManager.startScanActive()); 167 while (true) { 168 if ((System.currentTimeMillis() - startTime) > 169 ConnectivityManagerTestActivity.WIFI_SCAN_TIMEOUT) { 170 fail("Wifi scanning takes more than " + 171 ConnectivityManagerTestActivity.WIFI_SCAN_TIMEOUT + " ms"); 172 } 173 synchronized(mAct) { 174 try { 175 mAct.wait(ConnectivityManagerTestActivity.WAIT_FOR_SCAN_RESULT); 176 } catch (InterruptedException e) { 177 e.printStackTrace(); 178 } 179 if (mAct.scanResultAvailable) { 180 long scanTime = (System.currentTimeMillis() - startTime); 181 scanTimeSum += scanTime; 182 break; 183 } 184 } 185 } 186 if ((mAct.mWifiManager.getScanResults() == null) || 187 (mAct.mWifiManager.getScanResults().size() <= 0)) { 188 fail("Scan results are empty "); 189 } 190 191 List<ScanResult> netList = mAct.mWifiManager.getScanResults(); 192 if (netList != null) { 193 log("size of scan result list: " + netList.size()); 194 for (int s = 0; s < netList.size(); s++) { 195 ScanResult sr= netList.get(s); 196 log(String.format("scan result for %s is: %s", sr.SSID, sr.toString())); 197 log(String.format("signal level for %s is %d ", sr.SSID, sr.level)); 198 if (sr.SSID.equals(mSsid)) { 199 ssidAppearInScanResultsCount += 1; 200 log("Number of times " + mSsid + " appear in the scan list: " + 201 ssidAppearInScanResultsCount); 202 break; 203 } 204 } 205 } 206 } 207 if (i == mScanIterations) { 208 writeOutput(String.format("iteration %d out of %d", 209 i, mScanIterations)); 210 writeOutput(String.format("average scanning time is %d", scanTimeSum/mScanIterations)); 211 writeOutput(String.format("ssid appear %d out of %d scan iterations", 212 ssidAppearInScanResultsCount, mScanIterations)); 213 } 214 } 215 216 // Stress Wifi reconnection to secure net after sleep 217 @LargeTest 218 public void testWifiReconnectionAfterSleep() { 219 int value = Settings.System.getInt(mRunner.getContext().getContentResolver(), 220 Settings.System.WIFI_SLEEP_POLICY, -1); 221 if (value < 0) { 222 Settings.System.putInt(mRunner.getContext().getContentResolver(), 223 Settings.System.WIFI_SLEEP_POLICY, Settings.System.WIFI_SLEEP_POLICY_DEFAULT); 224 log("set wifi sleep policy to default value"); 225 } 226 Settings.Secure.putLong(mRunner.getContext().getContentResolver(), 227 Settings.Secure.WIFI_IDLE_MS, WIFI_IDLE_MS); 228 229 // Connect to a Wi-Fi network 230 WifiConfiguration config = new WifiConfiguration(); 231 config.SSID = mSsid; 232 config.allowedKeyManagement.set(KeyMgmt.WPA_PSK); 233 if (mPassword.matches("[0-9A-Fa-f]{64}")) { 234 config.preSharedKey = mPassword; 235 } else { 236 config.preSharedKey = '"' + mPassword + '"'; 237 } 238 config.ipAssignment = IpAssignment.DHCP; 239 config.proxySettings = ProxySettings.NONE; 240 241 assertTrue("Failed to connect to Wi-Fi network: " + mSsid, 242 mAct.connectToWifiWithConfiguration(config)); 243 assertTrue(mAct.waitForWifiState(WifiManager.WIFI_STATE_ENABLED, 244 ConnectivityManagerTestActivity.SHORT_TIMEOUT)); 245 assertTrue(mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 246 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 247 // Run ping test to verify the data connection 248 assertTrue("Wi-Fi is connected, but no data connection.", mAct.pingTest(null)); 249 250 int i; 251 for (i = 0; i < mReconnectIterations; i++) { 252 // 1. Put device into sleep mode 253 // 2. Wait for the device to sleep for sometime, verify wi-fi is off and mobile is on. 254 // 3. Maintain the sleep mode for some time, 255 // 4. Verify the Wi-Fi is still off, and data is on 256 // 5. Wake up the device, verify Wi-Fi is enabled and connected. 257 writeOutput(String.format("iteration %d out of %d", 258 i, mReconnectIterations)); 259 log("iteration: " + i); 260 mAct.turnScreenOff(); 261 PowerManager pm = 262 (PowerManager)mRunner.getContext().getSystemService(Context.POWER_SERVICE); 263 assertFalse(pm.isScreenOn()); 264 sleep(WIFI_IDLE_MS, "Interruped while wait for wifi to be idle"); 265 assertTrue("Wait for Wi-Fi to idle timeout", 266 mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED, 267 6 * ConnectivityManagerTestActivity.SHORT_TIMEOUT)); 268 if (!UtilHelper.isWifiOnly()) { 269 // use long timeout as the pppd startup may take several retries. 270 assertTrue("Wait for cellular connection timeout", 271 mAct.waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED, 272 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 273 } 274 sleep(mWifiSleepTime + WIFI_IDLE_DELAY, "Interrupted while device is in sleep mode"); 275 // Verify the wi-fi is still off and data connection is on 276 assertEquals("Wi-Fi is reconnected", State.DISCONNECTED, 277 mAct.mCM.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState()); 278 279 if (!UtilHelper.isWifiOnly()) { 280 assertEquals("Cellular connection is down", State.CONNECTED, 281 mAct.mCM.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState()); 282 assertTrue("Mobile is connected, but no data connection.", mAct.pingTest(null)); 283 } 284 285 // Turn screen on again 286 mAct.turnScreenOn(); 287 assertTrue("Wait for Wi-Fi enable timeout after wake up", 288 mAct.waitForWifiState(WifiManager.WIFI_STATE_ENABLED, 289 ConnectivityManagerTestActivity.SHORT_TIMEOUT)); 290 assertTrue("Wait for Wi-Fi connection timeout after wake up", 291 mAct.waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, 292 ConnectivityManagerTestActivity.LONG_TIMEOUT)); 293 assertTrue("Reconnect to Wi-Fi network, but no data connection.", mAct.pingTest(null)); 294 } 295 if (i == mReconnectIterations) { 296 writeOutput(String.format("iteration %d out of %d", 297 i, mReconnectIterations)); 298 } 299 } 300} 301