Merge "NetworkSuggestionEvaluator: Honor app set priority for suggestions"

2 files changed, 288 insertions, 55 deletions

diff --git a/service/java/com/android/server/wifi/NetworkSuggestionEvaluator.java b/service/java/com/android/server/wifi/NetworkSuggestionEvaluator.java
index 136d5c727..ddc0b71a7 100644
--- a/service/java/com/android/server/wifi/NetworkSuggestionEvaluator.java
+++ b/service/java/com/android/server/wifi/NetworkSuggestionEvaluator.java
@@ -21,16 +21,21 @@ import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiNetworkSuggestion;
 import android.util.LocalLog;
-import android.util.Pair;
+import android.util.Log;
 
 import com.android.server.wifi.util.ScanResultUtil;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.NotThreadSafe;
 
 /**
@@ -74,19 +79,10 @@ public class NetworkSuggestionEvaluator implements WifiNetworkSelector.NetworkEv
             WifiConfiguration currentNetwork, String currentBssid, boolean connected,
             boolean untrustedNetworkAllowed,
             @NonNull OnConnectableListener onConnectableListener) {
-        Map<WifiNetworkSuggestion, Pair<WifiConfiguration, ScanDetail>> candidateMap =
-                new HashMap<>();
+        MatchMetaInfo matchMetaInfo = new MatchMetaInfo();
         for (int i = 0; i < scanDetails.size(); i++) {
             ScanDetail scanDetail = scanDetails.get(i);
             ScanResult scanResult = scanDetail.getScanResult();
-            Set<WifiNetworkSuggestion> matchingNetworkSuggestions =
-                    mWifiNetworkSuggestionsManager.getNetworkSuggestionsForScanDetail(scanDetail);
-            if (matchingNetworkSuggestions == null || matchingNetworkSuggestions.isEmpty()) {
-                continue;
-            }
-            // All matching network credentials are considered equal. So, put any one of them.
-            WifiNetworkSuggestion matchingNetworkSuggestion =
-                    matchingNetworkSuggestions.stream().findAny().get();
             // If the user previously forgot this network, don't select it.
             if (mWifiConfigManager.wasEphemeralNetworkDeleted(
                     ScanResultUtil.createQuotedSSID(scanResult.SSID))) {
@@ -94,9 +90,20 @@ public class NetworkSuggestionEvaluator implements WifiNetworkSelector.NetworkEv
                         + WifiNetworkSelector.toScanId(scanResult));
                 continue;
             }
+            Set<WifiNetworkSuggestion> matchingNetworkSuggestions =
+                    mWifiNetworkSuggestionsManager.getNetworkSuggestionsForScanDetail(scanDetail);
+            if (matchingNetworkSuggestions == null || matchingNetworkSuggestions.isEmpty()) {
+                continue;
+            }
+            // All matching suggestions have the same network credentials type. So, use any one of
+            // them to lookup/add the credentials to WifiConfigManager.
+            // Note: Apps could provide different credentials (password, ceritificate) for the same
+            // network, need to handle that in the future.
+            WifiNetworkSuggestion matchingNetworkSuggestion =
+                    matchingNetworkSuggestions.stream().findAny().get();
             // Check if we already have a network with the same credentials in WifiConfigManager
             // database. If yes, we should check if the network is currently blacklisted.
-            WifiConfiguration  wCmConfiguredNetwork =
+            WifiConfiguration wCmConfiguredNetwork =
                     mWifiConfigManager.getConfiguredNetwork(
                             matchingNetworkSuggestion.wifiConfiguration.configKey());
             if (wCmConfiguredNetwork != null) {
@@ -106,35 +113,23 @@ public class NetworkSuggestionEvaluator implements WifiNetworkSelector.NetworkEv
                             + WifiNetworkSelector.toNetworkString(wCmConfiguredNetwork));
                     continue;
                 }
-                mLocalLog.log(String.format("network suggestion candidate %s (existing)",
-                        WifiNetworkSelector.toNetworkString(wCmConfiguredNetwork)));
-            } else {
-                wCmConfiguredNetwork = addCandidateToWifiConfigManager(
-                        matchingNetworkSuggestion.wifiConfiguration,
-                        matchingNetworkSuggestion.suggestorUid,
-                        matchingNetworkSuggestion.suggestorPackageName);
-                if (wCmConfiguredNetwork == null) continue;
-                mLocalLog.log(String.format("network suggestion candidate %s (new)",
-                        WifiNetworkSelector.toNetworkString(wCmConfiguredNetwork)));
             }
-            candidateMap.put(matchingNetworkSuggestion,
-                    Pair.create(wCmConfiguredNetwork, scanDetail));
-            onConnectableListener.onConnectable(scanDetail, wCmConfiguredNetwork, 0);
+            matchMetaInfo.putAll(matchingNetworkSuggestions, wCmConfiguredNetwork, scanDetail);
         }
-
-        // Pick the matching network suggestion corresponding to the highest RSSI. This will need to
-        // be replaced by a more sophisticated algorithm.
-        Map.Entry<WifiNetworkSuggestion, Pair<WifiConfiguration, ScanDetail>>
-                candidate = candidateMap
-                        .entrySet()
-                        .stream()
-                        .max(Comparator.comparing(e -> e.getValue().second.getScanResult().level))
-                        .orElse(null);
-        if (candidate == null) {
+        // Return early on no match.
+        if (matchMetaInfo.isEmpty()) {
             mLocalLog.log("did not see any matching network suggestions.");
             return null;
         }
-        return candidate.getValue().first;
+        // Note: These matched sets should be very small & hence these additional manipulations that
+        // follow should not be very expensive.
+        PerNetworkSuggestionMatchMetaInfo candidate =
+                matchMetaInfo.findConnectableNetworksAndPickBest(onConnectableListener);
+        if (candidate == null) { // should never happen.
+            Log.wtf(TAG, "Unexepectedly got null");
+            return null;
+        }
+        return candidate.wCmConfiguredNetwork;
     }
 
     // Add and enable this network to the central database (i.e WifiConfigManager).
@@ -169,4 +164,136 @@ public class NetworkSuggestionEvaluator implements WifiNetworkSelector.NetworkEv
     public String getName() {
         return TAG;
     }
+
+    // Container classes to handle book-keeping while we're iterating through the scan list.
+    private class PerNetworkSuggestionMatchMetaInfo {
+        public final WifiNetworkSuggestion wifiNetworkSuggestion;
+        public final ScanDetail matchingScanDetail;
+        public WifiConfiguration wCmConfiguredNetwork; // Added to WifiConfigManager.
+
+        PerNetworkSuggestionMatchMetaInfo(@NonNull WifiNetworkSuggestion wifiNetworkSuggestion,
+                                          @Nullable WifiConfiguration wCmConfiguredNetwork,
+                                          @NonNull ScanDetail matchingScanDetail) {
+            this.wifiNetworkSuggestion = wifiNetworkSuggestion;
+            this.wCmConfiguredNetwork = wCmConfiguredNetwork;
+            this.matchingScanDetail = matchingScanDetail;
+        }
+    }
+
+    private class PerAppMatchMetaInfo {
+        public final List<PerNetworkSuggestionMatchMetaInfo> networkInfos = new ArrayList<>();
+
+        /**
+         * Add the network suggestion & associated info to this package meta info.
+         */
+        public void put(WifiNetworkSuggestion wifiNetworkSuggestion,
+                        WifiConfiguration matchingWifiConfiguration,
+                        ScanDetail matchingScanDetail) {
+            networkInfos.add(new PerNetworkSuggestionMatchMetaInfo(
+                    wifiNetworkSuggestion, matchingWifiConfiguration, matchingScanDetail));
+        }
+
+        /**
+         * Pick the highest priority networks among the current match info candidates for this
+         * app.
+         */
+        public List<PerNetworkSuggestionMatchMetaInfo> getHighestPriorityNetworks() {
+            // Partition the list to a map of network suggestions keyed in by the priorities.
+            // There can be multiple networks with the same priority, hence a list in the value.
+            Map<Integer, List<PerNetworkSuggestionMatchMetaInfo>> matchedNetworkInfosPerPriority =
+                    networkInfos.stream()
+                            .collect(Collectors.toMap(
+                                    e -> e.wifiNetworkSuggestion.wifiConfiguration.priority,
+                                    e -> Arrays.asList(e),
+                                    (v1, v2) -> { // concatenate networks with the same priority.
+                                        List<PerNetworkSuggestionMatchMetaInfo> concatList =
+                                                new ArrayList<>(v1);
+                                        concatList.addAll(v2);
+                                        return concatList;
+                                    }));
+            if (matchedNetworkInfosPerPriority.isEmpty()) { // should never happen.
+                Log.wtf(TAG, "Unexepectedly got empty");
+                return Collections.EMPTY_LIST;
+            }
+            // Return the list associated with the highest priority value.
+            return matchedNetworkInfosPerPriority.get(Collections.max(
+                    matchedNetworkInfosPerPriority.keySet()));
+        }
+    }
+
+    private class MatchMetaInfo {
+        private Map<String, PerAppMatchMetaInfo> mAppInfos = new HashMap<>();
+
+        /**
+         * Add all the network suggestion & associated info.
+         */
+        public void putAll(Set<WifiNetworkSuggestion> wifiNetworkSuggestions,
+                           WifiConfiguration wCmConfiguredNetwork,
+                           ScanDetail matchingScanDetail) {
+            // Separate the suggestions into buckets for each app to allow sorting based on
+            // priorities set by app.
+            for (WifiNetworkSuggestion wifiNetworkSuggestion : wifiNetworkSuggestions) {
+                PerAppMatchMetaInfo appInfo = mAppInfos.computeIfAbsent(
+                        wifiNetworkSuggestion.suggestorPackageName, k -> new PerAppMatchMetaInfo());
+                appInfo.put(wifiNetworkSuggestion, wCmConfiguredNetwork, matchingScanDetail);
+            }
+        }
+
+        /**
+         * Are there any matched candidates?
+         */
+        public boolean isEmpty() {
+            return mAppInfos.isEmpty();
+        }
+
+        /**
+         * Find all the connectable networks and pick the best network among the current match info
+         * candidates.
+         *
+         * Among the highest priority suggestions from different packages, choose the suggestion
+         * with the highest RSSI.
+         * Note: This should need to be replaced by a more sophisticated algorithm.
+         */
+        public PerNetworkSuggestionMatchMetaInfo findConnectableNetworksAndPickBest(
+                @NonNull OnConnectableListener onConnectableListener) {
+            List<PerNetworkSuggestionMatchMetaInfo> allMatchedNetworkInfos = new ArrayList<>();
+            for (PerAppMatchMetaInfo appInfo : mAppInfos.values()) {
+                List<PerNetworkSuggestionMatchMetaInfo> matchedNetworkInfos =
+                        appInfo.getHighestPriorityNetworks();
+                for (PerNetworkSuggestionMatchMetaInfo matchedNetworkInfo : matchedNetworkInfos) {
+                    // if the network does not already exist in WifiConfigManager, add now.
+                    if (matchedNetworkInfo.wCmConfiguredNetwork == null) {
+                        matchedNetworkInfo.wCmConfiguredNetwork = addCandidateToWifiConfigManager(
+                                matchedNetworkInfo.wifiNetworkSuggestion.wifiConfiguration,
+                                matchedNetworkInfo.wifiNetworkSuggestion.suggestorUid,
+                                matchedNetworkInfo.wifiNetworkSuggestion.suggestorPackageName);
+                        if (matchedNetworkInfo.wCmConfiguredNetwork == null) continue;
+                        mLocalLog.log(String.format("network suggestion candidate %s (new)",
+                                WifiNetworkSelector.toNetworkString(
+                                        matchedNetworkInfo.wCmConfiguredNetwork)));
+                    } else {
+                        mLocalLog.log(String.format("network suggestion candidate %s (existing)",
+                                WifiNetworkSelector.toNetworkString(
+                                        matchedNetworkInfo.wCmConfiguredNetwork)));
+                    }
+                    allMatchedNetworkInfos.add(matchedNetworkInfo);
+                    // Invoke onConnectable for the best networks from each app.
+                    onConnectableListener.onConnectable(
+                            matchedNetworkInfo.matchingScanDetail,
+                            matchedNetworkInfo.wCmConfiguredNetwork,
+                            0);
+                }
+            }
+            PerNetworkSuggestionMatchMetaInfo networkInfo = allMatchedNetworkInfos
+                    .stream()
+                    .max(Comparator.comparing(e -> e.matchingScanDetail.getScanResult().level))
+                    .orElse(null);
+            if (networkInfo == null) { // should never happen.
+                Log.wtf(TAG, "Unexepectedly got null");
+                return null;
+            }
+            return networkInfo;
+        }
+    }
+
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/NetworkSuggestionEvaluatorTest.java b/tests/wifitests/src/com/android/server/wifi/NetworkSuggestionEvaluatorTest.java
index 4f494c0d7..fadfc6bc5 100644
--- a/tests/wifitests/src/com/android/server/wifi/NetworkSuggestionEvaluatorTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/NetworkSuggestionEvaluatorTest.java
@@ -125,7 +125,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK};
         boolean[] appInteractions = {true};
         boolean[] meteredness = {true};
