diff options
3 files changed, 507 insertions, 18 deletions
diff --git a/tests/wifitests/src/com/android/server/wifi/ExternalScoreEvaluatorTest.java b/tests/wifitests/src/com/android/server/wifi/ExternalScoreEvaluatorTest.java new file mode 100644 index 000000000..16bd4f8d8 --- /dev/null +++ b/tests/wifitests/src/com/android/server/wifi/ExternalScoreEvaluatorTest.java @@ -0,0 +1,419 @@ +/* + * Copyright (C) 2016 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.server.wifi; + +import static com.android.server.wifi.WifiConfigurationTestUtil.SECURITY_NONE; +import static com.android.server.wifi.WifiConfigurationTestUtil.SECURITY_PSK; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +import android.app.test.MockAnswerUtil.AnswerWithArguments; +import android.content.Context; +import android.content.res.Resources; +import android.net.INetworkScoreCache; +import android.net.NetworkScoreManager; +import android.net.wifi.ScanResult; +import android.net.wifi.WifiConfiguration; +import android.os.SystemClock; +import android.test.suitebuilder.annotation.SmallTest; + +import com.android.internal.R; +import com.android.server.wifi.WifiNetworkSelectorTestUtil.ScanDetailsAndWifiConfigs; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.List; + +/** + * Unit tests for {@link com.android.server.wifi.ExternalScoreEvaluator}. + */ +@SmallTest +public class ExternalScoreEvaluatorTest { + + /** Sets up test. */ + @Before + public void setUp() throws Exception { + mResource = getResource(); + mScoreManager = getScoreManager(); + mContext = getContext(); + mWifiConfigManager = getWifiConfigManager(); + when(mClock.getElapsedSinceBootMillis()).thenReturn(SystemClock.elapsedRealtime()); + + mThresholdQualifiedRssi2G = mResource.getInteger( + R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_24GHz); + mThresholdQualifiedRssi5G = mResource.getInteger( + R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_5GHz); + + mExternalScoreEvaluator = new ExternalScoreEvaluator(mContext, mWifiConfigManager, + mClock, null); + } + + /** Cleans up test. */ + @After + public void cleanup() { + validateMockitoUsage(); + } + + private ExternalScoreEvaluator mExternalScoreEvaluator; + private WifiConfigManager mWifiConfigManager; + private Context mContext; + private Resources mResource; + private NetworkScoreManager mScoreManager; + private WifiNetworkScoreCache mScoreCache; + private Clock mClock = mock(Clock.class); + private int mThresholdQualifiedRssi2G; + private int mThresholdQualifiedRssi5G; + private static final String TAG = "External Score Evaluator Unit Test"; + + NetworkScoreManager getScoreManager() { + NetworkScoreManager scoreManager = mock(NetworkScoreManager.class); + + doAnswer(new AnswerWithArguments() { + public void answer(int networkType, INetworkScoreCache scoreCache) { + mScoreCache = (WifiNetworkScoreCache) scoreCache; + }}).when(scoreManager).registerNetworkScoreCache(anyInt(), anyObject()); + + return scoreManager; + } + + Context getContext() { + Context context = mock(Context.class); + + when(context.getResources()).thenReturn(mResource); + when(context.getSystemService(Context.NETWORK_SCORE_SERVICE)).thenReturn(mScoreManager); + + return context; + } + + Resources getResource() { + Resources resource = mock(Resources.class); + + when(resource.getInteger( + R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_5GHz)) + .thenReturn(-70); + when(resource.getInteger( + R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_24GHz)) + .thenReturn(-73); + + return resource; + } + + WifiConfigManager getWifiConfigManager() { + WifiConfigManager wifiConfigManager = mock(WifiConfigManager.class); + when(wifiConfigManager.getLastSelectedNetwork()) + .thenReturn(WifiConfiguration.INVALID_NETWORK_ID); + return wifiConfigManager; + } + + + /** + * When no saved networks available, choose the available ephemeral networks + * if untrusted networks are allowed. + */ + @Test + public void chooseEphemeralNetworkBecauseOfNoSavedNetwork() { + String[] ssids = {"\"test1\"", "\"test2\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4"}; + int[] freqs = {2470, 2437}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[ESS]"}; + int[] levels = {mThresholdQualifiedRssi2G + 8, mThresholdQualifiedRssi2G + 10}; + Integer[] scores = {null, 120}; + boolean[] meteredHints = {false, true}; + + List<ScanDetail> scanDetails = WifiNetworkSelectorTestUtil.buildScanDetails( + ssids, bssids, freqs, caps, levels, mClock); + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + // No saved networks. + when(mWifiConfigManager.getSavedNetworkForScanDetailAndCache(any(ScanDetail.class))) + .thenReturn(null); + + ScanResult scanResult = scanDetails.get(1).getScanResult(); + WifiConfiguration ephemeralNetworkConfig = WifiNetworkSelectorTestUtil + .setupEphemeralNetwork(mWifiConfigManager, 1, scanResult, meteredHints[1]); + + // Untrusted networks allowed. + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(ephemeralNetworkConfig, candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + scanResult, candidate); + assertEquals(meteredHints[1], candidate.meteredHint); + } + + /** + * When no saved networks available, choose the highest scored ephemeral networks + * if untrusted networks are allowed. + */ + @Test + public void chooseHigherScoredEphemeralNetwork() { + String[] ssids = {"\"test1\"", "\"test2\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4"}; + int[] freqs = {2470, 2437}; + String[] caps = {"[ESS]", "[ESS]"}; + int[] levels = {mThresholdQualifiedRssi2G + 8, mThresholdQualifiedRssi2G + 8}; + Integer[] scores = {100, 120}; + boolean[] meteredHints = {true, true}; + ScanResult[] scanResults = new ScanResult[2]; + WifiConfiguration[] ephemeralNetworkConfigs = new WifiConfiguration[2]; + + List<ScanDetail> scanDetails = WifiNetworkSelectorTestUtil.buildScanDetails( + ssids, bssids, freqs, caps, levels, mClock); + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + // No saved networks. + when(mWifiConfigManager.getSavedNetworkForScanDetailAndCache(any(ScanDetail.class))) + .thenReturn(null); + + for (int i = 0; i < 2; i++) { + scanResults[i] = scanDetails.get(i).getScanResult(); + ephemeralNetworkConfigs[i] = WifiNetworkSelectorTestUtil + .setupEphemeralNetwork(mWifiConfigManager, i, scanResults[i], meteredHints[i]); + } + + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(ephemeralNetworkConfigs[1], candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + scanResults[1], candidate); + assertEquals(meteredHints[1], candidate.meteredHint); + } + + /** + * Don't choose available ephemeral networks if no saved networks and untrusted networks + * are not allowed. + */ + @Test + public void noEphemeralNetworkWhenUntrustedNetworksNotAllowed() { + String[] ssids = {"\"test1\"", "\"test2\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4"}; + int[] freqs = {2470, 2437}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[ESS]"}; + int[] levels = {mThresholdQualifiedRssi2G + 8, mThresholdQualifiedRssi2G + 10}; + Integer[] scores = {null, 120}; + boolean[] meteredHints = {false, true}; + + List<ScanDetail> scanDetails = WifiNetworkSelectorTestUtil.buildScanDetails( + ssids, bssids, freqs, caps, levels, mClock); + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + // No saved networks. + when(mWifiConfigManager.getSavedNetworkForScanDetailAndCache(any(ScanDetail.class))) + .thenReturn(null); + + ScanResult scanResult = scanDetails.get(1).getScanResult(); + WifiConfiguration ephemeralNetworkConfig = WifiNetworkSelectorTestUtil + .setupEphemeralNetwork(mWifiConfigManager, 1, scanResult, meteredHints[1]); + + // Untursted networks not allowed. + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, false, null); + + assertEquals("Expect null configuration", null, candidate); + } + + + /** + * Choose externally scored saved network. + */ + @Test + public void chooseSavedNetworkWithExternalScore() { + String[] ssids = {"\"test1\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3"}; + int[] freqs = {5200}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]"}; + int[] securities = {SECURITY_PSK}; + int[] levels = {mThresholdQualifiedRssi5G + 8}; + Integer[] scores = {120}; + boolean[] meteredHints = {false}; + + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = + WifiNetworkSelectorTestUtil.setupScanDetailsAndConfigStore(ssids, bssids, + freqs, caps, levels, securities, mWifiConfigManager, mClock); + List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); + WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); + savedConfigs[0].useExternalScores = true; + + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[0], candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + scanDetails.get(0).getScanResult(), candidate); + } + + /** + * Choose externally scored saved network with higher score. + */ + @Test + public void chooseSavedNetworkWithHigherExternalScore() { + String[] ssids = {"\"test1\"", "\"test2\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4"}; + int[] freqs = {2470, 2437}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[WPA2-EAP-CCMP][ESS]"}; + int[] securities = {SECURITY_PSK, SECURITY_PSK}; + int[] levels = {mThresholdQualifiedRssi2G + 8, mThresholdQualifiedRssi2G + 8}; + Integer[] scores = {100, 120}; + boolean[] meteredHints = {false, false}; + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = + WifiNetworkSelectorTestUtil.setupScanDetailsAndConfigStore(ssids, bssids, + freqs, caps, levels, securities, mWifiConfigManager, mClock); + List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); + WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); + savedConfigs[0].useExternalScores = savedConfigs[1].useExternalScores = true; + + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[1], candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + scanDetails.get(1).getScanResult(), candidate); + } + + /** + * Prefer externally scored saved network over untrusted network when they have + * the same score. + */ + @Test + public void chooseExternallyScoredSavedNetworkOverUntrustedNetworksWithSameScore() { + String[] ssids = {"\"test1\"", "\"test2\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4"}; + int[] freqs = {2470, 2437}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[ESS]"}; + int[] securities = {SECURITY_PSK, SECURITY_NONE}; + int[] levels = {mThresholdQualifiedRssi2G + 8, mThresholdQualifiedRssi2G + 8}; + Integer[] scores = {120, 120}; + boolean[] meteredHints = {false, true}; + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = + WifiNetworkSelectorTestUtil.setupScanDetailsAndConfigStore(ssids, bssids, + freqs, caps, levels, securities, mWifiConfigManager, mClock); + List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); + WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); + savedConfigs[0].useExternalScores = true; + + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[0], candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + scanDetails.get(0).getScanResult(), candidate); + } + + /** + * Choose untrusted network when it has higher score than the externally scored + * saved network. + */ + @Test + public void chooseUntrustedNetworkWithHigherScoreThanExternallyScoredSavedNetwork() { + // Saved network. + String[] savedSsids = {"\"test1\""}; + String[] savedBssids = {"6c:f3:7f:ae:8c:f3"}; + int[] savedFreqs = {2470}; + String[] savedCaps = {"[WPA2-EAP-CCMP][ESS]"}; + int[] savedSecurities = {SECURITY_PSK}; + int[] savedLevels = {mThresholdQualifiedRssi2G + 8}; + // Ephemeral network. + String[] ephemeralSsids = {"\"test2\""}; + String[] ephemeralBssids = {"6c:f3:7f:ae:8c:f4"}; + int[] ephemeralFreqs = {2437}; + String[] ephemeralCaps = {"[ESS]"}; + int[] ephemeralLevels = {mThresholdQualifiedRssi2G + 8}; + // Ephemeral network has higher score than the saved network. + Integer[] scores = {100, 120}; + boolean[] meteredHints = {false, true}; + + // Set up the saved network. + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = + WifiNetworkSelectorTestUtil.setupScanDetailsAndConfigStore(savedSsids, + savedBssids, savedFreqs, savedCaps, savedLevels, savedSecurities, + mWifiConfigManager, mClock); + List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); + WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); + savedConfigs[0].useExternalScores = true; + + // Set up the ephemeral network. + scanDetails.addAll(WifiNetworkSelectorTestUtil.buildScanDetails( + ephemeralSsids, ephemeralBssids, ephemeralFreqs, + ephemeralCaps, ephemeralLevels, mClock)); + ScanResult ephemeralScanResult = scanDetails.get(1).getScanResult(); + WifiConfiguration ephemeralNetworkConfig = WifiNetworkSelectorTestUtil + .setupEphemeralNetwork(mWifiConfigManager, 1, ephemeralScanResult, + meteredHints[1]); + + // Set up score cache for both the saved network and the ephemeral network. + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(ephemeralNetworkConfig, candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + ephemeralScanResult, candidate); + } + + /** + * Prefer externally scored saved network over untrusted network when they have + * the same score. + */ + @Test + public void nullScoredNetworks() { + String[] ssids = {"\"test1\"", "\"test2\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4"}; + int[] freqs = {2470, 2437}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[ESS]"}; + int[] securities = {SECURITY_PSK, SECURITY_NONE}; + int[] levels = {mThresholdQualifiedRssi2G + 8, mThresholdQualifiedRssi2G + 8}; + Integer[] scores = {null, null}; + boolean[] meteredHints = {false, true}; + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = + WifiNetworkSelectorTestUtil.setupScanDetailsAndConfigStore(ssids, bssids, + freqs, caps, levels, securities, mWifiConfigManager, mClock); + List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); + WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); + savedConfigs[0].useExternalScores = true; + + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + WifiConfiguration candidate = mExternalScoreEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + assertEquals("Expect null configuration", null, candidate); + } +} diff --git a/tests/wifitests/src/com/android/server/wifi/SavedNetworkEvaluatorTest.java b/tests/wifitests/src/com/android/server/wifi/SavedNetworkEvaluatorTest.java index d2c674625..fe290cd8a 100644 --- a/tests/wifitests/src/com/android/server/wifi/SavedNetworkEvaluatorTest.java +++ b/tests/wifitests/src/com/android/server/wifi/SavedNetworkEvaluatorTest.java @@ -28,7 +28,6 @@ import android.net.wifi.ScanResult; import android.net.wifi.WifiConfiguration; import android.os.SystemClock; import android.test.suitebuilder.annotation.SmallTest; -import android.util.Pair; import com.android.internal.R; import com.android.server.wifi.WifiNetworkSelectorTestUtil.ScanDetailsAndWifiConfigs; @@ -37,7 +36,6 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; -import java.util.ArrayList; import java.util.List; /** @@ -168,10 +166,9 @@ public class SavedNetworkEvaluatorTest { freqs, caps, levels, securities, mWifiConfigManager, mClock); List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); - List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>(); WifiConfiguration candidate = mSavedNetworkEvaluator.evaluateNetworks(scanDetails, - null, null, true, false, connectableNetworks); + null, null, true, false, null); ScanResult chosenScanResult = scanDetails.get(1).getScanResult(); WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[1], candidate); @@ -197,10 +194,9 @@ public class SavedNetworkEvaluatorTest { freqs, caps, levels, securities, mWifiConfigManager, mClock); List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); - List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>(); WifiConfiguration candidate = mSavedNetworkEvaluator.evaluateNetworks(scanDetails, - null, null, true, false, connectableNetworks); + null, null, true, false, null); ScanResult chosenScanResult = scanDetails.get(1).getScanResult(); WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[1], candidate); @@ -225,10 +221,9 @@ public class SavedNetworkEvaluatorTest { freqs, caps, levels, securities, mWifiConfigManager, mClock); List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); - List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>(); WifiConfiguration candidate = mSavedNetworkEvaluator.evaluateNetworks(scanDetails, - null, null, true, false, connectableNetworks); + null, null, true, false, null); ScanResult chosenScanResult = scanDetails.get(1).getScanResult(); WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[1], candidate); @@ -253,10 +248,9 @@ public class SavedNetworkEvaluatorTest { freqs, caps, levels, securities, mWifiConfigManager, mClock); List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); - List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>(); WifiConfiguration candidate = mSavedNetworkEvaluator.evaluateNetworks(scanDetails, - null, null, true, false, connectableNetworks); + null, null, true, false, null); ScanResult chosenScanResult = scanDetails.get(1).getScanResult(); WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[1], candidate); @@ -283,11 +277,10 @@ public class SavedNetworkEvaluatorTest { freqs, caps, levels, securities, mWifiConfigManager, mClock); List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); - List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>(); // Simuluate we are connected to SSID test1 already. WifiConfiguration candidate = mSavedNetworkEvaluator.evaluateNetworks(scanDetails, - savedConfigs[0], null, true, false, connectableNetworks); + savedConfigs[0], null, true, false, null); // Even though test2 has higher RSSI value, test1 is chosen because of the // currently connected network bonus. @@ -317,11 +310,10 @@ public class SavedNetworkEvaluatorTest { freqs, caps, levels, securities, mWifiConfigManager, mClock); List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails(); WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs(); - List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>(); // Simuluate we are connected to BSSID "6c:f3:7f:ae:8c:f3" already WifiConfiguration candidate = mSavedNetworkEvaluator.evaluateNetworks(scanDetails, - null, bssids[0], true, false, connectableNetworks); + null, bssids[0], true, false, null); // Even though test2 has higher RSSI value, test1 is chosen because of the // currently connected BSSID bonus. diff --git a/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java b/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java index a6327467f..db3aff14c 100644 --- a/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java +++ b/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java @@ -22,6 +22,10 @@ import static org.junit.Assert.*; import static org.mockito.Mockito.*; import android.app.test.MockAnswerUtil.AnswerWithArguments; +import android.net.NetworkKey; +import android.net.RssiCurve; +import android.net.ScoredNetwork; +import android.net.WifiKey; import android.net.wifi.ScanResult; import android.net.wifi.WifiConfiguration; import android.net.wifi.WifiConfiguration.NetworkSelectionStatus; @@ -29,6 +33,8 @@ import android.net.wifi.WifiSsid; import android.test.suitebuilder.annotation.SmallTest; import android.text.TextUtils; +import com.android.server.wifi.util.ScanResultUtil; + import java.util.ArrayList; import java.util.List; @@ -109,14 +115,14 @@ public class WifiNetworkSelectorTestUtil { * @param levels an array of the network's RSSI levels * @return the constructed list of ScanDetail */ - private static List<ScanDetail> buildScanDetails(String[] ssids, String[] bssids, int[] freq, + public static List<ScanDetail> buildScanDetails(String[] ssids, String[] bssids, int[] freqs, String[] caps, int[] levels, Clock clock) { List<ScanDetail> scanDetailList = new ArrayList<ScanDetail>(); long timeStamp = clock.getElapsedSinceBootMillis(); for (int index = 0; index < ssids.length; index++) { ScanDetail scanDetail = new ScanDetail(WifiSsid.createFromAsciiEncoded(ssids[index]), - bssids[index], caps[index], levels[index], freq[index], timeStamp, 0); + bssids[index], caps[index], levels[index], freqs[index], timeStamp, 0); scanDetailList.add(scanDetail); } return scanDetailList; @@ -128,10 +134,10 @@ public class WifiNetworkSelectorTestUtil { * supplied network SSID and sencurity information. * * @param ssids an array of SSIDs - * @param caps an array of the network's security setting + * @param securities an array of the network's security setting * @return the constructed array of {@link android.net.wifi.WifiConfiguration} */ - private static WifiConfiguration[] generateWifiConfigurations(String[] ssids, + public static WifiConfiguration[] generateWifiConfigurations(String[] ssids, int[] securities) { if (ssids == null || securities == null || ssids.length != securities.length || ssids.length == 0) { @@ -286,4 +292,76 @@ public class WifiNetworkSelectorTestUtil { } } } + + + + /** + * Configure the score cache for externally scored networks + * + * @param scoreCache Wifi network score cache to be configured + * @param scanDetails a list of ScanDetail + * @param scores scores of the networks + * @param meteredHints hints of if the networks are metered + */ + public static void configureScoreCache(WifiNetworkScoreCache scoreCache, + List<ScanDetail> scanDetails, Integer[] scores, boolean[] meteredHints) { + List<ScoredNetwork> networks = new ArrayList<>(); + + for (int i = 0; i < scanDetails.size(); i++) { + ScanDetail scanDetail = scanDetails.get(i); + byte rssiScore; + Integer score = scores[i]; + ScanResult scanResult = scanDetail.getScanResult(); + WifiKey wifiKey = new WifiKey("\"" + scanResult.SSID + "\"", scanResult.BSSID); + NetworkKey ntwkKey = new NetworkKey(wifiKey); + if (scores[i] == null) { + rssiScore = WifiNetworkScoreCache.INVALID_NETWORK_SCORE; + } else { + rssiScore = scores[i].byteValue(); + } + RssiCurve rssiCurve = new RssiCurve(-100, 100, new byte[] {rssiScore}); + ScoredNetwork scoredNetwork = new ScoredNetwork(ntwkKey, rssiCurve, meteredHints[i]); + + networks.add(scoredNetwork); + } + + scoreCache.updateScores(networks); + } + + /** + * Setup WifiConfigManager mock for ephemeral networks. + * + * @param wifiConfigManager WifiConfigManager mock + * @param networkId ID of the ephemeral network + * @param scanResult scanResult of the ephemeral network + * @param meteredHint flag to indidate if the network has meteredHint + */ + public static WifiConfiguration setupEphemeralNetwork(WifiConfigManager wifiConfigManager, + int networkId, ScanResult scanResult, boolean meteredHint) { + // Return the correct networkID for ephemeral network addition. + when(wifiConfigManager.addOrUpdateNetwork(any(WifiConfiguration.class), anyInt())) + .thenReturn(new NetworkUpdateResult(networkId)); + final WifiConfiguration config = ScanResultUtil.createNetworkFromScanResult(scanResult); + config.networkId = networkId; + config.meteredHint = meteredHint; + + when(wifiConfigManager.getConfiguredNetwork(eq(networkId))) + .then(new AnswerWithArguments() { + public WifiConfiguration answer(int netId) { + return new WifiConfiguration(config); + } + }); + when(wifiConfigManager.setNetworkCandidateScanResult( + eq(networkId), any(ScanResult.class), anyInt())) + .then(new AnswerWithArguments() { + public boolean answer(int netId, ScanResult scanResult, int score) { + config.getNetworkSelectionStatus().setCandidate(scanResult); + config.getNetworkSelectionStatus().setCandidateScore(score); + config.getNetworkSelectionStatus() + .setSeenInLastQualifiedNetworkSelection(true); + return true; + } + }); + return config; + } } |