--- /dev/null
+/*
+ * Copyright (C) 2009 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 android.net.wifi.cts;
+
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiManager;
+import android.net.wifi.WifiConfiguration.Status;
+import android.net.wifi.WifiManager.WifiLock;
+import android.test.AndroidTestCase;
+import android.util.Log;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+@TestTargetClass(WifiManager.class)
+public class WifiManagerTest extends AndroidTestCase {
+ private static class MySync {
+ int expectedState = STATE_NULL;
+ }
+
+ private WifiManager mWifiManager;
+ private WifiLock mWifiLock;
+ private static MySync mMySync;
+ private List<ScanResult> mScanResult = null;
+
+ // Please refer to WifiManager
+ private static final int MIN_RSSI = -100;
+ private static final int MAX_RSSI = -55;
+
+ private static final int STATE_NULL = 0;
+ private static final int STATE_WIFI_CHANGING = 1;
+ private static final int STATE_WIFI_CHANGED = 2;
+ private static final int STATE_SCANING = 3;
+ private static final int STATE_SCAN_RESULTS_AVAILABLE = 4;
+
+ private static final String TAG = "WifiManagerTest";
+ private static final String SSID1 = "\"WifiManagerTest\"";
+ private static final String SSID2 = "\"WifiManagerTestModified\"";
+ private static final int TIMEOUT_MSEC = 6000;
+ private static final int WAIT_MSEC = 60;
+ private static final int DURATION = 10000;
+ private IntentFilter mIntentFilter;
+ private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ final String action = intent.getAction();
+ if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
+ synchronized (mMySync) {
+ if (mWifiManager.getScanResults() != null) {
+ mScanResult = mWifiManager.getScanResults();
+ mMySync.expectedState = STATE_SCAN_RESULTS_AVAILABLE;
+ mScanResult = mWifiManager.getScanResults();
+ mMySync.notify();
+ }
+ }
+ } else if (action.equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) {
+ synchronized (mMySync) {
+ mMySync.expectedState = STATE_WIFI_CHANGED;
+ mMySync.notify();
+ }
+ }
+ }
+ };
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ mMySync = new MySync();
+ mIntentFilter = new IntentFilter();
+ mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+ mIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
+ mIntentFilter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
+ mIntentFilter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
+ mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
+ mIntentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
+ mIntentFilter.addAction(WifiManager.NETWORK_IDS_CHANGED_ACTION);
+ mIntentFilter.addAction(WifiManager.ACTION_PICK_WIFI_NETWORK);
+
+ mContext.registerReceiver(mReceiver, mIntentFilter);
+ mWifiManager = (WifiManager) getContext().getSystemService(Context.WIFI_SERVICE);
+ assertNotNull(mWifiManager);
+ mWifiLock = mWifiManager.createWifiLock(TAG);
+ mWifiLock.acquire();
+ if (!mWifiManager.isWifiEnabled())
+ setWifiEnabled(true);
+ Thread.sleep(DURATION);
+ assertTrue(mWifiManager.isWifiEnabled());
+ mMySync.expectedState = STATE_NULL;
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ mWifiLock.release();
+ mContext.unregisterReceiver(mReceiver);
+ if (!mWifiManager.isWifiEnabled())
+ setWifiEnabled(true);
+ Thread.sleep(DURATION);
+ super.tearDown();
+ }
+
+ private void setWifiEnabled(boolean enable) throws Exception {
+ synchronized (mMySync) {
+ mMySync.expectedState = STATE_WIFI_CHANGING;
+ assertTrue(mWifiManager.setWifiEnabled(enable));
+ long timeout = System.currentTimeMillis() + TIMEOUT_MSEC;
+ while (System.currentTimeMillis() < timeout
+ && mMySync.expectedState == STATE_WIFI_CHANGING)
+ mMySync.wait(WAIT_MSEC);
+ }
+ }
+
+ private void startScan() throws Exception {
+ synchronized (mMySync) {
+ mMySync.expectedState = STATE_SCANING;
+ assertTrue(mWifiManager.startScan());
+ long timeout = System.currentTimeMillis() + TIMEOUT_MSEC;
+ while (System.currentTimeMillis() < timeout && mMySync.expectedState == STATE_SCANING)
+ mMySync.wait(WAIT_MSEC);
+ }
+ }
+
+ private boolean existSSID(String ssid) {
+ for (final WifiConfiguration w : mWifiManager.getConfiguredNetworks()) {
+ if (w.SSID.equals(ssid))
+ return true;
+ }
+ return false;
+ }
+
+ private int findConfiguredNetworks(String SSID, List<WifiConfiguration> networks) {
+ for (final WifiConfiguration w : networks) {
+ if (w.SSID.equals(SSID))
+ return networks.indexOf(w);
+ }
+ return -1;
+ }
+
+ private void assertDisableOthers(WifiConfiguration wifiConfiguration, boolean disableOthers) {
+ for (WifiConfiguration w : mWifiManager.getConfiguredNetworks()) {
+ if ((!w.SSID.equals(wifiConfiguration.SSID)) && w.status != Status.CURRENT) {
+ if (disableOthers)
+ assertEquals(Status.DISABLED, w.status);
+ }
+ }
+ }
+
+ /**
+ * test point of wifiManager actions:
+ * 1.reconnect
+ * 2.reassociate
+ * 3.disconnect
+ * 4.pingSupplicant
+ * 5.satrtScan
+ */
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "isWifiEnabled",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "setWifiEnabled",
+ args = {boolean.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "startScan",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getScanResults",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "pingSupplicant",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "reassociate",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "reconnect",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "disconnect",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "createWifiLock",
+ args = {int.class, String.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "createWifiLock",
+ args = {String.class}
+ )
+ })
+ public void testWifiManagerActions() throws Exception {
+ assertTrue(mWifiManager.reconnect());
+ assertTrue(mWifiManager.reassociate());
+ assertTrue(mWifiManager.disconnect());
+ assertTrue(mWifiManager.pingSupplicant());
+ startScan();
+ setWifiEnabled(false);
+ Thread.sleep(DURATION);
+ assertFalse(mWifiManager.pingSupplicant());
+ final String TAG = "Test";
+ assertNotNull(mWifiManager.createWifiLock(TAG));
+ assertNotNull(mWifiManager.createWifiLock(WifiManager.WIFI_MODE_FULL, TAG));
+ }
+
+ /**
+ * test point of wifiManager properties:
+ * 1.enable properties
+ * 2.DhcpInfo properties
+ * 3.wifi state
+ * 4.ConnectionInfo
+ */
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "isWifiEnabled",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getWifiState",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "setWifiEnabled",
+ args = {boolean.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getConnectionInfo",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getDhcpInfo",
+ args = {}
+ )
+ })
+ public void testWifiManagerProperties() throws Exception {
+ setWifiEnabled(true);
+ assertTrue(mWifiManager.isWifiEnabled());
+ assertNotNull(mWifiManager.getDhcpInfo());
+ assertEquals(WifiManager.WIFI_STATE_ENABLED, mWifiManager.getWifiState());
+ mWifiManager.getConnectionInfo();
+ setWifiEnabled(false);
+ assertFalse(mWifiManager.isWifiEnabled());
+ }
+
+ /**
+ * test point of wifiManager NetWork:
+ * 1.add NetWork
+ * 2.update NetWork
+ * 3.remove NetWork
+ * 4.enable NetWork
+ * 5.disable NetWork
+ * 6.configured Networks
+ * 7.save configure;
+ */
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "isWifiEnabled",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "setWifiEnabled",
+ args = {boolean.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getConfiguredNetworks",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "addNetwork",
+ args = {android.net.wifi.WifiConfiguration.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "updateNetwork",
+ args = {android.net.wifi.WifiConfiguration.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "removeNetwork",
+ args = {int.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "enableNetwork",
+ args = {int.class, boolean.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "disableNetwork",
+ args = {int.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "saveConfiguration",
+ args = {}
+ )
+ })
+ public void testWifiManagerNetWork() throws Exception {
+ // store the list of enabled networks, so they can be re-enabled after test completes
+ Set<String> enabledSsids = getEnabledNetworks(mWifiManager.getConfiguredNetworks());
+ try {
+ WifiConfiguration wifiConfiguration;
+ // add a WifiConfig
+ final int notExist = -1;
+ List<WifiConfiguration> wifiConfiguredNetworks = mWifiManager.getConfiguredNetworks();
+ int pos = findConfiguredNetworks(SSID1, wifiConfiguredNetworks);
+ if (notExist != pos) {
+ wifiConfiguration = wifiConfiguredNetworks.get(pos);
+ mWifiManager.removeNetwork(wifiConfiguration.networkId);
+ }
+ pos = findConfiguredNetworks(SSID1, wifiConfiguredNetworks);
+ assertEquals(notExist, pos);
+ final int size = wifiConfiguredNetworks.size();
+
+ wifiConfiguration = new WifiConfiguration();
+ wifiConfiguration.SSID = SSID1;
+ int netId = mWifiManager.addNetwork(wifiConfiguration);
+ assertTrue(existSSID(SSID1));
+
+ wifiConfiguredNetworks = mWifiManager.getConfiguredNetworks();
+ assertEquals(size + 1, wifiConfiguredNetworks.size());
+ pos = findConfiguredNetworks(SSID1, wifiConfiguredNetworks);
+ assertTrue(notExist != pos);
+
+ // Enable & disable network
+ boolean disableOthers = false;
+ assertTrue(mWifiManager.enableNetwork(netId, disableOthers));
+ wifiConfiguration = mWifiManager.getConfiguredNetworks().get(pos);
+ assertDisableOthers(wifiConfiguration, disableOthers);
+ assertEquals(Status.ENABLED, wifiConfiguration.status);
+ disableOthers = true;
+
+ assertTrue(mWifiManager.enableNetwork(netId, disableOthers));
+ wifiConfiguration = mWifiManager.getConfiguredNetworks().get(pos);
+ assertDisableOthers(wifiConfiguration, disableOthers);
+
+ assertTrue(mWifiManager.disableNetwork(netId));
+ wifiConfiguration = mWifiManager.getConfiguredNetworks().get(pos);
+ assertEquals(Status.DISABLED, wifiConfiguration.status);
+
+ // Update a WifiConfig
+ wifiConfiguration = wifiConfiguredNetworks.get(pos);
+ wifiConfiguration.SSID = SSID2;
+ netId = mWifiManager.updateNetwork(wifiConfiguration);
+ assertFalse(existSSID(SSID1));
+ assertTrue(existSSID(SSID2));
+
+ // Remove a WifiConfig
+ assertTrue(mWifiManager.removeNetwork(netId));
+ assertFalse(mWifiManager.removeNetwork(notExist));
+ assertFalse(existSSID(SSID1));
+ assertFalse(existSSID(SSID2));
+
+ assertTrue(mWifiManager.saveConfiguration());
+ } finally {
+ reEnableNetworks(enabledSsids, mWifiManager.getConfiguredNetworks());
+ mWifiManager.saveConfiguration();
+ }
+ }
+
+ private Set<String> getEnabledNetworks(List<WifiConfiguration> configuredNetworks) {
+ Set<String> ssids = new HashSet<String>();
+ for (WifiConfiguration wifiConfig : configuredNetworks) {
+ if (Status.ENABLED == wifiConfig.status || Status.CURRENT == wifiConfig.status) {
+ ssids.add(wifiConfig.SSID);
+ Log.i(TAG, String.format("remembering enabled network %s", wifiConfig.SSID));
+ }
+ }
+ return ssids;
+ }
+
+ private void reEnableNetworks(Set<String> enabledSsids,
+ List<WifiConfiguration> configuredNetworks) {
+ for (WifiConfiguration wifiConfig : configuredNetworks) {
+ if (enabledSsids.contains(wifiConfig.SSID)) {
+ mWifiManager.enableNetwork(wifiConfig.networkId, false);
+ Log.i(TAG, String.format("re-enabling network %s", wifiConfig.SSID));
+ }
+ }
+ }
+
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "compareSignalLevel",
+ args = {int.class, int.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "calculateSignalLevel",
+ args = {int.class, int.class}
+ )
+ })
+ public void testSignal() {
+ final int numLevels = 9;
+ int expectLevel = 0;
+ assertEquals(expectLevel, WifiManager.calculateSignalLevel(MIN_RSSI, numLevels));
+ assertEquals(numLevels - 1, WifiManager.calculateSignalLevel(MAX_RSSI, numLevels));
+ expectLevel = 4;
+ assertEquals(expectLevel, WifiManager.calculateSignalLevel((MIN_RSSI + MAX_RSSI) / 2,
+ numLevels));
+ int rssiA = 4;
+ int rssiB = 5;
+ assertTrue(WifiManager.compareSignalLevel(rssiA, rssiB) < 0);
+ rssiB = 4;
+ assertTrue(WifiManager.compareSignalLevel(rssiA, rssiB) == 0);
+ rssiA = 5;
+ rssiB = 4;
+ assertTrue(WifiManager.compareSignalLevel(rssiA, rssiB) > 0);
+ }
+}
OSDN Git Service
