Unit tests for ExternalScoreEvaluator

While there, add a few null checks.
Updated SavedNetowrkEvaluatorTest accordingly.

Bug: 31273721
Test: Unit tests passed.
Merged-In: I32b0a92239968c0fdfd9f81934b3da33f85721f5
Change-Id: I32b0a92239968c0fdfd9f81934b3da33f85721f5

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;
+    }
 }