1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.android.settingslib.wifi;
17 
18 import static com.google.common.truth.Truth.assertThat;
19 
20 import static org.mockito.ArgumentMatchers.anyInt;
21 import static org.mockito.Mockito.any;
22 import static org.mockito.Mockito.doReturn;
23 import static org.mockito.Mockito.spy;
24 import static org.mockito.Mockito.verify;
25 import static org.mockito.Mockito.when;
26 
27 import android.content.Context;
28 import android.content.Intent;
29 import android.net.NetworkKey;
30 import android.net.RssiCurve;
31 import android.net.ScoredNetwork;
32 import android.net.WifiKey;
33 import android.net.wifi.ScanResult;
34 import android.net.wifi.WifiConfiguration;
35 import android.net.wifi.WifiNetworkScoreCache;
36 import android.os.Bundle;
37 import android.os.Parcelable;
38 import android.os.SystemClock;
39 import android.text.format.DateUtils;
40 import android.util.ArraySet;
41 
42 import androidx.test.core.app.ApplicationProvider;
43 
44 import com.android.settingslib.R;
45 
46 import org.junit.Before;
47 import org.junit.Test;
48 import org.junit.runner.RunWith;
49 import org.mockito.Mock;
50 import org.mockito.MockitoAnnotations;
51 import org.robolectric.RobolectricTestRunner;
52 
53 import java.util.ArrayList;
54 import java.util.Set;
55 
56 @RunWith(RobolectricTestRunner.class)
57 public class WifiUtilsTest {
58     private static final String TEST_SSID = "\"test_ssid\"";
59     private static final String TEST_BSSID = "00:00:00:00:00:00";
60     private static final long MAX_SCORE_CACHE_AGE_MILLIS =
61             20 * DateUtils.MINUTE_IN_MILLIS;
62 
63     private Context mContext;
64     @Mock
65     private RssiCurve mockBadgeCurve;
66     @Mock
67     private WifiNetworkScoreCache mockWifiNetworkScoreCache;
68     @Mock
69     private AccessPoint mAccessPoint;
70     @Mock
71     WifiConfiguration mWifiConfig;
72 
73     @Before
setUp()74     public void setUp() {
75         MockitoAnnotations.initMocks(this);
76         mContext = spy(ApplicationProvider.getApplicationContext());
77     }
78 
79     @Test
testVerboseSummaryString_showsScanResultSpeedLabel()80     public void testVerboseSummaryString_showsScanResultSpeedLabel() {
81         WifiTracker.sVerboseLogging = true;
82 
83         Bundle bundle = new Bundle();
84         ArrayList<ScanResult> scanResults = buildScanResultCache();
85         bundle.putParcelableArray(AccessPoint.KEY_SCANRESULTS,
86                                   scanResults.toArray(new Parcelable[0]));
87         AccessPoint ap = new AccessPoint(mContext, bundle);
88 
89         when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class)))
90                 .thenReturn(buildScoredNetworkWithGivenBadgeCurve(mockBadgeCurve));
91         when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.VERY_FAST);
92 
93         ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */,
94                 MAX_SCORE_CACHE_AGE_MILLIS);
95         String summary = WifiUtils.verboseScanResultSummary(ap, scanResults.get(0), null, 0);
96 
97         assertThat(summary.contains(mContext.getString(R.string.speed_label_very_fast))).isTrue();
98     }
99 
100     @Test
testGetVisibilityStatus_nullResultDoesNotCrash()101     public void testGetVisibilityStatus_nullResultDoesNotCrash() {
102         doReturn(null).when(mAccessPoint).getInfo();
103         Set<ScanResult> set = new ArraySet<>();
104         set.add(null);
105         doReturn(set).when(mAccessPoint).getScanResults();
106         WifiUtils.getVisibilityStatus(mAccessPoint);
107     }
108 
109     @Test
testGetMeteredLabel_returnsCorrectValues()110     public void testGetMeteredLabel_returnsCorrectValues() {
111         mWifiConfig.meteredHint = true;
112         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NONE;
113         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Metered");
114 
115         mWifiConfig.meteredHint = false;
116         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
117         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Metered");
118 
119         mWifiConfig.meteredHint = true;
120         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
121         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Metered");
122 
123         mWifiConfig.meteredHint = false;
124         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
125         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Unmetered");
126 
127         mWifiConfig.meteredHint = true;
128         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
129         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Unmetered");
130     }
131 
132     @Test
testIsMeteredOverridden_returnsCorrectValues()133     public void testIsMeteredOverridden_returnsCorrectValues() {
134         mWifiConfig.meteredHint = true;
135         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NONE;
136         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isFalse();
137 
138         mWifiConfig.meteredHint = false;
139         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
140         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
141 
142         mWifiConfig.meteredHint = true;
143         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
144         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
145 
146         mWifiConfig.meteredHint = false;
147         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
148         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
149 
150         mWifiConfig.meteredHint = true;
151         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
152         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
153     }
154 
155     @Test
getWifiDetailsSettingsIntent_returnsCorrectValues()156     public void getWifiDetailsSettingsIntent_returnsCorrectValues() {
157         final String key = "test_key";
158 
159         final Intent intent = WifiUtils.getWifiDetailsSettingsIntent(key);
160 
161         assertThat(intent.getAction()).isEqualTo(WifiUtils.ACTION_WIFI_DETAILS_SETTINGS);
162         final Bundle bundle = intent.getBundleExtra(WifiUtils.EXTRA_SHOW_FRAGMENT_ARGUMENTS);
163         assertThat(bundle.getString(WifiUtils.KEY_CHOSEN_WIFIENTRY_KEY)).isEqualTo(key);
164     }
165 
166     @Test
testInternetIconInjector_getIcon_returnsCorrectValues()167     public void testInternetIconInjector_getIcon_returnsCorrectValues() {
168         WifiUtils.InternetIconInjector iconInjector = new WifiUtils.InternetIconInjector(mContext);
169 
170         for (int level = 0; level <= 4; level++) {
171             iconInjector.getIcon(false /* noInternet */, level);
172             verify(mContext).getDrawable(
173                     WifiUtils.getInternetIconResource(level, false /* noInternet */));
174 
175             iconInjector.getIcon(true /* noInternet */, level);
176             verify(mContext).getDrawable(
177                     WifiUtils.getInternetIconResource(level, true /* noInternet */));
178         }
179     }
180 
buildScanResultCache()181     private static ArrayList<ScanResult> buildScanResultCache() {
182         ArrayList<ScanResult> scanResults = new ArrayList<>();
183         for (int i = 0; i < 5; i++) {
184             ScanResult scanResult = createScanResult(TEST_SSID, "bssid-" + i, i);
185             scanResults.add(scanResult);
186         }
187         return scanResults;
188     }
189 
createScanResult(String ssid, String bssid, int rssi)190     private static ScanResult createScanResult(String ssid, String bssid, int rssi) {
191         ScanResult scanResult = new ScanResult();
192         scanResult.SSID = ssid;
193         scanResult.level = rssi;
194         scanResult.BSSID = bssid;
195         scanResult.timestamp = SystemClock.elapsedRealtime() * 1000;
196         scanResult.capabilities = "";
197         return scanResult;
198     }
199 
buildScoredNetworkWithGivenBadgeCurve(RssiCurve badgeCurve)200     private ScoredNetwork buildScoredNetworkWithGivenBadgeCurve(RssiCurve badgeCurve) {
201         Bundle attr1 = new Bundle();
202         attr1.putParcelable(ScoredNetwork.ATTRIBUTES_KEY_BADGING_CURVE, badgeCurve);
203         return new ScoredNetwork(
204                 new NetworkKey(new WifiKey(TEST_SSID, TEST_BSSID)),
205                 badgeCurve,
206                 false /* meteredHint */,
207                 attr1);
208     }
209 }
210