-        int[] priorities = {0};
+        int[] priorities = {-1};
         int[] uids = {TEST_UID};
         String[] packageNames = {TEST_PACKAGE};
 
@@ -148,7 +148,7 @@ public class NetworkSuggestionEvaluatorTest {
         assertNotNull(candidate);
         assertEquals(suggestionSsids[0] , candidate.SSID);
 
-        validateConnectableNetworks(connectableNetworks, new String[] {scanSsids[0]});
+        validateConnectableNetworks(connectableNetworks, scanSsids[0]);
 
         verifyAddToWifiConfigManager(suggestions[0].wifiConfiguration);
     }
@@ -170,7 +170,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK, SECURITY_PSK};
         boolean[] appInteractions = {true, true};
         boolean[] meteredness = {true, true};
-        int[] priorities = {0, 1};
+        int[] priorities = {-1, -1};
         int[] uids = {TEST_UID, TEST_UID};
         String[] packageNames = {TEST_PACKAGE, TEST_PACKAGE};
 
@@ -194,14 +194,60 @@ public class NetworkSuggestionEvaluatorTest {
         assertNotNull(candidate);
         assertEquals(suggestionSsids[1] , candidate.SSID);
 
-        validateConnectableNetworks(connectableNetworks, scanSsids);
+        validateConnectableNetworks(connectableNetworks, scanSsids[0], scanSsids[1]);
 
-        verifyAddToWifiConfigManager(suggestions[0].wifiConfiguration,
+        verifyAddToWifiConfigManager(suggestions[1].wifiConfiguration,
                 suggestions[1].wifiConfiguration);
     }
 
     /**
      * Ensure that we select the network suggestion corresponding to the scan result with
+     * higest priority.
+     * Expected candidate: suggestionSsids[0]
+     * Expected connectable Networks: {suggestionSsids[0], suggestionSsids[1]}
+     */
+    @Test
+    public void testSelectNetworkSuggestionForMultipleMatchHighPriorityWins() {
+        String[] scanSsids = {"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[] levels = {-56, -45};
+        String[] suggestionSsids = {"\"" + scanSsids[0] + "\"", "\"" + scanSsids[1] + "\""};
+        int[] securities = {SECURITY_PSK, SECURITY_PSK};
+        boolean[] appInteractions = {true, true};
+        boolean[] meteredness = {true, true};
+        int[] priorities = {5, 1};
+        int[] uids = {TEST_UID, TEST_UID};
+        String[] packageNames = {TEST_PACKAGE, TEST_PACKAGE};
+
+        ScanDetail[] scanDetails =
+                buildScanDetails(scanSsids, bssids, freqs, caps, levels, mClock);
+        WifiNetworkSuggestion[] suggestions = buildNetworkSuggestions(suggestionSsids, securities,
+                appInteractions, meteredness, priorities, uids, packageNames);
+        // Link the scan result with suggestions.
+        linkScanDetailsWithNetworkSuggestions(scanDetails, suggestions);
+        // setup config manager interactions.
+        setupAddToWifiConfigManager(suggestions[0].wifiConfiguration,
+                suggestions[1].wifiConfiguration);
+
+        List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>();
+        WifiConfiguration candidate = mNetworkSuggestionEvaluator.evaluateNetworks(
+                Arrays.asList(scanDetails), null, null, true, false,
+                (ScanDetail scanDetail, WifiConfiguration configuration, int score) -> {
+                    connectableNetworks.add(Pair.create(scanDetail, configuration));
+                });
+
+        assertNotNull(candidate);
+        assertEquals(suggestionSsids[0] , candidate.SSID);
+
+        validateConnectableNetworks(connectableNetworks, scanSsids[0]);
+
+        verifyAddToWifiConfigManager(suggestions[0].wifiConfiguration);
+    }
+
+    /**
+     * Ensure that we select the network suggestion corresponding to the scan result with
      * highest RSSI. The lower RSSI scan result has multiple matching suggestions
      * (should pick any one in the connectable networks).
      *
@@ -221,7 +267,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK, SECURITY_PSK, SECURITY_PSK};
         boolean[] appInteractions = {true, true, false};
         boolean[] meteredness = {true, true, false};
-        int[] priorities = {0, 1, 0};
+        int[] priorities = {-1, -1, -1};
         int[] uids = {TEST_UID, TEST_UID, TEST_UID_OTHER};
         String[] packageNames = {TEST_PACKAGE, TEST_PACKAGE, TEST_PACKAGE_OTHER};
 
@@ -252,6 +298,66 @@ public class NetworkSuggestionEvaluatorTest {
     }
 
     /**
+     * Ensure that we select the network suggestion with the higest priority among network
+     * suggestions from the same package. Among different packages, pick the suggestion
+     * corresponding to the scan result with highest RSSI.
+     *
+     * The suggestion[1] has higher priority than suggestion[0] even though it has lower RSSI than
+     * suggestion[0].
+     *
+     * Expected candidate: suggestionSsids[1]
+     * Expected connectable Networks: {suggestionSsids[1],
+     *                                 (suggestionSsids[2],
+     *                                  suggestionSsids[3]}
+     */
+    @Test
+    public void
+            testSelectNetworkSuggestionForMultipleMatchWithMultipleSuggestionsHighPriorityWins() {
+        String[] scanSsids = {"test1", "test2", "test3", "test4"};
+        String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4", "6c:fc:de:34:12",
+                "6c:fd:a1:11:11:98"};
+        int[] freqs = {2470, 2437, 2470, 2437};
+        String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[WPA2-EAP-CCMP][ESS]", "[WPA2-EAP-CCMP][ESS]",
+                "[WPA2-EAP-CCMP][ESS]"};
+        int[] levels = {-23, -45, -56, -65};
+        String[] suggestionSsids = {"\"" + scanSsids[0] + "\"", "\"" + scanSsids[1] + "\"",
+                "\"" + scanSsids[2] + "\"", "\"" + scanSsids[3] + "\""};
+        int[] securities = {SECURITY_PSK, SECURITY_PSK, SECURITY_PSK, SECURITY_PSK};
+        boolean[] appInteractions = {true, true, false, false};
+        boolean[] meteredness = {true, true, false, false};
+        int[] priorities = {0, 5, -1, -1};
+        int[] uids = {TEST_UID, TEST_UID, TEST_UID_OTHER, TEST_UID_OTHER};
+        String[] packageNames = {TEST_PACKAGE, TEST_PACKAGE, TEST_PACKAGE_OTHER,
+                TEST_PACKAGE_OTHER};
+
+        ScanDetail[] scanDetails =
+                buildScanDetails(scanSsids, bssids, freqs, caps, levels, mClock);
+        WifiNetworkSuggestion[] suggestions = buildNetworkSuggestions(suggestionSsids, securities,
+                appInteractions, meteredness, priorities, uids, packageNames);
+        // Link the scan result with suggestions.
+        linkScanDetailsWithNetworkSuggestions(scanDetails, suggestions);
+        // setup config manager interactions.
+        setupAddToWifiConfigManager(suggestions[0].wifiConfiguration,
+                suggestions[1].wifiConfiguration, suggestions[2].wifiConfiguration,
+                suggestions[3].wifiConfiguration);
+
+        List<Pair<ScanDetail, WifiConfiguration>> connectableNetworks = new ArrayList<>();
+        WifiConfiguration candidate = mNetworkSuggestionEvaluator.evaluateNetworks(
+                Arrays.asList(scanDetails), null, null, true, false,
+                (ScanDetail scanDetail, WifiConfiguration configuration, int score) -> {
+                    connectableNetworks.add(Pair.create(scanDetail, configuration));
+                });
+
+        assertNotNull(candidate);
+        assertEquals(suggestionSsids[1] , candidate.SSID);
+
+        validateConnectableNetworks(connectableNetworks, scanSsids[1], scanSsids[2], scanSsids[3]);
+
+        verifyAddToWifiConfigManager(suggestions[1].wifiConfiguration,
+                suggestions[2].wifiConfiguration, suggestions[3].wifiConfiguration);
+    }
+
+    /**
      * Ensure that we select the only matching network suggestion, but return null because
      * we failed the {@link WifiConfigManager} interactions.
      * Expected candidate: null.
@@ -268,7 +374,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK};
         boolean[] appInteractions = {true};
         boolean[] meteredness = {true};
-        int[] priorities = {0};
+        int[] priorities = {-1};
         int[] uids = {TEST_UID};
         String[] packageNames = {TEST_PACKAGE};
 
@@ -292,7 +398,7 @@ public class NetworkSuggestionEvaluatorTest {
         assertNull(candidate);
         assertTrue(connectableNetworks.isEmpty());
 
-        verify(mWifiConfigManager, times(suggestionSsids.length))
+        verify(mWifiConfigManager, times(scanSsids.length))
                 .wasEphemeralNetworkDeleted(anyString());
         verify(mWifiConfigManager).getConfiguredNetwork(eq(
                 suggestions[0].wifiConfiguration.configKey()));
@@ -319,7 +425,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK};
         boolean[] appInteractions = {true};
         boolean[] meteredness = {true};
-        int[] priorities = {0};
+        int[] priorities = {-1};
         int[] uids = {TEST_UID};
         String[] packageNames = {TEST_PACKAGE};
 
@@ -346,7 +452,7 @@ public class NetworkSuggestionEvaluatorTest {
         validateConnectableNetworks(connectableNetworks, new String[] {scanSsids[0]});
 
         // check for any saved networks.
-        verify(mWifiConfigManager, times(suggestionSsids.length))
+        verify(mWifiConfigManager, times(scanSsids.length))
                 .wasEphemeralNetworkDeleted(anyString());
         verify(mWifiConfigManager).getConfiguredNetwork(candidate.configKey());
         // Verify we did not try to add any new networks or other interactions with
@@ -371,7 +477,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK};
         boolean[] appInteractions = {true};
         boolean[] meteredness = {true};
-        int[] priorities = {0};
+        int[] priorities = {-1};
         int[] uids = {TEST_UID};
         String[] packageNames = {TEST_PACKAGE};
 
@@ -396,7 +502,7 @@ public class NetworkSuggestionEvaluatorTest {
         assertNull(candidate);
         assertTrue(connectableNetworks.isEmpty());
 
-        verify(mWifiConfigManager, times(suggestionSsids.length))
+        verify(mWifiConfigManager, times(scanSsids.length))
                 .wasEphemeralNetworkDeleted(anyString());
         // Verify we did not try to add any new networks or other interactions with
         // WifiConfigManager.
@@ -421,7 +527,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK};
         boolean[] appInteractions = {true};
         boolean[] meteredness = {true};
-        int[] priorities = {0};
+        int[] priorities = {-1};
         int[] uids = {TEST_UID};
         String[] packageNames = {TEST_PACKAGE};
 
@@ -450,7 +556,7 @@ public class NetworkSuggestionEvaluatorTest {
         assertNull(candidate);
         assertTrue(connectableNetworks.isEmpty());
 
-        verify(mWifiConfigManager, times(suggestionSsids.length))
+        verify(mWifiConfigManager, times(scanSsids.length))
                 .wasEphemeralNetworkDeleted(anyString());
         verify(mWifiConfigManager).getConfiguredNetwork(eq(
                 suggestions[0].wifiConfiguration.configKey()));
@@ -479,7 +585,7 @@ public class NetworkSuggestionEvaluatorTest {
         int[] securities = {SECURITY_PSK};
         boolean[] appInteractions = {true};
         boolean[] meteredness = {true};
-        int[] priorities = {0};
+        int[] priorities = {-1};
         int[] uids = {TEST_UID};
         String[] packageNames = {TEST_PACKAGE};
 
@@ -512,7 +618,7 @@ public class NetworkSuggestionEvaluatorTest {
 
         validateConnectableNetworks(connectableNetworks, new String[] {scanSsids[0]});
 
-        verify(mWifiConfigManager, times(suggestionSsids.length))
+        verify(mWifiConfigManager, times(scanSsids.length))
                 .wasEphemeralNetworkDeleted(anyString());
         verify(mWifiConfigManager).getConfiguredNetwork(eq(
                 suggestions[0].wifiConfiguration.configKey()));
@@ -555,7 +661,7 @@ public class NetworkSuggestionEvaluatorTest {
 
     private void verifyAddToWifiConfigManager(WifiConfiguration...candidates) {
         // check for any saved networks.
-        verify(mWifiConfigManager, times(candidates.length)).getConfiguredNetwork(anyString());
+        verify(mWifiConfigManager, atLeast(candidates.length)).getConfiguredNetwork(anyString());
 
         ArgumentCaptor<WifiConfiguration> wifiConfigurationCaptor =
                 ArgumentCaptor.forClass(WifiConfiguration.class);
@@ -675,8 +781,8 @@ public class NetworkSuggestionEvaluatorTest {
     }
 
     private void validateConnectableNetworks(List<Pair<ScanDetail, WifiConfiguration>> actual,
-                                             String[] expectedSsids) {
-        Set<String> expectedSsidSet = new HashSet<String>(Arrays.asList(expectedSsids));
+                                             String...expectedSsids) {
+        Set<String> expectedSsidSet = new HashSet<>(Arrays.asList(expectedSsids));
         assertEquals(expectedSsidSet.size(), actual.size());
 
         for (Pair<ScanDetail, WifiConfiguration> candidate : actual) {