| /* |
| * Copyright (C) 2018 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 android.net.wifi.WifiConfiguration.NetworkSelectionStatus |
| .NETWORK_SELECTION_TEMPORARY_DISABLED; |
| |
| import static com.android.server.wifi.WifiConfigurationTestUtil.SECURITY_PSK; |
| import static com.android.server.wifi.WifiConfigurationTestUtil.generateWifiConfig; |
| |
| import static org.junit.Assert.*; |
| import static org.mockito.Mockito.*; |
| |
| import android.net.wifi.WifiConfiguration; |
| import android.net.wifi.WifiNetworkSuggestion; |
| import android.net.wifi.WifiSsid; |
| import android.util.LocalLog; |
| import android.util.Pair; |
| |
| import androidx.test.filters.SmallTest; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.mockito.ArgumentCaptor; |
| import org.mockito.ArgumentMatcher; |
| import org.mockito.Mock; |
| import org.mockito.MockitoAnnotations; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * Unit tests for {@link com.android.server.wifi.NetworkSuggestionEvaluator}. |
| */ |
| @SmallTest |
| public class NetworkSuggestionEvaluatorTest { |
| private static final int TEST_UID = 3555; |
| private static final int TEST_UID_OTHER = 3545; |
| private static final int TEST_NETWORK_ID = 55; |
| private static final String TEST_PACKAGE = "com.test"; |
| private static final String TEST_PACKAGE_OTHER = "com.test.other"; |
| |
| private @Mock WifiConfigManager mWifiConfigManager; |
| private @Mock WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager; |
| private @Mock Clock mClock; |
| private NetworkSuggestionEvaluator mNetworkSuggestionEvaluator; |
| |
| /** Sets up test. */ |
| @Before |
| public void setUp() throws Exception { |
| MockitoAnnotations.initMocks(this); |
| |
| mNetworkSuggestionEvaluator = new NetworkSuggestionEvaluator( |
| mWifiNetworkSuggestionsManager, mWifiConfigManager, new LocalLog(100)); |
| } |
| |
| /** |
| * Ensure that we ignore all scan results not matching the network suggestion. |
| * Expected candidate: null |
| * Expected connectable Networks: {} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForNoMatch() { |
| 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 = {-67, -76}; |
| String[] suggestionSsids = {}; |
| int[] securities = {}; |
| boolean[] appInteractions = {}; |
| boolean[] meteredness = {}; |
| int[] priorities = {}; |
| int[] uids = {}; |
| String[] packageNames = {}; |
| |
| 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); |
| |
| 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)); |
| }); |
| |
| assertNull(candidate); |
| assertTrue(connectableNetworks.isEmpty()); |
| } |
| |
| /** |
| * Ensure that we select the only matching network suggestion. |
| * Expected candidate: suggestionSsids[0] |
| * Expected connectable Networks: {suggestionSsids[0]} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForOneMatch() { |
| 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 = {-67, -76}; |
| String[] suggestionSsids = {"\"" + scanSsids[0] + "\""}; |
| int[] securities = {SECURITY_PSK}; |
| boolean[] appInteractions = {true}; |
| boolean[] meteredness = {true}; |
| int[] priorities = {-1}; |
| int[] uids = {TEST_UID}; |
| String[] packageNames = {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); |
| |
| 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. |
| * Expected candidate: suggestionSsids[1] |
| * Expected connectable Networks: {suggestionSsids[0], suggestionSsids[1]} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForMultipleMatch() { |
| 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 = {-1, -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[1] , candidate.SSID); |
| |
| validateConnectableNetworks(connectableNetworks, scanSsids[0], scanSsids[1]); |
| |
| 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). |
| * |
| * Expected candidate: suggestionSsids[0] |
| * Expected connectable Networks: {suggestionSsids[0], |
| * (suggestionSsids[1] || suggestionSsids[2]} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForMultipleMatchWithMultipleSuggestions() { |
| 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 = {-23, -45}; |
| String[] suggestionSsids = {"\"" + scanSsids[0] + "\"", "\"" + scanSsids[1] + "\"", |
| "\"" + scanSsids[1] + "\""}; |
| int[] securities = {SECURITY_PSK, SECURITY_PSK, SECURITY_PSK}; |
| boolean[] appInteractions = {true, true, false}; |
| boolean[] meteredness = {true, true, false}; |
| int[] priorities = {-1, -1, -1}; |
| int[] uids = {TEST_UID, TEST_UID, TEST_UID_OTHER}; |
| String[] packageNames = {TEST_PACKAGE, TEST_PACKAGE, 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); |
| |
| 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); |
| |
| verifyAddToWifiConfigManager(suggestions[0].wifiConfiguration, |
| suggestions[1].wifiConfiguration); |
| } |
| |
| /** |
| * 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. |
| * Expected connectable Networks: {suggestionSsids[0], suggestionSsids[1]} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForOneMatchButFailToAddToWifiConfigManager() { |
| 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 = {-67, -76}; |
| String[] suggestionSsids = {"\"" + scanSsids[0] + "\""}; |
| int[] securities = {SECURITY_PSK}; |
| boolean[] appInteractions = {true}; |
| boolean[] meteredness = {true}; |
| int[] priorities = {-1}; |
| int[] uids = {TEST_UID}; |
| String[] packageNames = {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); |
| // Fail add to WifiConfigManager |
| when(mWifiConfigManager.addOrUpdateNetwork(any(), anyInt(), anyString())) |
| .thenReturn(new NetworkUpdateResult(WifiConfiguration.INVALID_NETWORK_ID)); |
| |
| 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)); |
| }); |
| |
| assertNull(candidate); |
| assertTrue(connectableNetworks.isEmpty()); |
| |
| verify(mWifiConfigManager, times(scanSsids.length)) |
| .wasEphemeralNetworkDeleted(anyString()); |
| verify(mWifiConfigManager).getConfiguredNetwork(eq( |
| suggestions[0].wifiConfiguration.configKey())); |
| verify(mWifiConfigManager).addOrUpdateNetwork(any(), anyInt(), anyString()); |
| // Verify we did not try to add any new networks or other interactions with |
| // WifiConfigManager. |
| verifyNoMoreInteractions(mWifiConfigManager); |
| } |
| |
| /** |
| * Ensure that we select the only matching network suggestion, but that matches an existing |
| * saved network (maybe saved or maybe it exists from a previous connection attempt) . |
| * Expected candidate: suggestionSsids[0] |
| * Expected connectable Networks: {suggestionSsids[0]} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForOneMatchForExistingNetwork() { |
| 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 = {-67, -76}; |
| String[] suggestionSsids = {"\"" + scanSsids[0] + "\""}; |
| int[] securities = {SECURITY_PSK}; |
| boolean[] appInteractions = {true}; |
| boolean[] meteredness = {true}; |
| int[] priorities = {-1}; |
| int[] uids = {TEST_UID}; |
| String[] packageNames = {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); |
| // Existing saved network matching the credentials. |
| when(mWifiConfigManager.getConfiguredNetwork(suggestions[0].wifiConfiguration.configKey())) |
| .thenReturn(suggestions[0].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, new String[] {scanSsids[0]}); |
| |
| // check for any saved networks. |
| 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 |
| // WifiConfigManager. |
| verifyNoMoreInteractions(mWifiConfigManager); |
| } |
| |
| /** |
| * Ensure that we don't select the only matching network suggestion if it was previously |
| * disabled by the user. |
| * Expected candidate: null |
| * Expected connectable Networks: {} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForOneMatchButUserForgotTheNetwork() { |
| 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 = {-67, -76}; |
| String[] suggestionSsids = {"\"" + scanSsids[0] + "\""}; |
| int[] securities = {SECURITY_PSK}; |
| boolean[] appInteractions = {true}; |
| boolean[] meteredness = {true}; |
| int[] priorities = {-1}; |
| int[] uids = {TEST_UID}; |
| String[] packageNames = {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); |
| // Network was disabled by the user. |
| when(mWifiConfigManager.wasEphemeralNetworkDeleted(suggestionSsids[0])).thenReturn(true); |
| |
| 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)); |
| }); |
| |
| assertNull(candidate); |
| assertTrue(connectableNetworks.isEmpty()); |
| |
| verify(mWifiConfigManager, times(scanSsids.length)) |
| .wasEphemeralNetworkDeleted(anyString()); |
| // Verify we did not try to add any new networks or other interactions with |
| // WifiConfigManager. |
| verifyNoMoreInteractions(mWifiConfigManager); |
| } |
| |
| /** |
| * Ensure that we don't select the only matching network suggestion if the network configuration |
| * already exists (maybe saved or maybe it exists from a previous connection attempt) and |
| * blacklisted. |
| * Expected candidate: null |
| * Expected connectable Networks: {} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForOneMatchForExistingNetworkButTempDisabled() { |
| 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 = {-67, -76}; |
| String[] suggestionSsids = {"\"" + scanSsids[0] + "\""}; |
| int[] securities = {SECURITY_PSK}; |
| boolean[] appInteractions = {true}; |
| boolean[] meteredness = {true}; |
| int[] priorities = {-1}; |
| int[] uids = {TEST_UID}; |
| String[] packageNames = {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); |
| // Mark the network disabled. |
| suggestions[0].wifiConfiguration.getNetworkSelectionStatus().setNetworkSelectionStatus( |
| NETWORK_SELECTION_TEMPORARY_DISABLED); |
| // Existing network matching the credentials. |
| when(mWifiConfigManager.getConfiguredNetwork(suggestions[0].wifiConfiguration.configKey())) |
| .thenReturn(suggestions[0].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)); |
| }); |
| |
| assertNull(candidate); |
| assertTrue(connectableNetworks.isEmpty()); |
| |
| verify(mWifiConfigManager, times(scanSsids.length)) |
| .wasEphemeralNetworkDeleted(anyString()); |
| verify(mWifiConfigManager).getConfiguredNetwork(eq( |
| suggestions[0].wifiConfiguration.configKey())); |
| verify(mWifiConfigManager).tryEnableNetwork(eq( |
| suggestions[0].wifiConfiguration.networkId)); |
| // Verify we did not try to add any new networks or other interactions with |
| // WifiConfigManager. |
| verifyNoMoreInteractions(mWifiConfigManager); |
| } |
| |
| /** |
| * Ensure that we do select the only matching network suggestion if the network configuration |
| * already exists (maybe saved or maybe it exists from a previous connection attempt) and a |
| * temporary blacklist expired. |
| * Expected candidate: suggestionSsids[0] |
| * Expected connectable Networks: {suggestionSsids[0]} |
| */ |
| @Test |
| public void testSelectNetworkSuggestionForOneMatchForExistingNetworkButTempDisableExpired() { |
| 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 = {-67, -76}; |
| String[] suggestionSsids = {"\"" + scanSsids[0] + "\""}; |
| int[] securities = {SECURITY_PSK}; |
| boolean[] appInteractions = {true}; |
| boolean[] meteredness = {true}; |
| int[] priorities = {-1}; |
| int[] uids = {TEST_UID}; |
| String[] packageNames = {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); |
| // Mark the network disabled. |
| suggestions[0].wifiConfiguration.getNetworkSelectionStatus().setNetworkSelectionStatus( |
| NETWORK_SELECTION_TEMPORARY_DISABLED); |
| // Existing network matching the credentials. |
| when(mWifiConfigManager.getConfiguredNetwork(suggestions[0].wifiConfiguration.configKey())) |
| .thenReturn(suggestions[0].wifiConfiguration); |
| when(mWifiConfigManager.tryEnableNetwork(suggestions[0].wifiConfiguration.networkId)) |
| .thenReturn(true); |
| |
| 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, new String[] {scanSsids[0]}); |
| |
| verify(mWifiConfigManager, times(scanSsids.length)) |
| .wasEphemeralNetworkDeleted(anyString()); |
| verify(mWifiConfigManager).getConfiguredNetwork(eq( |
| suggestions[0].wifiConfiguration.configKey())); |
| verify(mWifiConfigManager).tryEnableNetwork(eq( |
| suggestions[0].wifiConfiguration.networkId)); |
| // Verify we did not try to add any new networks or other interactions with |
| // WifiConfigManager. |
| verifyNoMoreInteractions(mWifiConfigManager); |
| } |
| |
| private void setupAddToWifiConfigManager(WifiConfiguration...candidates) { |
| for (int i = 0; i < candidates.length; i++) { |
| WifiConfiguration candidate = candidates[i]; |
| // setup & verify the WifiConfigmanager interactions for adding/enabling the network. |
| when(mWifiConfigManager.addOrUpdateNetwork( |
| argThat(new WifiConfigMatcher(candidate)), anyInt(), anyString())) |
| .thenReturn(new NetworkUpdateResult(TEST_NETWORK_ID + i)); |
| when(mWifiConfigManager.updateNetworkSelectionStatus(eq(TEST_NETWORK_ID + i), anyInt())) |
| .thenReturn(true); |
| candidate.networkId = TEST_NETWORK_ID + i; |
| when(mWifiConfigManager.getConfiguredNetwork(TEST_NETWORK_ID + i)) |
| .thenReturn(candidate); |
| } |
| } |
| |
| class WifiConfigMatcher implements ArgumentMatcher<WifiConfiguration> { |
| private final WifiConfiguration mConfig; |
| |
| WifiConfigMatcher(WifiConfiguration config) { |
| assertNotNull(config); |
| mConfig = config; |
| } |
| |
| @Override |
| public boolean matches(WifiConfiguration otherConfig) { |
| if (otherConfig == null) return false; |
| return mConfig.configKey().equals(otherConfig.configKey()); |
| } |
| } |
| |
| private void verifyAddToWifiConfigManager(WifiConfiguration...candidates) { |
| // check for any saved networks. |
| verify(mWifiConfigManager, atLeast(candidates.length)).getConfiguredNetwork(anyString()); |
| |
| ArgumentCaptor<WifiConfiguration> wifiConfigurationCaptor = |
| ArgumentCaptor.forClass(WifiConfiguration.class); |
| verify(mWifiConfigManager, times(candidates.length)).addOrUpdateNetwork( |
| wifiConfigurationCaptor.capture(), anyInt(), anyString()); |
| for (int i = 0; i < candidates.length; i++) { |
| WifiConfiguration addedWifiConfiguration = null; |
| for (WifiConfiguration configuration : wifiConfigurationCaptor.getAllValues()) { |
| if (configuration.SSID.equals(candidates[i].SSID)) { |
| addedWifiConfiguration = configuration; |
| break; |
| } |
| } |
| assertNotNull(addedWifiConfiguration); |
| assertTrue(addedWifiConfiguration.ephemeral); |
| assertTrue(addedWifiConfiguration.fromWifiNetworkSuggestion); |
| } |
| |
| verify(mWifiConfigManager, times(candidates.length)).updateNetworkSelectionStatus( |
| anyInt(), anyInt()); |
| verify(mWifiConfigManager, times(candidates.length)).getConfiguredNetwork(anyInt()); |
| } |
| |
| /** |
| * Build an array of scanDetails based on the caller supplied network SSID, BSSID, |
| * frequency, capability and RSSI level information. |
| */ |
| public static ScanDetail[] buildScanDetails(String[] ssids, String[] bssids, int[] freqs, |
| String[] caps, int[] levels, Clock clock) { |
| if (ssids == null || ssids.length == 0) return new ScanDetail[0]; |
| |
| ScanDetail[] scanDetails = new ScanDetail[ssids.length]; |
| long timeStamp = clock.getElapsedSinceBootMillis(); |
| for (int index = 0; index < ssids.length; index++) { |
| scanDetails[index] = new ScanDetail(WifiSsid.createFromAsciiEncoded(ssids[index]), |
| bssids[index], caps[index], levels[index], freqs[index], timeStamp, 0); |
| } |
| return scanDetails; |
| } |
| |
| /** |
| * Generate an array of {@link android.net.wifi.WifiConfiguration} based on the caller |
| * supplied network SSID and security information. |
| */ |
| public static WifiConfiguration[] buildWifiConfigurations(String[] ssids, int[] securities) { |
| if (ssids == null || ssids.length == 0) return new WifiConfiguration[0]; |
| |
| WifiConfiguration[] configs = new WifiConfiguration[ssids.length]; |
| for (int index = 0; index < ssids.length; index++) { |
| configs[index] = generateWifiConfig(-1, 0, ssids[index], false, true, null, |
| null, securities[index]); |
| } |
| return configs; |
| } |
| |
| private WifiNetworkSuggestion[] buildNetworkSuggestions( |
| String[] ssids, int[] securities, boolean[] appInteractions, boolean[] meteredness, |
| int[] priorities, int[] uids, String[] packageNames) { |
| WifiConfiguration[] configs = buildWifiConfigurations(ssids, securities); |
| WifiNetworkSuggestion[] suggestions = new WifiNetworkSuggestion[configs.length]; |
| for (int i = 0; i < configs.length; i++) { |
| configs[i].priority = priorities[i]; |
| configs[i].meteredOverride = meteredness[i] |
| ? WifiConfiguration.METERED_OVERRIDE_METERED |
| : WifiConfiguration.METERED_OVERRIDE_NONE; |
| suggestions[i] = new WifiNetworkSuggestion(configs[i], appInteractions[i], |
| false, uids[i], packageNames[i]); |
| } |
| return suggestions; |
| } |
| |
| /** |
| * Link scan results to the network suggestions. |
| * |
| * The shorter of the 2 input params will be used to loop over so the inputs don't |
| * need to be of equal length. |
| * If there are more scan details than suggestions, the remaining |
| * scan details will be associated with a NULL suggestions. |
| * If there are more suggestions than scan details, the remaining |
| * suggestions will be associated with the last scan detail. |
| */ |
| private void linkScanDetailsWithNetworkSuggestions( |
| ScanDetail[] scanDetails, WifiNetworkSuggestion[] suggestions) { |
| if (suggestions == null || scanDetails == null) { |
| return; |
| } |
| int minLength = Math.min(scanDetails.length, suggestions.length); |
| |
| // 1 to 1 mapping from scan detail to suggestion. |
| for (int i = 0; i < minLength; i++) { |
| ScanDetail scanDetail = scanDetails[i]; |
| final WifiNetworkSuggestion matchingSuggestion = suggestions[i]; |
| HashSet<WifiNetworkSuggestion> matchingSuggestions = |
| new HashSet<WifiNetworkSuggestion>() {{ |
| add(matchingSuggestion); |
| }}; |
| when(mWifiNetworkSuggestionsManager.getNetworkSuggestionsForScanDetail(eq(scanDetail))) |
| .thenReturn((matchingSuggestions)); |
| } |
| if (scanDetails.length > suggestions.length) { |
| // No match for the remaining scan details. |
| for (int i = minLength; i < scanDetails.length; i++) { |
| ScanDetail scanDetail = scanDetails[i]; |
| when(mWifiNetworkSuggestionsManager.getNetworkSuggestionsForScanDetail( |
| eq(scanDetail))).thenReturn(null); |
| } |
| } else if (suggestions.length > scanDetails.length) { |
| // All the additional suggestions match the last scan detail. |
| HashSet<WifiNetworkSuggestion> matchingSuggestions = new HashSet<>(); |
| for (int i = minLength; i < suggestions.length; i++) { |
| matchingSuggestions.add(suggestions[i]); |
| } |
| ScanDetail lastScanDetail = scanDetails[minLength - 1]; |
| when(mWifiNetworkSuggestionsManager.getNetworkSuggestionsForScanDetail( |
| eq(lastScanDetail))).thenReturn((matchingSuggestions)); |
| } |
| } |
| |
| private void validateConnectableNetworks(List<Pair<ScanDetail, WifiConfiguration>> actual, |
| String...expectedSsids) { |
| Set<String> expectedSsidSet = new HashSet<>(Arrays.asList(expectedSsids)); |
| assertEquals(expectedSsidSet.size(), actual.size()); |
| |
| for (Pair<ScanDetail, WifiConfiguration> candidate : actual) { |
| // check if the scan detail matches the wificonfiguration. |
| assertEquals("\"" + candidate.first.getSSID() + "\"", candidate.second.SSID); |
| // check if both match one of the expected ssid's. |
| assertTrue(expectedSsidSet.remove(candidate.first.getSSID())); |
| } |
| assertTrue(expectedSsidSet.isEmpty()); |
| } |
| } |
