diff options
Diffstat (limited to 'tests')
3 files changed, 594 insertions, 555 deletions
diff --git a/tests/wifitests/src/com/android/server/wifi/RecommendedNetworkEvaluatorTest.java b/tests/wifitests/src/com/android/server/wifi/RecommendedNetworkEvaluatorTest.java deleted file mode 100644 index ef4f0a3fe..000000000 --- a/tests/wifitests/src/com/android/server/wifi/RecommendedNetworkEvaluatorTest.java +++ /dev/null @@ -1,551 +0,0 @@ -/* - * 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 junit.framework.Assert.assertNull; -import static junit.framework.Assert.assertTrue; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.anyString; -import static org.mockito.Mockito.*; - -import android.content.ContentResolver; -import android.content.Context; -import android.database.ContentObserver; -import android.net.NetworkKey; -import android.net.NetworkScoreManager; -import android.net.RecommendationRequest; -import android.net.RecommendationResult; -import android.net.Uri; -import android.net.WifiKey; -import android.net.wifi.ScanResult; -import android.net.wifi.WifiConfiguration; -import android.net.wifi.WifiConfiguration.NetworkSelectionStatus; -import android.net.wifi.WifiSsid; -import android.os.Looper; -import android.os.Process; -import android.provider.Settings; -import android.test.suitebuilder.annotation.SmallTest; -import android.util.ArraySet; -import android.util.LocalLog; -import android.util.Pair; - -import com.android.server.wifi.util.ScanResultUtil; - -import com.google.android.collect.Lists; - -import org.junit.Before; -import org.junit.Test; -import org.mockito.ArgumentCaptor; -import org.mockito.Captor; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import java.util.ArrayList; -import java.util.List; -import java.util.Set; -import java.util.concurrent.TimeUnit; - -/** - * Unit tests for {@link RecommendedNetworkEvaluator}. - */ -@SmallTest -public class RecommendedNetworkEvaluatorTest { - private ScanDetail mTrustedScanDetail; - private ScanDetail mUntrustedScanDetail; - private ScanDetail mEphemeralScanDetail; - private WifiConfiguration mTrustedWifiConfiguration; - private WifiConfiguration mUntrustedWifiConfiguration; - private WifiConfiguration mEphemeralWifiConfiguration; - private ContentObserver mContentObserver; - - @Mock private Context mContext; - @Mock private ContentResolver mContentResolver; - @Mock private FrameworkFacade mFrameworkFacade; - @Mock private NetworkScoreManager mNetworkScoreManager; - @Mock private WifiConfigManager mWifiConfigManager; - - @Captor private ArgumentCaptor<NetworkKey[]> mNetworkKeyArrayCaptor; - @Captor private ArgumentCaptor<RecommendationRequest> mRecommendationRequestCaptor; - - private RecommendedNetworkEvaluator mRecommendedNetworkEvaluator; - - @Before - public void setUp() throws Exception { - mTrustedScanDetail = buildScanDetail("ssid"); - mUntrustedScanDetail = buildScanDetail("ssid1"); - mEphemeralScanDetail = buildScanDetail("ssid2"); - - mTrustedWifiConfiguration = new WifiConfiguration(); - mTrustedWifiConfiguration.networkId = 5; - mTrustedWifiConfiguration.SSID = mTrustedScanDetail.getSSID(); - mTrustedWifiConfiguration.BSSID = mTrustedScanDetail.getBSSIDString(); - mTrustedWifiConfiguration.getNetworkSelectionStatus().setCandidate( - mTrustedScanDetail.getScanResult()); - - mUntrustedWifiConfiguration = new WifiConfiguration(); - mUntrustedWifiConfiguration.networkId = 6; - mUntrustedWifiConfiguration.SSID = mUntrustedScanDetail.getSSID(); - mUntrustedWifiConfiguration.BSSID = mUntrustedScanDetail.getBSSIDString(); - - mEphemeralWifiConfiguration = new WifiConfiguration(); - mEphemeralWifiConfiguration.SSID = mEphemeralScanDetail.getSSID(); - mEphemeralWifiConfiguration.BSSID = mEphemeralScanDetail.getBSSIDString(); - mEphemeralWifiConfiguration.ephemeral = true; - - MockitoAnnotations.initMocks(this); - - when(mFrameworkFacade.getIntegerSetting(mContext, - Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0)) - .thenReturn(1); - long dayMillis = TimeUnit.DAYS.toMillis(1); - when(mFrameworkFacade.getLongSetting(mContext, - Settings.Global.RECOMMENDED_NETWORK_EVALUATOR_CACHE_EXPIRY_MS, dayMillis)) - .thenReturn(dayMillis); - - ArgumentCaptor<ContentObserver> observerCaptor = - ArgumentCaptor.forClass(ContentObserver.class); - mRecommendedNetworkEvaluator = new RecommendedNetworkEvaluator(mContext, mContentResolver, - Looper.getMainLooper(), mFrameworkFacade, mNetworkScoreManager, - mWifiConfigManager, new LocalLog(0)); - verify(mFrameworkFacade).registerContentObserver(eq(mContext), any(Uri.class), eq(false), - observerCaptor.capture()); - mContentObserver = observerCaptor.getValue(); - - reset(mNetworkScoreManager); - - when(mWifiConfigManager.getSavedNetworkForScanDetailAndCache(mTrustedScanDetail)) - .thenReturn(mTrustedWifiConfiguration); - when(mWifiConfigManager.getSavedNetworkForScanDetailAndCache(mUntrustedScanDetail)) - .thenReturn(null); - when(mWifiConfigManager.getSavedNetworkForScanDetailAndCache(mEphemeralScanDetail)) - .thenReturn(mEphemeralWifiConfiguration); - when(mWifiConfigManager.getConfiguredNetwork(mTrustedWifiConfiguration.networkId)) - .thenReturn(mTrustedWifiConfiguration); - when(mWifiConfigManager.getSavedNetworks()) - .thenReturn(Lists.newArrayList(mTrustedWifiConfiguration)); - } - - @Test - public void testUpdate_recommendationsDisabled() { - ArrayList<ScanDetail> scanDetails = new ArrayList<>(); - when(mFrameworkFacade.getIntegerSetting(mContext, - Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0)) - .thenReturn(0); - - mContentObserver.onChange(false /* unused */); - - mRecommendedNetworkEvaluator.update(scanDetails); - - verifyZeroInteractions(mNetworkScoreManager); - verify(mWifiConfigManager).updateNetworkNotRecommended( - mTrustedWifiConfiguration.networkId, false /* notRecommended */); - } - - @Test - public void testUpdate_emptyScanList() { - mRecommendedNetworkEvaluator.update(new ArrayList<ScanDetail>()); - - verifyZeroInteractions(mNetworkScoreManager); - verify(mWifiConfigManager).updateNetworkNotRecommended( - mTrustedWifiConfiguration.networkId, false /* notRecommended */); - } - - @Test - public void testUpdate_allNetworksUnscored() { - mRecommendedNetworkEvaluator.update(Lists.newArrayList(mTrustedScanDetail, - mUntrustedScanDetail)); - - verify(mWifiConfigManager).updateNetworkNotRecommended( - mTrustedWifiConfiguration.networkId, false /* notRecommended */); - verify(mNetworkScoreManager).requestScores(mNetworkKeyArrayCaptor.capture()); - assertEquals(2, mNetworkKeyArrayCaptor.getValue().length); - NetworkKey expectedNetworkKey = new NetworkKey(new WifiKey(ScanResultUtil.createQuotedSSID( - mTrustedScanDetail.getSSID()), mTrustedScanDetail.getBSSIDString())); - assertEquals(expectedNetworkKey, mNetworkKeyArrayCaptor.getValue()[0]); - expectedNetworkKey = new NetworkKey(new WifiKey(ScanResultUtil.createQuotedSSID( - mUntrustedScanDetail.getSSID()), mUntrustedScanDetail.getBSSIDString())); - assertEquals(expectedNetworkKey, mNetworkKeyArrayCaptor.getValue()[1]); - } - - @Test - public void testUpdate_oneScored_twoScored() { - mRecommendedNetworkEvaluator.update(Lists.newArrayList(mUntrustedScanDetail)); - - // Next scan should only trigger a request for the trusted network. - mRecommendedNetworkEvaluator.update( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail)); - - verify(mWifiConfigManager, times(2)).updateNetworkNotRecommended( - mTrustedWifiConfiguration.networkId, false /* notRecommended */); - verify(mNetworkScoreManager, times(2)).requestScores(mNetworkKeyArrayCaptor.capture()); - - NetworkKey[] requestedScores = mNetworkKeyArrayCaptor.getAllValues().get(0); - assertEquals(1, requestedScores.length); - NetworkKey expectedNetworkKey = new NetworkKey(new WifiKey(ScanResultUtil.createQuotedSSID( - mUntrustedScanDetail.getSSID()), mUntrustedScanDetail.getBSSIDString())); - assertEquals(expectedNetworkKey, requestedScores[0]); - - requestedScores = mNetworkKeyArrayCaptor.getAllValues().get(1); - assertEquals(1, requestedScores.length); - expectedNetworkKey = new NetworkKey(new WifiKey(ScanResultUtil.createQuotedSSID( - mTrustedScanDetail.getSSID()), mTrustedScanDetail.getBSSIDString())); - assertEquals(expectedNetworkKey, requestedScores[0]); - } - - @Test - public void testEvaluateNetworks_recommendationsDisabled() { - when(mFrameworkFacade.getIntegerSetting(mContext, - Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0)) - .thenReturn(0); - - mContentObserver.onChange(false /* unused */); - - mRecommendedNetworkEvaluator.evaluateNetworks(null, null, null, false, false, null); - - verifyZeroInteractions(mWifiConfigManager, mNetworkScoreManager); - } - - @Test - public void testEvaluateNetworks_emptyScanList() { - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - new ArrayList<ScanDetail>(), null, null, false, - false /* untrustedNetworkAllowed */, null); - - assertNull(result); - verifyZeroInteractions(mWifiConfigManager, mNetworkScoreManager); - } - - @Test - public void testEvaluateNetworks_onlyTrustedNetworksAllowed_noTrustedInScanList() { - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mUntrustedScanDetail), null, null, false, - false /* untrustedNetworkAllowed */, null); - - assertNull(result); - verifyZeroInteractions(mNetworkScoreManager); - } - - @Test - public void testEvaluateNetworks_untrustedNetworksAllowed_onlyDeletedEphemeral() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(ScanResultUtil - .createQuotedSSID(mUntrustedScanDetail.getScanResult().SSID))) - .thenReturn(true); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mUntrustedScanDetail), null, null, false, - true /* untrustedNetworkAllowed */, null); - - assertNull(result); - verifyZeroInteractions(mNetworkScoreManager); - } - - @Test - public void testEvaluateNetworks_recommendation_onlyTrustedNetworkAllowed() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult - .createConnectRecommendation(mTrustedWifiConfiguration)); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail), - null, null, false, false /* untrustedNetworkAllowed */, null); - - assertEquals(mTrustedWifiConfiguration, result); - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - assertEquals(1, mRecommendationRequestCaptor.getValue().getScanResults().length); - assertEquals(mTrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[0]); - verify(mWifiConfigManager).setNetworkCandidateScanResult( - mTrustedWifiConfiguration.networkId, mTrustedScanDetail.getScanResult(), 0); - } - - @Test - public void testEvaluateNetworks_trustedRecommendation_untrustedNetworksAllowed() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult - .createConnectRecommendation(mTrustedWifiConfiguration)); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - assertEquals(mTrustedWifiConfiguration, result); - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - assertEquals(2, mRecommendationRequestCaptor.getValue().getScanResults().length); - assertEquals(mTrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[0]); - assertEquals(mUntrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[1]); - verify(mWifiConfigManager).setNetworkCandidateScanResult( - mTrustedWifiConfiguration.networkId, mTrustedScanDetail.getScanResult(), 0); - } - - @Test - public void testEvaluateNetworks_trustedRecommendation_anyBssidSpecified() { - WifiConfiguration recommendedNetwork = new WifiConfiguration(); - recommendedNetwork.SSID = mTrustedWifiConfiguration.SSID; - recommendedNetwork.BSSID = "any"; - - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createConnectRecommendation(recommendedNetwork)); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail), - null, null, false, false /* untrustedNetworkAllowed */, null); - - assertEquals(mTrustedWifiConfiguration, result); - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - assertEquals(1, mRecommendationRequestCaptor.getValue().getScanResults().length); - assertEquals(mTrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[0]); - verify(mWifiConfigManager).setNetworkCandidateScanResult( - mTrustedWifiConfiguration.networkId, mTrustedScanDetail.getScanResult(), 0); - } - - @Test - public void testEvaluateNetworks_untrustedRecommendation_untrustedNetworksAllowed() { - NetworkUpdateResult networkUpdateResult = new NetworkUpdateResult(10); - when(mWifiConfigManager.addOrUpdateNetwork(mUntrustedWifiConfiguration, Process.WIFI_UID)) - .thenReturn(networkUpdateResult); - when(mWifiConfigManager.getConfiguredNetwork(networkUpdateResult.getNetworkId())) - .thenReturn(mUntrustedWifiConfiguration); - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult - .createConnectRecommendation(mUntrustedWifiConfiguration)); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - assertEquals(mUntrustedWifiConfiguration, result); - assertNull(result.BSSID); - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - assertEquals(2, mRecommendationRequestCaptor.getValue().getScanResults().length); - assertEquals(mTrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[0]); - assertEquals(mUntrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[1]); - verify(mWifiConfigManager).setNetworkCandidateScanResult( - networkUpdateResult.getNetworkId(), mUntrustedScanDetail.getScanResult(), 0); - verify(mWifiConfigManager, never()).updateNetworkSelectionStatus(anyInt(), anyInt()); - } - - @Test - public void testEvaluateNetworks_untrustedRecommendation_updateFailed() { - NetworkUpdateResult networkUpdateResult = new NetworkUpdateResult( - WifiConfiguration.INVALID_NETWORK_ID); - when(mWifiConfigManager.addOrUpdateNetwork(mUntrustedWifiConfiguration, Process.WIFI_UID)) - .thenReturn(networkUpdateResult); - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult - .createConnectRecommendation(mUntrustedWifiConfiguration)); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - assertNull(result); - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - assertEquals(2, mRecommendationRequestCaptor.getValue().getScanResults().length); - assertEquals(mTrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[0]); - assertEquals(mUntrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[1]); - verify(mWifiConfigManager, never()) - .setNetworkCandidateScanResult(anyInt(), any(ScanResult.class), anyInt()); - } - - @Test - public void testEvaluateNetworks_doNotConnectRecommendation_untrustedNetworksAllowed() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createDoNotConnectRecommendation()); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - assertNull(result); - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - assertEquals(2, mRecommendationRequestCaptor.getValue().getScanResults().length); - assertEquals(mTrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[0]); - assertEquals(mUntrustedScanDetail.getScanResult(), - mRecommendationRequestCaptor.getValue().getScanResults()[1]); - verify(mWifiConfigManager) - .updateNetworkNotRecommended(mTrustedWifiConfiguration.networkId, true); - } - - @Test - public void testEvaluateNetworks_nullRecommendation() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(null); - - WifiConfiguration result = mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail), - null, null, false, false /* untrustedNetworkAllowed */, null); - - assertNull(result); - verify(mNetworkScoreManager).requestRecommendation(any(RecommendationRequest.class)); - verify(mWifiConfigManager, never()).updateNetworkSelectionStatus(anyInt(), anyInt()); - } - - @Test - public void testEvaluateNetworks_requestContainsCurrentNetwork() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createDoNotConnectRecommendation()); - - mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail), - mTrustedWifiConfiguration, null, false, true /* untrustedNetworkAllowed */, null); - - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - assertSame(mTrustedWifiConfiguration, - mRecommendationRequestCaptor.getValue().getConnectedConfig()); - verify(mWifiConfigManager) - .updateNetworkNotRecommended(mTrustedWifiConfiguration.networkId, true); - } - - @Test - public void testEvaluateNetworks_requestConnectableNetworks() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createDoNotConnectRecommendation()); - - mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mUntrustedScanDetail, - mEphemeralScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - RecommendationRequest request = mRecommendationRequestCaptor.getValue(); - assertEquals(2, request.getConnectableConfigs().length); - Set<String> ssids = new ArraySet<>(); - for (WifiConfiguration config : request.getConnectableConfigs()) { - ssids.add(config.SSID); - } - Set<String> expectedSsids = new ArraySet<>(); - expectedSsids.add(mTrustedWifiConfiguration.SSID); - expectedSsids.add(mEphemeralWifiConfiguration.SSID); - assertEquals(expectedSsids, ssids); - } - - @Test - public void testEvaluateNetworks_requestConnectableNetworks_filterDisabledNetworks() { - WifiConfiguration disabledWifiConfiguration = mTrustedWifiConfiguration; - disabledWifiConfiguration.getNetworkSelectionStatus().setNetworkSelectionStatus( - NetworkSelectionStatus.NETWORK_SELECTION_TEMPORARY_DISABLED); - when(mWifiConfigManager.getSavedNetworkForScanDetailAndCache(mTrustedScanDetail)) - .thenReturn(disabledWifiConfiguration); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createDoNotConnectRecommendation()); - - mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mEphemeralScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - RecommendationRequest request = mRecommendationRequestCaptor.getValue(); - assertEquals(1, request.getConnectableConfigs().length); - assertEquals(mEphemeralWifiConfiguration, request.getConnectableConfigs()[0]); - } - - @Test - public void testEvaluateNetworks_scanResultMarkedAsUntrusted_configIsEphemeral() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createDoNotConnectRecommendation()); - - mRecommendedNetworkEvaluator.evaluateNetworks(Lists.newArrayList(mEphemeralScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - RecommendationRequest request = mRecommendationRequestCaptor.getValue(); - assertEquals(1, request.getScanResults().length); - assertTrue(request.getScanResults()[0].untrusted); - } - - @Test - public void testEvaluateNetworks_potentialConnectableNetworksPopulated() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createDoNotConnectRecommendation()); - - List<Pair<ScanDetail, WifiConfiguration>> potentialConnectableNetworks = new ArrayList<>(); - mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mEphemeralScanDetail, - mUntrustedScanDetail), null, null, false, - true /* untrustedNetworkAllowed */, potentialConnectableNetworks); - - assertEquals(3, potentialConnectableNetworks.size()); - Pair<ScanDetail, WifiConfiguration> expectedTrustedPair = - Pair.create(mTrustedScanDetail, mTrustedWifiConfiguration); - Pair<ScanDetail, WifiConfiguration> expectedUntrustedPair = - Pair.create(mUntrustedScanDetail, null); - Pair<ScanDetail, WifiConfiguration> expectedEphemPair = - Pair.create(mEphemeralScanDetail, mEphemeralWifiConfiguration); - assertTrue(potentialConnectableNetworks.contains(expectedTrustedPair)); - assertTrue(potentialConnectableNetworks.contains(expectedUntrustedPair)); - assertTrue(potentialConnectableNetworks.contains(expectedEphemPair)); - } - - @Test - public void testEvaluateNetworks_potentialConnectableNetworksIsNull() { - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mNetworkScoreManager.requestRecommendation(any(RecommendationRequest.class))) - .thenReturn(RecommendationResult.createDoNotConnectRecommendation()); - - mRecommendedNetworkEvaluator.evaluateNetworks( - Lists.newArrayList(mTrustedScanDetail, mEphemeralScanDetail, - mUntrustedScanDetail), - null, null, false, true /* untrustedNetworkAllowed */, null); - - // should not throw a NPE. - } - - @Test - public void testEvaluateNetworks_requestContainsLastSelectedNetwork() { - int lastSelectedNetworkId = 5; - long lastSelectedTimestamp = 1000; - when(mWifiConfigManager.wasEphemeralNetworkDeleted(anyString())).thenReturn(false); - when(mWifiConfigManager.getLastSelectedNetwork()).thenReturn(lastSelectedNetworkId); - when(mWifiConfigManager.getLastSelectedTimeStamp()).thenReturn(lastSelectedTimestamp); - - mRecommendedNetworkEvaluator.evaluateNetworks(Lists.newArrayList(mTrustedScanDetail), - null, null, false, false /* untrustedNetworkAllowed */, null); - - verify(mNetworkScoreManager).requestRecommendation(mRecommendationRequestCaptor.capture()); - RecommendationRequest request = mRecommendationRequestCaptor.getValue(); - assertEquals(lastSelectedNetworkId, request.getLastSelectedNetworkId()); - assertEquals(lastSelectedTimestamp, request.getLastSelectedNetworkTimestamp()); - } - - private static ScanDetail buildScanDetail(String ssid) { - return new ScanDetail(WifiSsid.createFromAsciiEncoded(ssid), - "00:00:00:00:00:00", "", 0, 0, 0, 0); - } -} diff --git a/tests/wifitests/src/com/android/server/wifi/ScoredNetworkEvaluatorTest.java b/tests/wifitests/src/com/android/server/wifi/ScoredNetworkEvaluatorTest.java new file mode 100644 index 000000000..55b00c9b5 --- /dev/null +++ b/tests/wifitests/src/com/android/server/wifi/ScoredNetworkEvaluatorTest.java @@ -0,0 +1,577 @@ +/* + * 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.content.Context; +import android.database.ContentObserver; +import android.net.NetworkKey; +import android.net.NetworkScoreManager; +import android.net.Uri; +import android.net.wifi.ScanResult; +import android.net.wifi.WifiConfiguration; +import android.net.wifi.WifiNetworkScoreCache; +import android.os.Looper; +import android.os.SystemClock; +import android.provider.Settings; +import android.test.suitebuilder.annotation.SmallTest; +import android.util.LocalLog; + +import com.android.server.wifi.WifiNetworkSelectorTestUtil.ScanDetailsAndWifiConfigs; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.ArrayList; +import java.util.List; + +/** + * Unit tests for {@link ScoredNetworkEvaluator}. + */ +@SmallTest +public class ScoredNetworkEvaluatorTest { + private ContentObserver mContentObserver; + private int mThresholdQualifiedRssi2G; + private int mThresholdQualifiedRssi5G; + + @Mock private Context mContext; + @Mock private Clock mClock; + @Mock private FrameworkFacade mFrameworkFacade; + @Mock private NetworkScoreManager mNetworkScoreManager; + @Mock private WifiConfigManager mWifiConfigManager; + + @Captor private ArgumentCaptor<NetworkKey[]> mNetworkKeyArrayCaptor; + + private WifiNetworkScoreCache mScoreCache; + private ScoredNetworkEvaluator mScoredNetworkEvaluator; + + @Before + public void setUp() throws Exception { + mThresholdQualifiedRssi2G = -73; + mThresholdQualifiedRssi5G = -70; + + MockitoAnnotations.initMocks(this); + + when(mFrameworkFacade.getIntegerSetting(mContext, + Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0)) + .thenReturn(1); + + ArgumentCaptor<ContentObserver> observerCaptor = + ArgumentCaptor.forClass(ContentObserver.class); + mScoreCache = new WifiNetworkScoreCache(mContext); + mScoredNetworkEvaluator = new ScoredNetworkEvaluator(mContext, + Looper.getMainLooper(), mFrameworkFacade, mNetworkScoreManager, + mWifiConfigManager, new LocalLog(0), mScoreCache); + verify(mFrameworkFacade).registerContentObserver(eq(mContext), any(Uri.class), eq(false), + observerCaptor.capture()); + mContentObserver = observerCaptor.getValue(); + + reset(mNetworkScoreManager); + + when(mClock.getElapsedSinceBootMillis()).thenReturn(SystemClock.elapsedRealtime()); + } + + @After + public void tearDown() { + validateMockitoUsage(); + } + + @Test + public void testUpdate_recommendationsDisabled() { + String[] ssids = {"\"test1\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3"}; + int[] freqs = {2470}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]"}; + int[] levels = {mThresholdQualifiedRssi2G + 8}; + int[] securities = {SECURITY_PSK}; + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = WifiNetworkSelectorTestUtil + .setupScanDetailsAndConfigStore( + ssids, bssids, freqs, caps, levels, securities, mWifiConfigManager, mClock); + + when(mFrameworkFacade.getIntegerSetting(mContext, + Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0)) + .thenReturn(0); + + mContentObserver.onChange(false /* unused */); + + mScoredNetworkEvaluator.update(scanDetailsAndConfigs.getScanDetails()); + + verifyZeroInteractions(mNetworkScoreManager); + } + + @Test + public void testUpdate_emptyScanList() { + String[] ssids = {"\"test1\""}; + String[] bssids = {"6c:f3:7f:ae:8c:f3"}; + int[] freqs = {2470}; + String[] caps = {"[WPA2-EAP-CCMP][ESS]"}; + int[] levels = {mThresholdQualifiedRssi2G + 8}; + int[] securities = {SECURITY_PSK}; + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = WifiNetworkSelectorTestUtil + .setupScanDetailsAndConfigStore( + ssids, bssids, freqs, caps, levels, securities, mWifiConfigManager, mClock); + + mScoredNetworkEvaluator.update(new ArrayList<ScanDetail>()); + + verifyZeroInteractions(mNetworkScoreManager); + } + + @Test + public void testUpdate_allNetworksUnscored() { + 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 + 10}; + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = WifiNetworkSelectorTestUtil + .setupScanDetailsAndConfigStore( + ssids, bssids, freqs, caps, levels, securities, mWifiConfigManager, mClock); + + mScoredNetworkEvaluator.update(scanDetailsAndConfigs.getScanDetails()); + + verify(mNetworkScoreManager).requestScores(mNetworkKeyArrayCaptor.capture()); + assertEquals(2, mNetworkKeyArrayCaptor.getValue().length); + NetworkKey expectedNetworkKey = NetworkKey.createFromScanResult( + scanDetailsAndConfigs.getScanDetails().get(0).getScanResult()); + assertEquals(expectedNetworkKey, mNetworkKeyArrayCaptor.getValue()[0]); + expectedNetworkKey = NetworkKey.createFromScanResult( + scanDetailsAndConfigs.getScanDetails().get(1).getScanResult()); + assertEquals(expectedNetworkKey, mNetworkKeyArrayCaptor.getValue()[1]); + } + + @Test + public void testUpdate_oneScored_oneUnscored() { + 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 + 10}; + + ScanDetailsAndWifiConfigs scanDetailsAndConfigs = WifiNetworkSelectorTestUtil + .setupScanDetailsAndConfigStore( + ssids, bssids, freqs, caps, levels, securities, mWifiConfigManager, mClock); + + List<ScanDetail> scoredScanDetails = scanDetailsAndConfigs.getScanDetails().subList(0, 1); + Integer[] scores = {120}; + boolean[] meteredHints = {true}; + WifiNetworkSelectorTestUtil.configureScoreCache( + mScoreCache, scoredScanDetails, scores, meteredHints); + + mScoredNetworkEvaluator.update(scanDetailsAndConfigs.getScanDetails()); + + verify(mNetworkScoreManager).requestScores(mNetworkKeyArrayCaptor.capture()); + + NetworkKey[] requestedScores = mNetworkKeyArrayCaptor.getValue(); + assertEquals(1, requestedScores.length); + NetworkKey expectedNetworkKey = NetworkKey.createFromScanResult( + scanDetailsAndConfigs.getScanDetails().get(1).getScanResult()); + assertEquals(expectedNetworkKey, requestedScores[0]); + } + + @Test + public void testEvaluateNetworks_recommendationsDisabled() { + when(mFrameworkFacade.getIntegerSetting(mContext, + Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0)) + .thenReturn(0); + + mContentObserver.onChange(false /* unused */); + + mScoredNetworkEvaluator.evaluateNetworks(null, null, null, false, false, null); + + verifyZeroInteractions(mWifiConfigManager, mNetworkScoreManager); + } + + /** + * When no saved networks available, choose the available ephemeral networks + * if untrusted networks are allowed. + */ + @Test + public void testEvaluateNetworks_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, scanDetails.get(1), meteredHints[1]); + + // Untrusted networks allowed. + WifiConfiguration candidate = mScoredNetworkEvaluator.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 testEvaluateNetworks_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, scanDetails.get(i), meteredHints[i]); + } + + WifiConfiguration candidate = mScoredNetworkEvaluator.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 testEvaluateNetworks_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); + + WifiNetworkSelectorTestUtil.setupEphemeralNetwork( + mWifiConfigManager, 1, scanDetails.get(1), meteredHints[1]); + + // Untrusted networks not allowed. + WifiConfiguration candidate = mScoredNetworkEvaluator.evaluateNetworks(scanDetails, + null, null, false, false, null); + + assertEquals("Expect null configuration", null, candidate); + } + + /** + * Choose externally scored saved network. + */ + @Test + public void testEvaluateNetworks_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}; + + WifiNetworkSelectorTestUtil.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 = mScoredNetworkEvaluator.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 testEvaluateNetworks_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}; + + WifiNetworkSelectorTestUtil.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 = mScoredNetworkEvaluator.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 testEvaluateNetworks_chooseExternallyScoredOverUntrustedNetworksWithSameScore() { + 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}; + + WifiNetworkSelectorTestUtil.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 = mScoredNetworkEvaluator.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 testEvaluateNetworks_chooseUntrustedWithHigherScoreThanExternallyScoredNetwork() { + // 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. + WifiNetworkSelectorTestUtil.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, scanDetails.get(1), + meteredHints[1]); + + // Set up score cache for both the saved network and the ephemeral network. + WifiNetworkSelectorTestUtil.configureScoreCache(mScoreCache, + scanDetails, scores, meteredHints); + + WifiConfiguration candidate = mScoredNetworkEvaluator.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 testEvaluateNetworks_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}; + + WifiNetworkSelectorTestUtil.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 = mScoredNetworkEvaluator.evaluateNetworks(scanDetails, + null, null, false, true, null); + + assertEquals("Expect null configuration", null, candidate); + } + + /** + * Between two ephemeral networks with the same RSSI, choose + * the currently connected one. + */ + @Test + public void testEvaluateNetworks_chooseActiveEphemeralNetwork() { + 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 + 28, mThresholdQualifiedRssi2G + 28}; + 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, null, 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, scanDetails.get(i), meteredHints[i]); + } + + WifiConfiguration candidate = mScoredNetworkEvaluator.evaluateNetworks( + scanDetails, ephemeralNetworkConfigs[1], + bssids[1], true, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(ephemeralNetworkConfigs[1], candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + scanResults[1], candidate); + assertEquals(meteredHints[1], candidate.meteredHint); + } + + /** + * Between two externally scored saved networks with the same RSSI, choose + * the currently connected one. + */ + @Test + public void testEvaluateNetworks_chooseActiveSavedNetwork() { + 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 + 28, mThresholdQualifiedRssi2G + 28}; + boolean[] meteredHints = {false, false}; + + WifiNetworkSelectorTestUtil.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, null, meteredHints); + + WifiConfiguration candidate = mScoredNetworkEvaluator.evaluateNetworks(scanDetails, + savedConfigs[1], bssids[1], true, true, null); + + WifiConfigurationTestUtil.assertConfigurationEqual(savedConfigs[1], candidate); + WifiNetworkSelectorTestUtil.verifySelectedScanResult(mWifiConfigManager, + scanDetails.get(1).getScanResult(), candidate); + } +} diff --git a/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java b/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java index 1e255c86c..9c78c9b12 100644 --- a/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java +++ b/tests/wifitests/src/com/android/server/wifi/WifiNetworkSelectorTestUtil.java @@ -177,7 +177,7 @@ public class WifiNetworkSelectorTestUtil { * @param wifiConfigManager the mocked WifiConfigManager * @param configs input configuration need to be added to WifiConfigureStore */ - private static void prepareConfigStore(WifiConfigManager wifiConfigManager, + private static void prepareConfigStore(final WifiConfigManager wifiConfigManager, final WifiConfiguration[] configs) { when(wifiConfigManager.getConfiguredNetwork(anyInt())) .then(new AnswerWithArguments() { @@ -356,18 +356,22 @@ public class WifiNetworkSelectorTestUtil { * * @param wifiConfigManager WifiConfigManager mock * @param networkId ID of the ephemeral network - * @param scanResult scanResult of the ephemeral network + * @param scanDetail scanDetail 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) { + int networkId, ScanDetail scanDetail, 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); + final WifiConfiguration config = + ScanResultUtil.createNetworkFromScanResult(scanDetail.getScanResult()); + config.ephemeral = true; config.networkId = networkId; config.meteredHint = meteredHint; + when(wifiConfigManager.getSavedNetworkForScanDetailAndCache(eq(scanDetail))) + .thenReturn(new WifiConfiguration(config)); when(wifiConfigManager.getConfiguredNetwork(eq(networkId))) .then(new AnswerWithArguments() { public WifiConfiguration answer(int netId) { @@ -385,6 +389,15 @@ public class WifiNetworkSelectorTestUtil { return true; } }); + when(wifiConfigManager.updateNetworkSelectionStatus(eq(networkId), + eq(WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLE))) + .then(new AnswerWithArguments() { + public boolean answer(int netId, int status) { + config.getNetworkSelectionStatus().setNetworkSelectionStatus( + WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLE); + return true; + } + }); return config; } } |