/* * 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 android.app.Activity; import android.content.Context; import android.net.ConnectivityManager; import android.net.NetworkInfo; import android.net.NetworkInfo.State; import android.net.wifi.ScanResult; import android.net.wifi.WifiConfiguration; import android.net.wifi.WifiManager; import android.os.Bundle; import android.os.Environment; import android.os.PowerManager; import android.os.SystemClock; import android.provider.Settings; import android.test.suitebuilder.annotation.LargeTest; import android.util.Log; import com.android.connectivitymanagertest.ConnectivityManagerStressTestRunner; import com.android.connectivitymanagertest.ConnectivityManagerTestBase; import com.android.connectivitymanagertest.WifiConfigurationHelper; 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 ConnectivityManagerTestBase { private final static long SCREEN_OFF_TIMER = 500; //500ms /** * Wi-Fi idle time for default sleep policy */ private final static long WIFI_IDLE_MS = 15 * 1000; /** * Delay after issuing wifi shutdown. * The framework keep driver up for at leat 2 minutes to avoid problems * that a quick shutdown could cause on wext driver and protentially * on cfg based driver */ private final static long WIFI_SHUTDOWN_DELAY = 2 * 60 * 1000; private final static String OUTPUT_FILE = "WifiStressTestOutput.txt"; private int mReconnectIterations; private long mWifiSleepTime; private int mScanIterations; private String mSsid; private String mPassword; private ConnectivityManagerStressTestRunner mRunner; private BufferedWriter mOutputWriter = null; private boolean mWifiOnlyFlag; public WifiStressTest() { super(WifiStressTest.class.getSimpleName()); } @Override protected void setUp() throws Exception { super.setUp(); mRunner = (ConnectivityManagerStressTestRunner) getInstrumentation(); mReconnectIterations = mRunner.getReconnectIterations(); mSsid = mRunner.getReconnectSsid(); mPassword = mRunner.getReconnectPassword(); mScanIterations = mRunner.getScanIterations(); mWifiSleepTime = mRunner.getSleepTime(); mWifiOnlyFlag = mRunner.isWifiOnly(); logv(String.format("mReconnectIterations(%d), mSsid(%s), mPassword(%s)," + "mScanIterations(%d), mWifiSleepTime(%d)", mReconnectIterations, mSsid, mPassword, mScanIterations, mWifiSleepTime)); mOutputWriter = new BufferedWriter(new FileWriter(new File( Environment.getExternalStorageDirectory(), OUTPUT_FILE), true)); turnScreenOn(); if (!mWifiManager.isWifiEnabled()) { logv("Enable wi-fi before stress tests."); if (!enableWifi()) { tearDown(); fail("enable wifi failed."); } sleep(SHORT_TIMEOUT, "Interruped while waiting for wifi on"); } } @Override protected void tearDown() throws Exception { logv("tearDown()"); if (mOutputWriter != null) { mOutputWriter.close(); } super.tearDown(); } private void writeOutput(String s) { logv("write message: " + s); if (mOutputWriter == null) { logv("no writer attached to file " + OUTPUT_FILE); return; } try { mOutputWriter.write(s + "\n"); mOutputWriter.flush(); } catch (IOException e) { logv("failed to write output."); } } 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() { long scanTimeSum = 0, i, averageScanTime = -1; int ssidAppearInScanResultsCount = 0; // count times of given ssid appear in scan results. for (i = 1; i <= mScanIterations; i++) { logv("testWifiScanning: iteration: " + i); 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)); List scanResultLocal = null; // wait for a scan result long start = 0; synchronized (mWifiScanResultLock) { start = SystemClock.uptimeMillis(); assertTrue("start scan failed", mWifiManager.startScan()); try { mWifiScanResultLock.wait(WAIT_FOR_SCAN_RESULT); } catch (InterruptedException e) { // ignore } scanTimeSum += SystemClock.uptimeMillis() - start; // save the scan result while in lock scanResultLocal = mLastScanResult; } if (scanResultLocal == null || scanResultLocal.isEmpty()) { fail("Scan results are empty "); } logv("size of scan result list: " + scanResultLocal.size()); for (ScanResult sr : scanResultLocal) { logv(String.format("scan result: " + sr.toString())); if (mSsid.equals(sr.SSID)) { ssidAppearInScanResultsCount += 1; break; } } } Bundle result = new Bundle(); result.putLong("actual-iterations", i - 1); result.putLong("avg-scan-time", averageScanTime); result.putInt("ap-discovered", ssidAppearInScanResultsCount); getInstrumentation().sendStatus(Activity.RESULT_FIRST_USER, result); if (i == mScanIterations + 1) { writeOutput(String.format("iteration %d out of %d", i - 1, mScanIterations)); writeOutput(String.format("average scanning time is %d", scanTimeSum / (i - 1))); writeOutput(String.format("ssid appear %d out of %d scan iterations", ssidAppearInScanResultsCount, i - 1)); } } // Stress Wifi reconnection to secure net after sleep @LargeTest public void testWifiReconnectionAfterSleep() { // set always scan to false Settings.Global.putInt(mRunner.getContext().getContentResolver(), Settings.Global.WIFI_SCAN_ALWAYS_AVAILABLE, 0); // set wifi sleep policy to never on while in sleep Settings.Global.putInt(mRunner.getContext().getContentResolver(), Settings.Global.WIFI_SLEEP_POLICY, Settings.Global.WIFI_SLEEP_POLICY_DEFAULT); // set idle timeout for wifi to 15s Settings.Global.putLong(mRunner.getContext().getContentResolver(), Settings.Global.WIFI_IDLE_MS, WIFI_IDLE_MS); WifiConfiguration config; if (mPassword == null) { config = WifiConfigurationHelper.createOpenConfig(mSsid); } else { config = WifiConfigurationHelper.createPskConfig(mSsid, mPassword); } assertTrue("Failed to connect to Wi-Fi network: " + mSsid, connectToWifiWithConfiguration(config)); assertTrue("wifi not connected", 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.", pingTest()); long i, sum = 0, avgReconnectTime = 0; for (i = 1; 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)); logv("iteration: " + i); turnScreenOff(); // Use clock time since boot for intervals. long start = SystemClock.uptimeMillis(); PowerManager pm = (PowerManager)mRunner.getContext().getSystemService(Context.POWER_SERVICE); while (pm.isInteractive() && ((SystemClock.uptimeMillis() - start) < SCREEN_OFF_TIMER)) { SystemClock.sleep(100); } assertFalse("screen still on", pm.isInteractive()); // wait for WiFi timeout SystemClock.sleep(WIFI_IDLE_MS + WIFI_SHUTDOWN_DELAY); // below check temporarily disabled due to bug in ConnectivityManager return // assertTrue("Wait for Wi-Fi to idle timeout", // waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.DISCONNECTED, // 6 * SHORT_TIMEOUT)); if (mWifiOnlyFlag) { assertTrue("expected wifi disconnect, still has active connection", waitUntilNoActiveNetworkConnection(2 * LONG_TIMEOUT)); } else { // use long timeout as the pppd startup may take several retries. assertTrue("no fallback on mobile or wifi didn't disconnect", waitForNetworkState(ConnectivityManager.TYPE_MOBILE, State.CONNECTED, 2 * LONG_TIMEOUT)); } SystemClock.sleep(mWifiSleepTime); // verify the wi-fi is still off and either we have no connectivity or fallback on mobile if (mWifiOnlyFlag) { NetworkInfo ni = mCm.getActiveNetworkInfo(); if (ni != null) { Log.e(mLogTag, "has active network while in wifi sleep: " + ni.toString()); fail("active network detected"); } } else { assertEquals("mobile not connected", State.CONNECTED, mCm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState()); assertTrue("no connectivity over mobile", pingTest()); } // Turn screen on again turnScreenOn(); // Measure the time for Wi-Fi to get connected long startTime = SystemClock.uptimeMillis(); assertTrue("screen on: wifi not enabled before timeout", waitForWifiState(WifiManager.WIFI_STATE_ENABLED, SHORT_TIMEOUT)); assertTrue("screen on: wifi not connected before timeout", waitForNetworkState(ConnectivityManager.TYPE_WIFI, State.CONNECTED, LONG_TIMEOUT)); long connectionTime = SystemClock.uptimeMillis() - startTime; sum += connectionTime; avgReconnectTime = sum / i; logv("average reconnection time is: " + avgReconnectTime); assertTrue("Reconnect to Wi-Fi network, but no data connection.", pingTest()); } Bundle result = new Bundle(); result.putLong("actual-iterations", i - 1); result.putLong("avg-reconnect-time", avgReconnectTime); getInstrumentation().sendStatus(Activity.RESULT_FIRST_USER, result); if (i == mReconnectIterations + 1) { writeOutput(String.format("iteration %d out of %d", i - 1, mReconnectIterations)); } } }