Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 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 | |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 18 | import static com.google.common.truth.Truth.assertThat; |
| 19 | import static com.google.common.truth.Truth.assertWithMessage; |
Sundeep Ghuman | 71f4a82 | 2017-04-18 19:51:46 -0700 | [diff] [blame] | 20 | |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 21 | import static org.junit.Assert.fail; |
Roshan Pius | e9b8e50 | 2019-01-23 15:42:44 -0800 | [diff] [blame] | 22 | import static org.mockito.ArgumentMatchers.eq; |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 23 | import static org.mockito.Mockito.any; |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 24 | import static org.mockito.Mockito.anyInt; |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 25 | import static org.mockito.Mockito.mock; |
Quang Luong | 1f1207b | 2019-02-19 17:35:50 -0800 | [diff] [blame] | 26 | import static org.mockito.Mockito.spy; |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 27 | import static org.mockito.Mockito.verify; |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 28 | import static org.mockito.Mockito.when; |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 29 | |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 30 | import android.content.Context; |
Roshan Pius | e9b8e50 | 2019-01-23 15:42:44 -0800 | [diff] [blame] | 31 | import android.content.pm.ApplicationInfo; |
| 32 | import android.content.pm.PackageManager; |
| 33 | import android.content.res.Resources; |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 34 | import android.net.ConnectivityManager; |
| 35 | import android.net.NetworkInfo; |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 36 | import android.net.NetworkKey; |
| 37 | import android.net.RssiCurve; |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 38 | import android.net.ScoredNetwork; |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 39 | import android.net.WifiKey; |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 40 | import android.net.wifi.ScanResult; |
| 41 | import android.net.wifi.WifiConfiguration; |
Peter Qiu | 280581b | 2017-07-24 14:18:56 -0700 | [diff] [blame] | 42 | import android.net.wifi.WifiEnterpriseConfig; |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 43 | import android.net.wifi.WifiInfo; |
Quang Luong | 7cfa527 | 2019-03-08 12:37:15 -0800 | [diff] [blame] | 44 | import android.net.wifi.WifiManager; |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 45 | import android.net.wifi.WifiNetworkScoreCache; |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 46 | import android.net.wifi.WifiSsid; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 47 | import android.net.wifi.hotspot2.OsuProvider; |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 48 | import android.net.wifi.hotspot2.PasspointConfiguration; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 49 | import android.net.wifi.hotspot2.ProvisioningCallback; |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 50 | import android.net.wifi.hotspot2.pps.HomeSp; |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 51 | import android.os.Bundle; |
Sundeep Ghuman | 04f7f34 | 2018-01-23 19:18:31 -0800 | [diff] [blame] | 52 | import android.os.Parcelable; |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 53 | import android.os.SystemClock; |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 54 | import android.text.SpannableString; |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 55 | import android.text.format.DateUtils; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 56 | import android.util.ArraySet; |
Quang Luong | 7cfa527 | 2019-03-08 12:37:15 -0800 | [diff] [blame] | 57 | import android.util.Pair; |
KOUSHIK PANUGANTI | 63bf06e | 2018-12-18 14:26:21 -0800 | [diff] [blame] | 58 | |
| 59 | import androidx.test.InstrumentationRegistry; |
| 60 | import androidx.test.filters.SmallTest; |
| 61 | import androidx.test.runner.AndroidJUnit4; |
Sundeep Ghuman | 71f4a82 | 2017-04-18 19:51:46 -0700 | [diff] [blame] | 62 | |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 63 | import com.android.settingslib.R; |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 64 | import com.android.settingslib.utils.ThreadUtils; |
Eric Schwarzenbach | f4f3842b | 2017-07-17 16:45:04 -0700 | [diff] [blame] | 65 | import com.android.settingslib.wifi.AccessPoint.Speed; |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 66 | |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 67 | import org.junit.Before; |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 68 | import org.junit.Test; |
| 69 | import org.junit.runner.RunWith; |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 70 | import org.mockito.Mock; |
| 71 | import org.mockito.MockitoAnnotations; |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 72 | |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 73 | import java.util.ArrayList; |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 74 | import java.util.Arrays; |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 75 | import java.util.Collections; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 76 | import java.util.HashMap; |
Quang Luong | 7cfa527 | 2019-03-08 12:37:15 -0800 | [diff] [blame] | 77 | import java.util.List; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 78 | import java.util.Map; |
| 79 | import java.util.Set; |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 80 | import java.util.concurrent.CountDownLatch; |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 81 | |
| 82 | @SmallTest |
| 83 | @RunWith(AndroidJUnit4.class) |
| 84 | public class AccessPointTest { |
| 85 | |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 86 | private static final String TEST_SSID = "\"test_ssid\""; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 87 | private static final String ROAMING_SSID = "\"roaming_ssid\""; |
| 88 | private static final String OSU_FRIENDLY_NAME = "osu_friendly_name"; |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 89 | |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 90 | private ArrayList<ScanResult> mScanResults; |
| 91 | private ArrayList<ScanResult> mRoamingScans; |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 92 | |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 93 | private static final RssiCurve FAST_BADGE_CURVE = |
| 94 | new RssiCurve(-150, 10, new byte[]{Speed.FAST}); |
| 95 | public static final String TEST_BSSID = "00:00:00:00:00:00"; |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 96 | private static final long MAX_SCORE_CACHE_AGE_MILLIS = |
| 97 | 20 * DateUtils.MINUTE_IN_MILLIS;; |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 98 | |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 99 | private Context mContext; |
Quang Luong | 1f1207b | 2019-02-19 17:35:50 -0800 | [diff] [blame] | 100 | private WifiInfo mWifiInfo; |
Quang Luong | 7cfa527 | 2019-03-08 12:37:15 -0800 | [diff] [blame] | 101 | @Mock private Context mMockContext; |
| 102 | @Mock private WifiManager mMockWifiManager; |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 103 | @Mock private RssiCurve mockBadgeCurve; |
| 104 | @Mock private WifiNetworkScoreCache mockWifiNetworkScoreCache; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 105 | @Mock private AccessPoint.AccessPointListener mMockAccessPointListener; |
Quang Luong | 7cfa527 | 2019-03-08 12:37:15 -0800 | [diff] [blame] | 106 | @Mock private WifiManager.ActionListener mMockConnectListener; |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 107 | private static final int NETWORK_ID = 123; |
| 108 | private static final int DEFAULT_RSSI = -55; |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 109 | |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 110 | private ScanResult createScanResult(String ssid, String bssid, int rssi) { |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 111 | ScanResult scanResult = new ScanResult(); |
| 112 | scanResult.SSID = ssid; |
| 113 | scanResult.level = rssi; |
| 114 | scanResult.BSSID = bssid; |
| 115 | scanResult.timestamp = SystemClock.elapsedRealtime() * 1000; |
| 116 | scanResult.capabilities = ""; |
| 117 | return scanResult; |
| 118 | } |
| 119 | |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 120 | private OsuProvider createOsuProvider() { |
| 121 | Map<String, String> friendlyNames = new HashMap<>(); |
| 122 | friendlyNames.put("en", OSU_FRIENDLY_NAME); |
| 123 | return new OsuProvider(null, friendlyNames, null, null, null, null, null); |
| 124 | } |
| 125 | |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 126 | @Before |
| 127 | public void setUp() { |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 128 | MockitoAnnotations.initMocks(this); |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 129 | mContext = InstrumentationRegistry.getTargetContext(); |
Quang Luong | 1f1207b | 2019-02-19 17:35:50 -0800 | [diff] [blame] | 130 | mWifiInfo = new WifiInfo(); |
| 131 | mWifiInfo.setSSID(WifiSsid.createFromAsciiEncoded(TEST_SSID)); |
| 132 | mWifiInfo.setBSSID(TEST_BSSID); |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 133 | mScanResults = buildScanResultCache(TEST_SSID); |
| 134 | mRoamingScans = buildScanResultCache(ROAMING_SSID); |
Eric Schwarzenbach | 0b8700f | 2017-07-25 14:32:21 -0700 | [diff] [blame] | 135 | WifiTracker.sVerboseLogging = false; |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 136 | } |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 137 | |
| 138 | @Test |
pastychang | a2998fc | 2018-06-26 13:37:34 +0800 | [diff] [blame] | 139 | public void testSsidIsSpannableString_returnFalse() { |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 140 | final Bundle bundle = new Bundle(); |
| 141 | bundle.putString("key_ssid", TEST_SSID); |
| 142 | final AccessPoint ap = new AccessPoint(InstrumentationRegistry.getTargetContext(), bundle); |
| 143 | final CharSequence ssid = ap.getSsid(); |
| 144 | |
pastychang | a2998fc | 2018-06-26 13:37:34 +0800 | [diff] [blame] | 145 | assertThat(ssid instanceof SpannableString).isFalse(); |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 146 | } |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 147 | |
| 148 | @Test |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 149 | public void testCompareTo_GivesActiveBeforeInactive() { |
| 150 | AccessPoint activeAp = new TestAccessPointBuilder(mContext).setActive(true).build(); |
| 151 | AccessPoint inactiveAp = new TestAccessPointBuilder(mContext).setActive(false).build(); |
| 152 | |
| 153 | assertSortingWorks(activeAp, inactiveAp); |
| 154 | } |
| 155 | |
| 156 | @Test |
| 157 | public void testCompareTo_GivesReachableBeforeUnreachable() { |
| 158 | AccessPoint nearAp = new TestAccessPointBuilder(mContext).setReachable(true).build(); |
| 159 | AccessPoint farAp = new TestAccessPointBuilder(mContext).setReachable(false).build(); |
| 160 | |
| 161 | assertSortingWorks(nearAp, farAp); |
| 162 | } |
| 163 | |
| 164 | @Test |
| 165 | public void testCompareTo_GivesSavedBeforeUnsaved() { |
| 166 | AccessPoint savedAp = new TestAccessPointBuilder(mContext).setSaved(true).build(); |
| 167 | AccessPoint notSavedAp = new TestAccessPointBuilder(mContext).setSaved(false).build(); |
| 168 | |
| 169 | assertSortingWorks(savedAp, notSavedAp); |
| 170 | } |
| 171 | |
Eric Schwarzenbach | f4f3842b | 2017-07-17 16:45:04 -0700 | [diff] [blame] | 172 | @Test |
| 173 | public void testCompareTo_GivesHighSpeedBeforeLowSpeed() { |
| 174 | AccessPoint fastAp = new TestAccessPointBuilder(mContext).setSpeed(Speed.FAST).build(); |
| 175 | AccessPoint slowAp = new TestAccessPointBuilder(mContext).setSpeed(Speed.SLOW).build(); |
| 176 | |
| 177 | assertSortingWorks(fastAp, slowAp); |
| 178 | } |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 179 | |
| 180 | @Test |
| 181 | public void testCompareTo_GivesHighLevelBeforeLowLevel() { |
| 182 | final int highLevel = AccessPoint.SIGNAL_LEVELS - 1; |
| 183 | final int lowLevel = 1; |
| 184 | assertThat(highLevel).isGreaterThan(lowLevel); |
| 185 | |
| 186 | AccessPoint strongAp = new TestAccessPointBuilder(mContext).setLevel(highLevel).build(); |
| 187 | AccessPoint weakAp = new TestAccessPointBuilder(mContext).setLevel(lowLevel).build(); |
| 188 | |
| 189 | assertSortingWorks(strongAp, weakAp); |
| 190 | } |
| 191 | |
| 192 | @Test |
| 193 | public void testCompareTo_GivesSsidAlphabetically() { |
| 194 | |
| 195 | final String firstName = "AAAAAA"; |
| 196 | final String secondName = "zzzzzz"; |
| 197 | |
| 198 | AccessPoint firstAp = new TestAccessPointBuilder(mContext).setSsid(firstName).build(); |
| 199 | AccessPoint secondAp = new TestAccessPointBuilder(mContext).setSsid(secondName).build(); |
| 200 | |
| 201 | assertThat(firstAp.getSsidStr().compareToIgnoreCase(secondAp.getSsidStr()) < 0).isTrue(); |
| 202 | assertSortingWorks(firstAp, secondAp); |
| 203 | } |
| 204 | |
| 205 | @Test |
Sundeep Ghuman | d44b8e4 | 2017-06-21 21:40:06 -0700 | [diff] [blame] | 206 | public void testCompareTo_GivesSsidCasePrecendenceAfterAlphabetical() { |
| 207 | |
| 208 | final String firstName = "aaAaaa"; |
| 209 | final String secondName = "aaaaaa"; |
| 210 | final String thirdName = "BBBBBB"; |
| 211 | |
| 212 | AccessPoint firstAp = new TestAccessPointBuilder(mContext).setSsid(firstName).build(); |
| 213 | AccessPoint secondAp = new TestAccessPointBuilder(mContext).setSsid(secondName).build(); |
| 214 | AccessPoint thirdAp = new TestAccessPointBuilder(mContext).setSsid(thirdName).build(); |
| 215 | |
| 216 | assertSortingWorks(firstAp, secondAp); |
| 217 | assertSortingWorks(secondAp, thirdAp); |
| 218 | } |
| 219 | |
| 220 | @Test |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 221 | public void testCompareTo_AllSortingRulesCombined() { |
| 222 | |
| 223 | AccessPoint active = new TestAccessPointBuilder(mContext).setActive(true).build(); |
| 224 | AccessPoint reachableAndMinLevel = new TestAccessPointBuilder(mContext) |
| 225 | .setReachable(true).build(); |
| 226 | AccessPoint saved = new TestAccessPointBuilder(mContext).setSaved(true).build(); |
| 227 | AccessPoint highLevelAndReachable = new TestAccessPointBuilder(mContext) |
| 228 | .setLevel(AccessPoint.SIGNAL_LEVELS - 1).build(); |
| 229 | AccessPoint firstName = new TestAccessPointBuilder(mContext).setSsid("a").build(); |
| 230 | AccessPoint lastname = new TestAccessPointBuilder(mContext).setSsid("z").build(); |
| 231 | |
| 232 | ArrayList<AccessPoint> points = new ArrayList<AccessPoint>(); |
| 233 | points.add(lastname); |
| 234 | points.add(firstName); |
| 235 | points.add(highLevelAndReachable); |
| 236 | points.add(saved); |
| 237 | points.add(reachableAndMinLevel); |
| 238 | points.add(active); |
| 239 | |
| 240 | Collections.sort(points); |
| 241 | assertThat(points.indexOf(active)).isLessThan(points.indexOf(reachableAndMinLevel)); |
| 242 | assertThat(points.indexOf(reachableAndMinLevel)).isLessThan(points.indexOf(saved)); |
| 243 | // note: the saved AP will not appear before highLevelAndReachable, |
| 244 | // because all APs with a signal level are reachable, |
| 245 | // and isReachable() takes higher sorting precedence than isSaved(). |
| 246 | assertThat(points.indexOf(saved)).isLessThan(points.indexOf(firstName)); |
| 247 | assertThat(points.indexOf(highLevelAndReachable)).isLessThan(points.indexOf(firstName)); |
| 248 | assertThat(points.indexOf(firstName)).isLessThan(points.indexOf(lastname)); |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 249 | } |
| 250 | |
Sundeep Ghuman | 54bdcfa | 2017-03-08 19:52:05 -0800 | [diff] [blame] | 251 | @Test |
| 252 | public void testRssiIsSetFromScanResults() { |
| 253 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 254 | int originalRssi = ap.getRssi(); |
| 255 | assertThat(originalRssi).isNotEqualTo(AccessPoint.UNREACHABLE_RSSI); |
| 256 | } |
| 257 | |
| 258 | @Test |
| 259 | public void testGetRssiShouldReturnSetRssiValue() { |
| 260 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 261 | int originalRssi = ap.getRssi(); |
| 262 | int newRssi = originalRssi - 10; |
| 263 | ap.setRssi(newRssi); |
| 264 | assertThat(ap.getRssi()).isEqualTo(newRssi); |
| 265 | } |
| 266 | |
Sundeep Ghuman | ce78a5f | 2017-03-15 19:06:14 -0700 | [diff] [blame] | 267 | @Test |
| 268 | public void testUpdateWithScanResultShouldAverageRssi() { |
| 269 | String ssid = "ssid"; |
| 270 | int originalRssi = -65; |
| 271 | int newRssi = -80; |
| 272 | int expectedRssi = (originalRssi + newRssi) / 2; |
| 273 | AccessPoint ap = |
| 274 | new TestAccessPointBuilder(mContext).setSsid(ssid).setRssi(originalRssi).build(); |
| 275 | |
| 276 | ScanResult scanResult = new ScanResult(); |
| 277 | scanResult.SSID = ssid; |
| 278 | scanResult.level = newRssi; |
| 279 | scanResult.BSSID = "bssid"; |
| 280 | scanResult.timestamp = SystemClock.elapsedRealtime() * 1000; |
| 281 | scanResult.capabilities = ""; |
Sundeep Ghuman | 04f7f34 | 2018-01-23 19:18:31 -0800 | [diff] [blame] | 282 | |
| 283 | ap.setScanResults(Collections.singletonList(scanResult)); |
Sundeep Ghuman | ce78a5f | 2017-03-15 19:06:14 -0700 | [diff] [blame] | 284 | |
| 285 | assertThat(ap.getRssi()).isEqualTo(expectedRssi); |
| 286 | } |
| 287 | |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 288 | @Test |
| 289 | public void testCreateFromPasspointConfig() { |
| 290 | PasspointConfiguration config = new PasspointConfiguration(); |
| 291 | HomeSp homeSp = new HomeSp(); |
| 292 | homeSp.setFqdn("test.com"); |
| 293 | homeSp.setFriendlyName("Test Provider"); |
| 294 | config.setHomeSp(homeSp); |
| 295 | AccessPoint ap = new AccessPoint(mContext, config); |
Stephen Chen | b5bcb8d | 2017-05-19 15:55:02 -0700 | [diff] [blame] | 296 | assertThat(ap.isPasspointConfig()).isTrue(); |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 297 | } |
| 298 | |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 299 | @Test |
| 300 | public void testIsMetered_returnTrueWhenWifiConfigurationIsMetered() { |
| 301 | WifiConfiguration configuration = createWifiConfiguration(); |
| 302 | configuration.meteredHint = true; |
| 303 | |
| 304 | NetworkInfo networkInfo = |
| 305 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 2, "WIFI", "WIFI_SUBTYPE"); |
| 306 | AccessPoint accessPoint = new AccessPoint(mContext, configuration); |
| 307 | WifiInfo wifiInfo = new WifiInfo(); |
| 308 | wifiInfo.setSSID(WifiSsid.createFromAsciiEncoded(configuration.SSID)); |
| 309 | wifiInfo.setBSSID(configuration.BSSID); |
| 310 | wifiInfo.setNetworkId(configuration.networkId); |
| 311 | accessPoint.update(configuration, wifiInfo, networkInfo); |
| 312 | |
Stephen Chen | b5bcb8d | 2017-05-19 15:55:02 -0700 | [diff] [blame] | 313 | assertThat(accessPoint.isMetered()).isTrue(); |
| 314 | } |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 315 | |
| 316 | @Test |
| 317 | public void testIsMetered_returnTrueWhenWifiInfoIsMetered() { |
| 318 | WifiConfiguration configuration = createWifiConfiguration(); |
| 319 | |
| 320 | NetworkInfo networkInfo = |
| 321 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 2, "WIFI", "WIFI_SUBTYPE"); |
| 322 | AccessPoint accessPoint = new AccessPoint(mContext, configuration); |
| 323 | WifiInfo wifiInfo = new WifiInfo(); |
| 324 | wifiInfo.setSSID(WifiSsid.createFromAsciiEncoded(configuration.SSID)); |
| 325 | wifiInfo.setBSSID(configuration.BSSID); |
| 326 | wifiInfo.setNetworkId(configuration.networkId); |
| 327 | wifiInfo.setMeteredHint(true); |
| 328 | accessPoint.update(configuration, wifiInfo, networkInfo); |
| 329 | |
Stephen Chen | b5bcb8d | 2017-05-19 15:55:02 -0700 | [diff] [blame] | 330 | assertThat(accessPoint.isMetered()).isTrue(); |
| 331 | } |
| 332 | |
| 333 | @Test |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 334 | public void testIsMetered_returnTrueWhenScoredNetworkIsMetered() { |
| 335 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 336 | |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 337 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 338 | .thenReturn( |
| 339 | new ScoredNetwork( |
| 340 | null /* NetworkKey */, |
| 341 | null /* rssiCurve */, |
| 342 | true /* metered */)); |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 343 | ap.update(mockWifiNetworkScoreCache, false /* scoringUiEnabled */, |
| 344 | MAX_SCORE_CACHE_AGE_MILLIS); |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 345 | |
Stephen Chen | b5bcb8d | 2017-05-19 15:55:02 -0700 | [diff] [blame] | 346 | assertThat(ap.isMetered()).isTrue(); |
| 347 | } |
| 348 | |
| 349 | @Test |
| 350 | public void testIsMetered_returnFalseByDefault() { |
| 351 | WifiConfiguration configuration = createWifiConfiguration(); |
| 352 | |
| 353 | NetworkInfo networkInfo = |
| 354 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 2, "WIFI", "WIFI_SUBTYPE"); |
| 355 | AccessPoint accessPoint = new AccessPoint(mContext, configuration); |
| 356 | WifiInfo wifiInfo = new WifiInfo(); |
| 357 | wifiInfo.setSSID(WifiSsid.createFromAsciiEncoded(configuration.SSID)); |
| 358 | wifiInfo.setBSSID(configuration.BSSID); |
| 359 | wifiInfo.setNetworkId(configuration.networkId); |
| 360 | accessPoint.update(configuration, wifiInfo, networkInfo); |
| 361 | |
| 362 | assertThat(accessPoint.isMetered()).isFalse(); |
| 363 | } |
Stephen Chen | 21f6868 | 2017-04-04 13:23:31 -0700 | [diff] [blame] | 364 | |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 365 | @Test |
Sundeep Ghuman | 55adc6b | 2017-06-05 16:46:59 -0700 | [diff] [blame] | 366 | public void testSpeedLabel_returnsVeryFast() { |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 367 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 368 | |
| 369 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 370 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 371 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.VERY_FAST); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 372 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 373 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 374 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 375 | |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 376 | assertThat(ap.getSpeed()).isEqualTo(AccessPoint.Speed.VERY_FAST); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 377 | assertThat(ap.getSpeedLabel()) |
| 378 | .isEqualTo(mContext.getString(R.string.speed_label_very_fast)); |
| 379 | } |
| 380 | |
| 381 | @Test |
Sundeep Ghuman | 55adc6b | 2017-06-05 16:46:59 -0700 | [diff] [blame] | 382 | public void testSpeedLabel_returnsFast() { |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 383 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 384 | |
| 385 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 386 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 387 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.FAST); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 388 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 389 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 390 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 391 | |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 392 | assertThat(ap.getSpeed()).isEqualTo(AccessPoint.Speed.FAST); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 393 | assertThat(ap.getSpeedLabel()) |
| 394 | .isEqualTo(mContext.getString(R.string.speed_label_fast)); |
| 395 | } |
| 396 | |
| 397 | @Test |
Sundeep Ghuman | 55adc6b | 2017-06-05 16:46:59 -0700 | [diff] [blame] | 398 | public void testSpeedLabel_returnsOkay() { |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 399 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 400 | |
| 401 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 402 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 403 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.MODERATE); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 404 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 405 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 406 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 407 | |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 408 | assertThat(ap.getSpeed()).isEqualTo(AccessPoint.Speed.MODERATE); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 409 | assertThat(ap.getSpeedLabel()) |
| 410 | .isEqualTo(mContext.getString(R.string.speed_label_okay)); |
| 411 | } |
| 412 | |
| 413 | @Test |
Sundeep Ghuman | 55adc6b | 2017-06-05 16:46:59 -0700 | [diff] [blame] | 414 | public void testSpeedLabel_returnsSlow() { |
| 415 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 416 | |
| 417 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 418 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 419 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.SLOW); |
Sundeep Ghuman | 55adc6b | 2017-06-05 16:46:59 -0700 | [diff] [blame] | 420 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 421 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 422 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 55adc6b | 2017-06-05 16:46:59 -0700 | [diff] [blame] | 423 | |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 424 | assertThat(ap.getSpeed()).isEqualTo(AccessPoint.Speed.SLOW); |
Sundeep Ghuman | 55adc6b | 2017-06-05 16:46:59 -0700 | [diff] [blame] | 425 | assertThat(ap.getSpeedLabel()) |
| 426 | .isEqualTo(mContext.getString(R.string.speed_label_slow)); |
| 427 | } |
| 428 | |
| 429 | @Test |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 430 | public void testSummaryString_showsSpeedLabel() { |
| 431 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 432 | |
| 433 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 434 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 435 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.VERY_FAST); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 436 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 437 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 438 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 439 | |
| 440 | assertThat(ap.getSummary()).isEqualTo(mContext.getString(R.string.speed_label_very_fast)); |
| 441 | } |
| 442 | |
| 443 | @Test |
| 444 | public void testSummaryString_concatenatesSpeedLabel() { |
| 445 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 446 | ap.update(new WifiConfiguration()); |
| 447 | |
| 448 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 449 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
Sundeep Ghuman | 53200ed | 2017-06-21 16:54:36 -0700 | [diff] [blame] | 450 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.VERY_FAST); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 451 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 452 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 453 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 454 | |
| 455 | String expectedString = mContext.getString(R.string.speed_label_very_fast) + " / " |
| 456 | + mContext.getString(R.string.wifi_remembered); |
| 457 | assertThat(ap.getSummary()).isEqualTo(expectedString); |
| 458 | } |
| 459 | |
Peter Qiu | 9c4c6ad | 2017-06-20 13:17:36 -0700 | [diff] [blame] | 460 | @Test |
| 461 | public void testSummaryString_showsWrongPasswordLabel() { |
| 462 | WifiConfiguration configuration = createWifiConfiguration(); |
| 463 | configuration.getNetworkSelectionStatus().setNetworkSelectionStatus( |
| 464 | WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED); |
| 465 | configuration.getNetworkSelectionStatus().setNetworkSelectionDisableReason( |
| 466 | WifiConfiguration.NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD); |
| 467 | AccessPoint ap = new AccessPoint(mContext, configuration); |
| 468 | |
| 469 | assertThat(ap.getSummary()).isEqualTo(mContext.getString( |
| 470 | R.string.wifi_check_password_try_again)); |
| 471 | } |
| 472 | |
Peter Qiu | 280581b | 2017-07-24 14:18:56 -0700 | [diff] [blame] | 473 | @Test |
| 474 | public void testSummaryString_showsAvaiableViaCarrier() { |
| 475 | String carrierName = "Test Carrier"; |
| 476 | ScanResult result = new ScanResult(); |
| 477 | result.BSSID = "00:11:22:33:44:55"; |
| 478 | result.capabilities = "EAP"; |
| 479 | result.isCarrierAp = true; |
| 480 | result.carrierApEapType = WifiEnterpriseConfig.Eap.SIM; |
| 481 | result.carrierName = carrierName; |
| 482 | |
Sundeep Ghuman | 04f7f34 | 2018-01-23 19:18:31 -0800 | [diff] [blame] | 483 | AccessPoint ap = new AccessPoint(mContext, Collections.singletonList(result)); |
Peter Qiu | 280581b | 2017-07-24 14:18:56 -0700 | [diff] [blame] | 484 | assertThat(ap.getSummary()).isEqualTo(String.format(mContext.getString( |
| 485 | R.string.available_via_carrier), carrierName)); |
| 486 | assertThat(ap.isCarrierAp()).isEqualTo(true); |
| 487 | assertThat(ap.getCarrierApEapType()).isEqualTo(WifiEnterpriseConfig.Eap.SIM); |
| 488 | assertThat(ap.getCarrierName()).isEqualTo(carrierName); |
| 489 | } |
| 490 | |
| 491 | @Test |
| 492 | public void testSummaryString_showsConnectedViaCarrier() { |
| 493 | int networkId = 123; |
| 494 | int rssi = -55; |
| 495 | String carrierName = "Test Carrier"; |
| 496 | WifiConfiguration config = new WifiConfiguration(); |
| 497 | config.networkId = networkId; |
| 498 | WifiInfo wifiInfo = new WifiInfo(); |
| 499 | wifiInfo.setNetworkId(networkId); |
| 500 | wifiInfo.setRssi(rssi); |
| 501 | |
| 502 | NetworkInfo networkInfo = |
| 503 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 504 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, "", ""); |
| 505 | |
| 506 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 507 | .setNetworkInfo(networkInfo) |
| 508 | .setNetworkId(networkId) |
| 509 | .setRssi(rssi) |
| 510 | .setWifiInfo(wifiInfo) |
| 511 | .setIsCarrierAp(true) |
| 512 | .setCarrierName(carrierName) |
| 513 | .build(); |
| 514 | assertThat(ap.getSummary()).isEqualTo(String.format(mContext.getString( |
| 515 | R.string.connected_via_carrier), carrierName)); |
| 516 | } |
| 517 | |
| 518 | @Test |
Roshan Pius | e9b8e50 | 2019-01-23 15:42:44 -0800 | [diff] [blame] | 519 | public void testSummaryString_showsConnectedViaSuggestionOrSpecifierApp() throws Exception { |
| 520 | final int rssi = -55; |
| 521 | final String appPackageName = "com.test.app"; |
| 522 | final CharSequence appLabel = "Test App"; |
| 523 | final String connectedViaAppResourceString = "Connected via "; |
| 524 | |
| 525 | WifiInfo wifiInfo = new WifiInfo(); |
| 526 | wifiInfo.setSSID(WifiSsid.createFromAsciiEncoded(TEST_SSID)); |
| 527 | wifiInfo.setEphemeral(true); |
| 528 | wifiInfo.setNetworkSuggestionOrSpecifierPackageName(appPackageName); |
| 529 | wifiInfo.setRssi(rssi); |
| 530 | |
| 531 | Context context = mock(Context.class); |
| 532 | Resources resources = mock(Resources.class); |
| 533 | PackageManager packageManager = mock(PackageManager.class); |
| 534 | ApplicationInfo applicationInfo = mock(ApplicationInfo.class); |
| 535 | when(context.getPackageManager()).thenReturn(packageManager); |
| 536 | when(context.getResources()).thenReturn(resources); |
| 537 | when(resources.getString(R.string.connected_via_app, appLabel)) |
| 538 | .thenReturn(connectedViaAppResourceString + appLabel.toString()); |
| 539 | when(packageManager.getApplicationInfoAsUser(eq(appPackageName), anyInt(), anyInt())) |
| 540 | .thenReturn(applicationInfo); |
| 541 | when(applicationInfo.loadLabel(packageManager)).thenReturn(appLabel); |
| 542 | |
| 543 | NetworkInfo networkInfo = |
| 544 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 545 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, "", ""); |
| 546 | |
| 547 | AccessPoint ap = new TestAccessPointBuilder(context) |
| 548 | .setSsid(TEST_SSID) |
| 549 | .setNetworkInfo(networkInfo) |
| 550 | .setRssi(rssi) |
| 551 | .setSecurity(AccessPoint.SECURITY_NONE) |
| 552 | .setWifiInfo(wifiInfo) |
| 553 | .build(); |
| 554 | assertThat(ap.getSummary()).isEqualTo("Connected via Test App"); |
| 555 | } |
| 556 | |
| 557 | @Test |
Sundeep Ghuman | 04f7f34 | 2018-01-23 19:18:31 -0800 | [diff] [blame] | 558 | public void testSetScanResultWithCarrierInfo() { |
Peter Qiu | 280581b | 2017-07-24 14:18:56 -0700 | [diff] [blame] | 559 | String ssid = "ssid"; |
| 560 | AccessPoint ap = new TestAccessPointBuilder(mContext).setSsid(ssid).build(); |
| 561 | assertThat(ap.isCarrierAp()).isEqualTo(false); |
| 562 | assertThat(ap.getCarrierApEapType()).isEqualTo(WifiEnterpriseConfig.Eap.NONE); |
| 563 | assertThat(ap.getCarrierName()).isEqualTo(null); |
| 564 | |
| 565 | int carrierApEapType = WifiEnterpriseConfig.Eap.SIM; |
| 566 | String carrierName = "Test Carrier"; |
| 567 | ScanResult scanResult = new ScanResult(); |
| 568 | scanResult.SSID = ssid; |
| 569 | scanResult.BSSID = "00:11:22:33:44:55"; |
| 570 | scanResult.capabilities = ""; |
| 571 | scanResult.isCarrierAp = true; |
| 572 | scanResult.carrierApEapType = carrierApEapType; |
| 573 | scanResult.carrierName = carrierName; |
Peter Qiu | 280581b | 2017-07-24 14:18:56 -0700 | [diff] [blame] | 574 | |
Sundeep Ghuman | 04f7f34 | 2018-01-23 19:18:31 -0800 | [diff] [blame] | 575 | |
| 576 | ap.setScanResults(Collections.singletonList(scanResult)); |
Peter Qiu | 280581b | 2017-07-24 14:18:56 -0700 | [diff] [blame] | 577 | assertThat(ap.isCarrierAp()).isEqualTo(true); |
| 578 | assertThat(ap.getCarrierApEapType()).isEqualTo(carrierApEapType); |
| 579 | assertThat(ap.getCarrierName()).isEqualTo(carrierName); |
| 580 | } |
| 581 | |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 582 | private ScoredNetwork buildScoredNetworkWithMockBadgeCurve() { |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 583 | return buildScoredNetworkWithGivenBadgeCurve(mockBadgeCurve); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 584 | } |
| 585 | |
| 586 | private ScoredNetwork buildScoredNetworkWithGivenBadgeCurve(RssiCurve badgeCurve) { |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 587 | Bundle attr1 = new Bundle(); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 588 | attr1.putParcelable(ScoredNetwork.ATTRIBUTES_KEY_BADGING_CURVE, badgeCurve); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 589 | return new ScoredNetwork( |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 590 | new NetworkKey(new WifiKey(TEST_SSID, TEST_BSSID)), |
| 591 | badgeCurve, |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 592 | false /* meteredHint */, |
| 593 | attr1); |
Sundeep Ghuman | 271e5de | 2017-05-30 14:11:39 -0700 | [diff] [blame] | 594 | } |
| 595 | |
Sundeep Ghuman | 54bdcfa | 2017-03-08 19:52:05 -0800 | [diff] [blame] | 596 | private AccessPoint createAccessPointWithScanResultCache() { |
| 597 | Bundle bundle = new Bundle(); |
Sundeep Ghuman | 04f7f34 | 2018-01-23 19:18:31 -0800 | [diff] [blame] | 598 | bundle.putParcelableArray( |
| 599 | AccessPoint.KEY_SCANRESULTS, |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 600 | mScanResults.toArray(new Parcelable[mScanResults.size()])); |
Sundeep Ghuman | a28050a | 2017-07-12 22:09:25 -0700 | [diff] [blame] | 601 | return new AccessPoint(mContext, bundle); |
| 602 | } |
| 603 | |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 604 | private ArrayList<ScanResult> buildScanResultCache(String ssid) { |
Sundeep Ghuman | 54bdcfa | 2017-03-08 19:52:05 -0800 | [diff] [blame] | 605 | ArrayList<ScanResult> scanResults = new ArrayList<>(); |
| 606 | for (int i = 0; i < 5; i++) { |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 607 | ScanResult scanResult = createScanResult(ssid, "bssid-" + i, i); |
Sundeep Ghuman | 54bdcfa | 2017-03-08 19:52:05 -0800 | [diff] [blame] | 608 | scanResults.add(scanResult); |
| 609 | } |
Sundeep Ghuman | a28050a | 2017-07-12 22:09:25 -0700 | [diff] [blame] | 610 | return scanResults; |
Sundeep Ghuman | 54bdcfa | 2017-03-08 19:52:05 -0800 | [diff] [blame] | 611 | } |
| 612 | |
Ajay Nadathur | d7b689a | 2016-08-31 15:07:56 -0700 | [diff] [blame] | 613 | private WifiConfiguration createWifiConfiguration() { |
| 614 | WifiConfiguration configuration = new WifiConfiguration(); |
| 615 | configuration.BSSID = "bssid"; |
| 616 | configuration.SSID = "ssid"; |
| 617 | configuration.networkId = 123; |
| 618 | return configuration; |
| 619 | } |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 620 | |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 621 | private AccessPoint createApWithFastTimestampedScoredNetworkCache( |
| 622 | long elapsedTimeMillis) { |
| 623 | TimestampedScoredNetwork recentScore = new TimestampedScoredNetwork( |
| 624 | buildScoredNetworkWithGivenBadgeCurve(FAST_BADGE_CURVE), |
| 625 | elapsedTimeMillis); |
| 626 | return new TestAccessPointBuilder(mContext) |
| 627 | .setSsid(TEST_SSID) |
| 628 | .setScoredNetworkCache( |
| 629 | new ArrayList<>(Arrays.asList(recentScore))) |
| 630 | .build(); |
| 631 | } |
| 632 | |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 633 | /** |
Eric Schwarzenbach | f4f3842b | 2017-07-17 16:45:04 -0700 | [diff] [blame] | 634 | * Assert that the first AccessPoint appears before the second AccessPoint |
Dave Schaefer | 9853743 | 2017-02-08 11:26:08 -0800 | [diff] [blame] | 635 | * once sorting has been completed. |
| 636 | */ |
| 637 | private void assertSortingWorks(AccessPoint first, AccessPoint second) { |
| 638 | |
| 639 | ArrayList<AccessPoint> points = new ArrayList<AccessPoint>(); |
| 640 | |
| 641 | // add in reverse order so we can tell that sorting actually changed something |
| 642 | points.add(second); |
| 643 | points.add(first); |
| 644 | Collections.sort(points); |
| 645 | assertWithMessage( |
| 646 | String.format("After sorting: second AccessPoint should have higher array index " |
| 647 | + "than the first, but found indicies second '%s' and first '%s'.", |
| 648 | points.indexOf(second), points.indexOf(first))) |
| 649 | .that(points.indexOf(second)).isGreaterThan(points.indexOf(first)); |
| 650 | } |
| 651 | |
| 652 | @Test |
| 653 | public void testBuilder_setActive() { |
| 654 | AccessPoint activeAp = new TestAccessPointBuilder(mContext).setActive(true).build(); |
| 655 | assertThat(activeAp.isActive()).isTrue(); |
| 656 | |
| 657 | AccessPoint inactiveAp = new TestAccessPointBuilder(mContext).setActive(false).build(); |
| 658 | assertThat(inactiveAp.isActive()).isFalse(); |
| 659 | } |
| 660 | |
| 661 | @Test |
| 662 | public void testBuilder_setReachable() { |
| 663 | AccessPoint nearAp = new TestAccessPointBuilder(mContext).setReachable(true).build(); |
| 664 | assertThat(nearAp.isReachable()).isTrue(); |
| 665 | |
| 666 | AccessPoint farAp = new TestAccessPointBuilder(mContext).setReachable(false).build(); |
| 667 | assertThat(farAp.isReachable()).isFalse(); |
| 668 | } |
| 669 | |
| 670 | @Test |
| 671 | public void testBuilder_setSaved() { |
| 672 | AccessPoint savedAp = new TestAccessPointBuilder(mContext).setSaved(true).build(); |
| 673 | assertThat(savedAp.isSaved()).isTrue(); |
| 674 | |
| 675 | AccessPoint newAp = new TestAccessPointBuilder(mContext).setSaved(false).build(); |
| 676 | assertThat(newAp.isSaved()).isFalse(); |
| 677 | } |
| 678 | |
| 679 | @Test |
| 680 | public void testBuilder_setLevel() { |
| 681 | AccessPoint testAp; |
| 682 | |
| 683 | for (int i = 0; i < AccessPoint.SIGNAL_LEVELS; i++) { |
| 684 | testAp = new TestAccessPointBuilder(mContext).setLevel(i).build(); |
| 685 | assertThat(testAp.getLevel()).isEqualTo(i); |
| 686 | } |
| 687 | |
| 688 | // numbers larger than the max level should be set to max |
| 689 | testAp = new TestAccessPointBuilder(mContext).setLevel(AccessPoint.SIGNAL_LEVELS).build(); |
| 690 | assertThat(testAp.getLevel()).isEqualTo(AccessPoint.SIGNAL_LEVELS - 1); |
| 691 | |
| 692 | // numbers less than 0 should give level 0 |
| 693 | testAp = new TestAccessPointBuilder(mContext).setLevel(-100).build(); |
| 694 | assertThat(testAp.getLevel()).isEqualTo(0); |
| 695 | } |
| 696 | |
| 697 | @Test |
| 698 | public void testBuilder_settingReachableAfterLevelDoesNotAffectLevel() { |
| 699 | int level = 1; |
| 700 | assertThat(level).isLessThan(AccessPoint.SIGNAL_LEVELS - 1); |
| 701 | |
| 702 | AccessPoint testAp = |
| 703 | new TestAccessPointBuilder(mContext).setLevel(level).setReachable(true).build(); |
| 704 | assertThat(testAp.getLevel()).isEqualTo(level); |
| 705 | } |
| 706 | |
| 707 | @Test |
| 708 | public void testBuilder_setSsid() { |
| 709 | String name = "AmazingSsid!"; |
| 710 | AccessPoint namedAp = new TestAccessPointBuilder(mContext).setSsid(name).build(); |
| 711 | assertThat(namedAp.getSsidStr()).isEqualTo(name); |
| 712 | } |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 713 | |
| 714 | @Test |
| 715 | public void testBuilder_passpointConfig() { |
| 716 | String fqdn = "Test.com"; |
| 717 | String providerFriendlyName = "Test Provider"; |
| 718 | AccessPoint ap = new TestAccessPointBuilder(mContext).setFqdn(fqdn) |
| 719 | .setProviderFriendlyName(providerFriendlyName).build(); |
Stephen Chen | b5bcb8d | 2017-05-19 15:55:02 -0700 | [diff] [blame] | 720 | assertThat(ap.isPasspointConfig()).isTrue(); |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 721 | assertThat(ap.getPasspointFqdn()).isEqualTo(fqdn); |
Quang Luong | 19429e4 | 2019-02-20 17:10:51 -0800 | [diff] [blame] | 722 | assertThat(ap.getTitle()).isEqualTo(providerFriendlyName); |
Peter Qiu | ced37db | 2017-03-14 15:51:22 -0700 | [diff] [blame] | 723 | } |
Sundeep Ghuman | 96a5357 | 2017-04-20 21:25:41 -0700 | [diff] [blame] | 724 | |
| 725 | @Test |
| 726 | public void testUpdateNetworkInfo_returnsTrue() { |
| 727 | int networkId = 123; |
| 728 | int rssi = -55; |
| 729 | WifiConfiguration config = new WifiConfiguration(); |
| 730 | config.networkId = networkId; |
| 731 | WifiInfo wifiInfo = new WifiInfo(); |
| 732 | wifiInfo.setNetworkId(networkId); |
| 733 | wifiInfo.setRssi(rssi); |
| 734 | |
| 735 | NetworkInfo networkInfo = |
| 736 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 737 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTING, "", ""); |
| 738 | |
| 739 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 740 | .setNetworkInfo(networkInfo) |
| 741 | .setNetworkId(networkId) |
| 742 | .setRssi(rssi) |
| 743 | .setWifiInfo(wifiInfo) |
| 744 | .build(); |
| 745 | |
| 746 | NetworkInfo newInfo = new NetworkInfo(networkInfo); |
| 747 | newInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, "", ""); |
| 748 | assertThat(ap.update(config, wifiInfo, newInfo)).isTrue(); |
| 749 | } |
| 750 | |
| 751 | @Test |
| 752 | public void testUpdateNetworkInfoWithSameInfo_returnsFalse() { |
| 753 | int networkId = 123; |
| 754 | int rssi = -55; |
| 755 | WifiConfiguration config = new WifiConfiguration(); |
| 756 | config.networkId = networkId; |
| 757 | WifiInfo wifiInfo = new WifiInfo(); |
| 758 | wifiInfo.setNetworkId(networkId); |
| 759 | wifiInfo.setRssi(rssi); |
| 760 | |
| 761 | NetworkInfo networkInfo = |
| 762 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 763 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTING, "", ""); |
| 764 | |
| 765 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 766 | .setNetworkInfo(networkInfo) |
| 767 | .setNetworkId(networkId) |
| 768 | .setRssi(rssi) |
| 769 | .setWifiInfo(wifiInfo) |
| 770 | .build(); |
| 771 | |
| 772 | NetworkInfo newInfo = new NetworkInfo(networkInfo); // same values |
| 773 | assertThat(ap.update(config, wifiInfo, newInfo)).isFalse(); |
| 774 | } |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 775 | |
| 776 | @Test |
Glen Kuhne | d38708c | 2017-07-19 14:53:34 -0700 | [diff] [blame] | 777 | public void testUpdateWithDifferentRssi_returnsTrue() { |
| 778 | int networkId = 123; |
| 779 | int rssi = -55; |
| 780 | WifiConfiguration config = new WifiConfiguration(); |
| 781 | config.networkId = networkId; |
| 782 | WifiInfo wifiInfo = new WifiInfo(); |
| 783 | wifiInfo.setNetworkId(networkId); |
| 784 | wifiInfo.setRssi(rssi); |
| 785 | |
| 786 | NetworkInfo networkInfo = |
| 787 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 788 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTING, "", ""); |
| 789 | |
| 790 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 791 | .setNetworkInfo(networkInfo) |
| 792 | .setNetworkId(networkId) |
| 793 | .setRssi(rssi) |
| 794 | .setWifiInfo(wifiInfo) |
| 795 | .build(); |
| 796 | |
| 797 | NetworkInfo newInfo = new NetworkInfo(networkInfo); // same values |
| 798 | wifiInfo.setRssi(rssi + 1); |
| 799 | assertThat(ap.update(config, wifiInfo, newInfo)).isTrue(); |
| 800 | } |
| 801 | |
| 802 | @Test |
| 803 | public void testUpdateWithInvalidRssi_returnsFalse() { |
| 804 | int networkId = 123; |
| 805 | int rssi = -55; |
| 806 | WifiConfiguration config = new WifiConfiguration(); |
| 807 | config.networkId = networkId; |
| 808 | WifiInfo wifiInfo = new WifiInfo(); |
| 809 | wifiInfo.setNetworkId(networkId); |
| 810 | wifiInfo.setRssi(rssi); |
| 811 | |
| 812 | NetworkInfo networkInfo = |
| 813 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 814 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTING, "", ""); |
| 815 | |
| 816 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 817 | .setNetworkInfo(networkInfo) |
| 818 | .setNetworkId(networkId) |
| 819 | .setRssi(rssi) |
| 820 | .setWifiInfo(wifiInfo) |
| 821 | .build(); |
| 822 | |
| 823 | NetworkInfo newInfo = new NetworkInfo(networkInfo); // same values |
| 824 | wifiInfo.setRssi(WifiInfo.INVALID_RSSI); |
| 825 | assertThat(ap.update(config, wifiInfo, newInfo)).isFalse(); |
| 826 | } |
| 827 | @Test |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 828 | public void testUpdateWithConfigChangeOnly_returnsFalseButInvokesListener() |
| 829 | throws InterruptedException { |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 830 | WifiConfiguration config = new WifiConfiguration(); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 831 | config.networkId = NETWORK_ID; |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 832 | config.numNoInternetAccessReports = 1; |
| 833 | |
| 834 | WifiInfo wifiInfo = new WifiInfo(); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 835 | wifiInfo.setNetworkId(NETWORK_ID); |
| 836 | wifiInfo.setRssi(DEFAULT_RSSI); |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 837 | |
| 838 | NetworkInfo networkInfo = |
| 839 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 840 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, "", ""); |
| 841 | |
| 842 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 843 | .setNetworkInfo(networkInfo) |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 844 | .setNetworkId(NETWORK_ID) |
| 845 | .setRssi(DEFAULT_RSSI) |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 846 | .setWifiInfo(wifiInfo) |
| 847 | .build(); |
| 848 | |
| 849 | AccessPoint.AccessPointListener mockListener = mock(AccessPoint.AccessPointListener.class); |
| 850 | ap.setListener(mockListener); |
| 851 | WifiConfiguration newConfig = new WifiConfiguration(config); |
| 852 | config.validatedInternetAccess = true; |
| 853 | |
| 854 | assertThat(ap.update(newConfig, wifiInfo, networkInfo)).isFalse(); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 855 | |
| 856 | // Wait for MainHandler to process callback |
| 857 | CountDownLatch latch = new CountDownLatch(1); |
| 858 | ThreadUtils.postOnMainThread(latch::countDown); |
| 859 | |
| 860 | latch.await(); |
Sundeep Ghuman | f4d3302 | 2017-06-05 19:47:36 -0700 | [diff] [blame] | 861 | verify(mockListener).onAccessPointChanged(ap); |
| 862 | } |
Sundeep Ghuman | d911da3 | 2017-07-05 20:06:05 -0700 | [diff] [blame] | 863 | |
| 864 | @Test |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 865 | public void testConnectionInfo_doesNotThrowNPE_ifListenerIsNulledWhileAwaitingExecution() |
| 866 | throws InterruptedException { |
Sundeep Ghuman | d911da3 | 2017-07-05 20:06:05 -0700 | [diff] [blame] | 867 | WifiConfiguration config = new WifiConfiguration(); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 868 | config.networkId = NETWORK_ID; |
| 869 | config.numNoInternetAccessReports = 1; |
| 870 | |
Sundeep Ghuman | d911da3 | 2017-07-05 20:06:05 -0700 | [diff] [blame] | 871 | WifiInfo wifiInfo = new WifiInfo(); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 872 | wifiInfo.setNetworkId(NETWORK_ID); |
| 873 | wifiInfo.setRssi(DEFAULT_RSSI); |
| 874 | |
| 875 | NetworkInfo networkInfo = |
| 876 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 877 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, "", ""); |
| 878 | |
| 879 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 880 | .setNetworkInfo(networkInfo) |
| 881 | .setNetworkId(NETWORK_ID) |
| 882 | .setRssi(DEFAULT_RSSI) |
| 883 | .setWifiInfo(wifiInfo) |
| 884 | .build(); |
| 885 | |
| 886 | WifiConfiguration newConfig = new WifiConfiguration(config); |
| 887 | config.validatedInternetAccess = true; |
| 888 | |
| 889 | performGivenUpdateAndThenNullListenerBeforeResumingMainHandlerExecution( |
| 890 | ap, () -> assertThat(ap.update(newConfig, wifiInfo, networkInfo)).isFalse()); |
| 891 | |
| 892 | } |
| 893 | |
| 894 | private void performGivenUpdateAndThenNullListenerBeforeResumingMainHandlerExecution( |
| 895 | AccessPoint ap, Runnable r) { |
| 896 | AccessPoint.AccessPointListener mockListener = mock(AccessPoint.AccessPointListener.class); |
| 897 | ap.setListener(mockListener); |
| 898 | |
| 899 | // Put a latch on the MainHandler to prevent the callback from being invoked instantly |
| 900 | CountDownLatch latch1 = new CountDownLatch(1); |
| 901 | ThreadUtils.postOnMainThread(() -> { |
| 902 | try{ |
| 903 | latch1.await(); |
| 904 | } catch (InterruptedException e) { |
| 905 | fail("Interruped Exception thrown while awaiting latch countdown"); |
| 906 | } |
| 907 | }); |
| 908 | |
| 909 | r.run(); |
| 910 | |
| 911 | ap.setListener(null); |
| 912 | latch1.countDown(); |
| 913 | |
| 914 | // The second latch ensures the previously posted listener invocation has processed on the |
| 915 | // main thread. |
| 916 | CountDownLatch latch2 = new CountDownLatch(1); |
| 917 | ThreadUtils.postOnMainThread(latch2::countDown); |
| 918 | |
| 919 | try{ |
| 920 | latch2.await(); |
| 921 | } catch (InterruptedException e) { |
| 922 | fail("Interruped Exception thrown while awaiting latch countdown"); |
| 923 | } |
| 924 | } |
| 925 | |
| 926 | @Test |
| 927 | public void testUpdateScanResults_doesNotThrowNPE_ifListenerIsNulledWhileAwaitingExecution() |
| 928 | throws InterruptedException { |
| 929 | String ssid = "ssid"; |
| 930 | int newRssi = -80; |
| 931 | AccessPoint ap = new TestAccessPointBuilder(mContext).setSsid(ssid).build(); |
| 932 | |
| 933 | ScanResult scanResult = new ScanResult(); |
| 934 | scanResult.SSID = ssid; |
| 935 | scanResult.level = newRssi; |
| 936 | scanResult.BSSID = "bssid"; |
| 937 | scanResult.timestamp = SystemClock.elapsedRealtime() * 1000; |
| 938 | scanResult.capabilities = ""; |
| 939 | |
| 940 | performGivenUpdateAndThenNullListenerBeforeResumingMainHandlerExecution( |
| 941 | ap, () -> ap.setScanResults(Collections.singletonList(scanResult))); |
| 942 | } |
| 943 | |
| 944 | @Test |
| 945 | public void testUpdateConfig_doesNotThrowNPE_ifListenerIsNulledWhileAwaitingExecution() |
| 946 | throws InterruptedException { |
| 947 | WifiConfiguration config = new WifiConfiguration(); |
| 948 | config.networkId = NETWORK_ID; |
| 949 | config.numNoInternetAccessReports = 1; |
| 950 | |
| 951 | WifiInfo wifiInfo = new WifiInfo(); |
| 952 | wifiInfo.setNetworkId(NETWORK_ID); |
| 953 | wifiInfo.setRssi(DEFAULT_RSSI); |
| 954 | |
| 955 | NetworkInfo networkInfo = |
| 956 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 957 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, "", ""); |
| 958 | |
| 959 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 960 | .setNetworkInfo(networkInfo) |
| 961 | .setNetworkId(NETWORK_ID) |
| 962 | .setRssi(DEFAULT_RSSI) |
| 963 | .setWifiInfo(wifiInfo) |
| 964 | .build(); |
| 965 | |
| 966 | WifiConfiguration newConfig = new WifiConfiguration(config); |
| 967 | config.validatedInternetAccess = true; |
| 968 | |
| 969 | performGivenUpdateAndThenNullListenerBeforeResumingMainHandlerExecution( |
| 970 | ap, () -> ap.update(newConfig)); |
| 971 | } |
| 972 | |
| 973 | @Test |
| 974 | public void testUpdateWithNullWifiConfiguration_doesNotThrowNPE() { |
| 975 | WifiConfiguration config = new WifiConfiguration(); |
| 976 | config.networkId = NETWORK_ID; |
| 977 | WifiInfo wifiInfo = new WifiInfo(); |
| 978 | wifiInfo.setNetworkId(NETWORK_ID); |
| 979 | wifiInfo.setRssi(DEFAULT_RSSI); |
Sundeep Ghuman | d911da3 | 2017-07-05 20:06:05 -0700 | [diff] [blame] | 980 | |
| 981 | NetworkInfo networkInfo = |
| 982 | new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0 /* subtype */, "WIFI", ""); |
| 983 | networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTING, "", ""); |
| 984 | |
| 985 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 986 | .setNetworkInfo(networkInfo) |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 987 | .setNetworkId(NETWORK_ID) |
| 988 | .setRssi(DEFAULT_RSSI) |
Sundeep Ghuman | d911da3 | 2017-07-05 20:06:05 -0700 | [diff] [blame] | 989 | .setWifiInfo(wifiInfo) |
| 990 | .build(); |
| 991 | |
| 992 | ap.update(null, wifiInfo, networkInfo); |
| 993 | } |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 994 | |
| 995 | @Test |
| 996 | public void testSpeedLabelAveragesAllBssidScores() { |
| 997 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 998 | |
| 999 | int speed1 = Speed.MODERATE; |
| 1000 | RssiCurve badgeCurve1 = mock(RssiCurve.class); |
| 1001 | when(badgeCurve1.lookupScore(anyInt())).thenReturn((byte) speed1); |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1002 | when(mockWifiNetworkScoreCache.getScoredNetwork(mScanResults.get(0))) |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1003 | .thenReturn(buildScoredNetworkWithGivenBadgeCurve(badgeCurve1)); |
| 1004 | int speed2 = Speed.VERY_FAST; |
| 1005 | RssiCurve badgeCurve2 = mock(RssiCurve.class); |
| 1006 | when(badgeCurve2.lookupScore(anyInt())).thenReturn((byte) speed2); |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1007 | when(mockWifiNetworkScoreCache.getScoredNetwork(mScanResults.get(1))) |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1008 | .thenReturn(buildScoredNetworkWithGivenBadgeCurve(badgeCurve2)); |
| 1009 | |
| 1010 | int expectedSpeed = (speed1 + speed2) / 2; |
| 1011 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1012 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 1013 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1014 | |
| 1015 | assertThat(ap.getSpeed()).isEqualTo(expectedSpeed); |
| 1016 | } |
| 1017 | |
| 1018 | @Test |
| 1019 | public void testSpeedLabelAverageIgnoresNoSpeedScores() { |
| 1020 | AccessPoint ap = createAccessPointWithScanResultCache(); |
| 1021 | |
| 1022 | int speed1 = Speed.VERY_FAST; |
| 1023 | RssiCurve badgeCurve1 = mock(RssiCurve.class); |
| 1024 | when(badgeCurve1.lookupScore(anyInt())).thenReturn((byte) speed1); |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1025 | when(mockWifiNetworkScoreCache.getScoredNetwork(mScanResults.get(0))) |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1026 | .thenReturn(buildScoredNetworkWithGivenBadgeCurve(badgeCurve1)); |
| 1027 | int speed2 = Speed.NONE; |
| 1028 | RssiCurve badgeCurve2 = mock(RssiCurve.class); |
| 1029 | when(badgeCurve2.lookupScore(anyInt())).thenReturn((byte) speed2); |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1030 | when(mockWifiNetworkScoreCache.getScoredNetwork(mScanResults.get(1))) |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1031 | .thenReturn(buildScoredNetworkWithGivenBadgeCurve(badgeCurve2)); |
| 1032 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1033 | ap.update( |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 1034 | mockWifiNetworkScoreCache, true /* scoringUiEnabled */, MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1035 | |
| 1036 | assertThat(ap.getSpeed()).isEqualTo(speed1); |
| 1037 | } |
| 1038 | |
| 1039 | @Test |
Sundeep Ghuman | a782569 | 2017-08-23 15:53:00 -0700 | [diff] [blame] | 1040 | public void testSpeedLabelFallbackScoreIgnoresNullCurves() { |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1041 | String bssid = "00:00:00:00:00:00"; |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1042 | |
| 1043 | WifiInfo info = new WifiInfo(); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 1044 | info.setRssi(DEFAULT_RSSI); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1045 | info.setSSID(WifiSsid.createFromAsciiEncoded(TEST_SSID)); |
| 1046 | info.setBSSID(bssid); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 1047 | info.setNetworkId(NETWORK_ID); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1048 | |
| 1049 | ArrayList<ScanResult> scanResults = new ArrayList<>(); |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 1050 | ScanResult scanResultUnconnected = |
| 1051 | createScanResult(TEST_SSID, "11:11:11:11:11:11", DEFAULT_RSSI); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1052 | scanResults.add(scanResultUnconnected); |
| 1053 | |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 1054 | ScanResult scanResultConnected = |
| 1055 | createScanResult(TEST_SSID, bssid, DEFAULT_RSSI); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1056 | scanResults.add(scanResultConnected); |
| 1057 | |
| 1058 | AccessPoint ap = |
| 1059 | new TestAccessPointBuilder(mContext) |
| 1060 | .setActive(true) |
Sundeep Ghuman | 5fde640 | 2018-02-21 20:51:39 -0800 | [diff] [blame] | 1061 | .setNetworkId(NETWORK_ID) |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1062 | .setSsid(TEST_SSID) |
Sundeep Ghuman | 04f7f34 | 2018-01-23 19:18:31 -0800 | [diff] [blame] | 1063 | .setScanResults(scanResults) |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1064 | .setWifiInfo(info) |
| 1065 | .build(); |
| 1066 | |
| 1067 | int fallbackSpeed = Speed.SLOW; |
| 1068 | when(mockWifiNetworkScoreCache.getScoredNetwork(scanResultUnconnected)) |
| 1069 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
| 1070 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) fallbackSpeed); |
| 1071 | |
| 1072 | when(mockWifiNetworkScoreCache.getScoredNetwork(scanResultConnected)) |
| 1073 | .thenReturn(null); |
| 1074 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1075 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 1076 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | 6390fa8 | 2017-08-01 17:50:59 -0700 | [diff] [blame] | 1077 | |
| 1078 | assertThat(ap.getSpeed()).isEqualTo(fallbackSpeed); |
| 1079 | } |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1080 | |
| 1081 | @Test |
| 1082 | public void testScoredNetworkCacheBundling() { |
| 1083 | long timeMillis = SystemClock.elapsedRealtime(); |
| 1084 | AccessPoint ap = createApWithFastTimestampedScoredNetworkCache(timeMillis); |
| 1085 | Bundle bundle = new Bundle(); |
| 1086 | ap.saveWifiState(bundle); |
| 1087 | |
| 1088 | ArrayList<TimestampedScoredNetwork> list = |
| 1089 | bundle.getParcelableArrayList(AccessPoint.KEY_SCOREDNETWORKCACHE); |
| 1090 | assertThat(list).hasSize(1); |
| 1091 | assertThat(list.get(0).getUpdatedTimestampMillis()).isEqualTo(timeMillis); |
| 1092 | |
| 1093 | RssiCurve curve = list.get(0).getScore().attributes.getParcelable( |
| 1094 | ScoredNetwork.ATTRIBUTES_KEY_BADGING_CURVE); |
| 1095 | assertThat(curve).isEqualTo(FAST_BADGE_CURVE); |
| 1096 | } |
| 1097 | |
| 1098 | @Test |
| 1099 | public void testRecentNetworkScoresAreUsedForSpeedLabelGeneration() { |
| 1100 | AccessPoint ap = |
| 1101 | createApWithFastTimestampedScoredNetworkCache(SystemClock.elapsedRealtime()); |
| 1102 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1103 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 1104 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1105 | |
| 1106 | assertThat(ap.getSpeed()).isEqualTo(Speed.FAST); |
| 1107 | } |
| 1108 | |
| 1109 | @Test |
| 1110 | public void testNetworkScoresAreUsedForSpeedLabelGenerationWhenWithinAgeRange() { |
| 1111 | long withinRangeTimeMillis = |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1112 | SystemClock.elapsedRealtime() - (MAX_SCORE_CACHE_AGE_MILLIS - 10000); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1113 | AccessPoint ap = |
| 1114 | createApWithFastTimestampedScoredNetworkCache(withinRangeTimeMillis); |
| 1115 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1116 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 1117 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1118 | |
| 1119 | assertThat(ap.getSpeed()).isEqualTo(Speed.FAST); |
| 1120 | } |
| 1121 | |
| 1122 | @Test |
| 1123 | public void testOldNetworkScoresAreNotUsedForSpeedLabelGeneration() { |
| 1124 | long tooOldTimeMillis = |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1125 | SystemClock.elapsedRealtime() - (MAX_SCORE_CACHE_AGE_MILLIS + 1); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1126 | AccessPoint ap = |
| 1127 | createApWithFastTimestampedScoredNetworkCache(tooOldTimeMillis); |
| 1128 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1129 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 1130 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1131 | |
| 1132 | assertThat(ap.getSpeed()).isEqualTo(Speed.NONE); |
| 1133 | } |
| 1134 | |
| 1135 | @Test |
| 1136 | public void testUpdateScoresRefreshesScoredNetworkCacheTimestamps () { |
| 1137 | long tooOldTimeMillis = |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1138 | SystemClock.elapsedRealtime() - (MAX_SCORE_CACHE_AGE_MILLIS + 1); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1139 | |
| 1140 | ScoredNetwork scoredNetwork = buildScoredNetworkWithGivenBadgeCurve(FAST_BADGE_CURVE); |
| 1141 | TimestampedScoredNetwork recentScore = new TimestampedScoredNetwork( |
| 1142 | scoredNetwork, |
| 1143 | tooOldTimeMillis); |
| 1144 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 1145 | .setSsid(TEST_SSID) |
| 1146 | .setBssid(TEST_BSSID) |
| 1147 | .setActive(true) |
| 1148 | .setScoredNetworkCache( |
| 1149 | new ArrayList(Arrays.asList(recentScore))) |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1150 | .setScanResults(mScanResults) |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1151 | .build(); |
| 1152 | |
| 1153 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 1154 | .thenReturn(scoredNetwork); |
| 1155 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1156 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 1157 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1158 | |
| 1159 | // Fast should still be returned since cache was updated with recent time |
| 1160 | assertThat(ap.getSpeed()).isEqualTo(Speed.FAST); |
| 1161 | } |
| 1162 | |
| 1163 | @Test |
| 1164 | public void testUpdateScoresRefreshesScoredNetworkCacheWithNewSpeed () { |
| 1165 | long tooOldTimeMillis = |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1166 | SystemClock.elapsedRealtime() - (MAX_SCORE_CACHE_AGE_MILLIS + 1); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1167 | |
| 1168 | ScoredNetwork scoredNetwork = buildScoredNetworkWithGivenBadgeCurve(FAST_BADGE_CURVE); |
| 1169 | TimestampedScoredNetwork recentScore = new TimestampedScoredNetwork( |
| 1170 | scoredNetwork, |
| 1171 | tooOldTimeMillis); |
| 1172 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 1173 | .setSsid(TEST_SSID) |
| 1174 | .setBssid(TEST_BSSID) |
| 1175 | .setActive(true) |
| 1176 | .setScoredNetworkCache( |
| 1177 | new ArrayList(Arrays.asList(recentScore))) |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1178 | .setScanResults(mScanResults) |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1179 | .build(); |
| 1180 | |
| 1181 | int newSpeed = Speed.MODERATE; |
| 1182 | when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class))) |
| 1183 | .thenReturn(buildScoredNetworkWithMockBadgeCurve()); |
| 1184 | when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) newSpeed); |
| 1185 | |
Sundeep Ghuman | 9bb85d3 | 2017-08-28 17:04:16 -0700 | [diff] [blame] | 1186 | ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */, |
| 1187 | MAX_SCORE_CACHE_AGE_MILLIS); |
Sundeep Ghuman | a419b9b | 2017-08-15 15:47:18 -0700 | [diff] [blame] | 1188 | |
| 1189 | // Fast should still be returned since cache was updated with recent time |
| 1190 | assertThat(ap.getSpeed()).isEqualTo(newSpeed); |
| 1191 | } |
Quang Luong | 1f1207b | 2019-02-19 17:35:50 -0800 | [diff] [blame] | 1192 | |
| 1193 | /** |
| 1194 | * Verifies that a Passpoint WifiInfo updates the matching Passpoint AP |
| 1195 | */ |
| 1196 | @Test |
| 1197 | public void testUpdate_passpointWifiInfo_updatesPasspointAccessPoint() { |
| 1198 | mWifiInfo.setFQDN("fqdn"); |
| 1199 | mWifiInfo.setProviderFriendlyName("providerFriendlyName"); |
| 1200 | |
| 1201 | WifiConfiguration spyConfig = spy(new WifiConfiguration()); |
| 1202 | when(spyConfig.isPasspoint()).thenReturn(true); |
| 1203 | spyConfig.SSID = TEST_SSID; |
| 1204 | spyConfig.BSSID = TEST_BSSID; |
| 1205 | spyConfig.FQDN = "fqdn"; |
| 1206 | spyConfig.providerFriendlyName = "providerFriendlyName"; |
| 1207 | AccessPoint passpointAp = new AccessPoint(mContext, spyConfig); |
| 1208 | |
| 1209 | assertThat(passpointAp.update(null, mWifiInfo, null)).isTrue(); |
| 1210 | } |
| 1211 | |
| 1212 | /** |
| 1213 | * Verifies that a Passpoint WifiInfo does not update a non-Passpoint AP with the same SSID. |
| 1214 | */ |
| 1215 | @Test |
| 1216 | public void testUpdate_passpointWifiInfo_doesNotUpdateNonPasspointAccessPoint() { |
| 1217 | mWifiInfo.setFQDN("fqdn"); |
| 1218 | mWifiInfo.setProviderFriendlyName("providerFriendlyName"); |
| 1219 | |
| 1220 | AccessPoint ap = new TestAccessPointBuilder(mContext) |
| 1221 | .setSsid(TEST_SSID) |
| 1222 | .setBssid(TEST_BSSID) |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1223 | .setScanResults(mScanResults) |
Quang Luong | 1f1207b | 2019-02-19 17:35:50 -0800 | [diff] [blame] | 1224 | .build(); |
| 1225 | |
| 1226 | assertThat(ap.update(null, mWifiInfo, null)).isFalse(); |
| 1227 | } |
| 1228 | |
| 1229 | /** |
| 1230 | * Verifies that a non-Passpoint WifiInfo does not update a Passpoint AP with the same SSID. |
| 1231 | */ |
| 1232 | @Test |
| 1233 | public void testUpdate_nonPasspointWifiInfo_doesNotUpdatePasspointAccessPoint() { |
| 1234 | WifiConfiguration spyConfig = spy(new WifiConfiguration()); |
| 1235 | when(spyConfig.isPasspoint()).thenReturn(true); |
| 1236 | spyConfig.SSID = TEST_SSID; |
| 1237 | spyConfig.BSSID = TEST_BSSID; |
| 1238 | spyConfig.FQDN = "fqdn"; |
| 1239 | spyConfig.providerFriendlyName = "providerFriendlyName"; |
| 1240 | AccessPoint passpointAp = new AccessPoint(mContext, spyConfig); |
| 1241 | |
| 1242 | assertThat(passpointAp.update(null, mWifiInfo, null)).isFalse(); |
| 1243 | } |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1244 | |
| 1245 | /** |
| 1246 | * Verifies that an AccessPoint's getKey() is consistent with the overloaded static getKey(). |
| 1247 | */ |
| 1248 | @Test |
| 1249 | public void testGetKey_matchesKeysCorrectly() { |
| 1250 | AccessPoint ap = new AccessPoint(mContext, mScanResults); |
| 1251 | assertThat(ap.getKey()).isEqualTo(AccessPoint.getKey(mScanResults.get(0))); |
| 1252 | |
| 1253 | WifiConfiguration spyConfig = spy(new WifiConfiguration()); |
| 1254 | when(spyConfig.isPasspoint()).thenReturn(true); |
| 1255 | spyConfig.FQDN = "fqdn"; |
| 1256 | AccessPoint passpointAp = new AccessPoint(mContext, spyConfig, mScanResults, null); |
| 1257 | assertThat(passpointAp.getKey()).isEqualTo(AccessPoint.getKey(spyConfig)); |
| 1258 | |
Quang Luong | 6e711c8 | 2019-03-07 14:52:55 -0800 | [diff] [blame] | 1259 | PasspointConfiguration passpointConfig = new PasspointConfiguration(); |
| 1260 | HomeSp homeSp = new HomeSp(); |
| 1261 | homeSp.setFqdn("fqdn"); |
| 1262 | homeSp.setFriendlyName("Test Provider"); |
| 1263 | passpointConfig.setHomeSp(homeSp); |
| 1264 | AccessPoint passpointConfigAp = new AccessPoint(mContext, passpointConfig); |
| 1265 | assertThat(passpointConfigAp.getKey()).isEqualTo(AccessPoint.getKey("fqdn")); |
| 1266 | |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1267 | OsuProvider provider = createOsuProvider(); |
| 1268 | AccessPoint osuAp = new AccessPoint(mContext, provider, mScanResults); |
| 1269 | assertThat(osuAp.getKey()).isEqualTo(AccessPoint.getKey(provider)); |
| 1270 | } |
| 1271 | |
| 1272 | /** |
| 1273 | * Verifies that the Passpoint AccessPoint constructor creates AccessPoints whose isPasspoint() |
| 1274 | * returns true. |
| 1275 | */ |
| 1276 | @Test |
| 1277 | public void testPasspointAccessPointConstructor_createdAccessPointIsPasspoint() { |
| 1278 | WifiConfiguration spyConfig = spy(new WifiConfiguration()); |
| 1279 | when(spyConfig.isPasspoint()).thenReturn(true); |
| 1280 | AccessPoint passpointAccessPoint = new AccessPoint(mContext, spyConfig, |
| 1281 | mScanResults, mRoamingScans); |
| 1282 | |
| 1283 | assertThat(passpointAccessPoint.isPasspoint()).isTrue(); |
| 1284 | } |
| 1285 | |
| 1286 | /** |
| 1287 | * Verifies that Passpoint AccessPoints set their config's SSID to the home scans', and to the |
| 1288 | * roaming scans' if no home scans are available. |
| 1289 | */ |
| 1290 | @Test |
| 1291 | public void testSetScanResultsPasspoint_differentiatesHomeAndRoaming() { |
| 1292 | WifiConfiguration spyConfig = spy(new WifiConfiguration()); |
| 1293 | when(spyConfig.isPasspoint()).thenReturn(true); |
| 1294 | AccessPoint passpointAccessPoint = new AccessPoint(mContext, spyConfig, |
| 1295 | mScanResults, mRoamingScans); |
| 1296 | assertThat(AccessPoint.removeDoubleQuotes(spyConfig.SSID)).isEqualTo(TEST_SSID); |
| 1297 | |
| 1298 | passpointAccessPoint.setScanResultsPasspoint(null, mRoamingScans); |
| 1299 | assertThat(AccessPoint.removeDoubleQuotes(spyConfig.SSID)).isEqualTo(ROAMING_SSID); |
| 1300 | |
| 1301 | passpointAccessPoint.setScanResultsPasspoint(mScanResults, null); |
| 1302 | assertThat(AccessPoint.removeDoubleQuotes(spyConfig.SSID)).isEqualTo(TEST_SSID); |
| 1303 | } |
| 1304 | |
| 1305 | /** |
| 1306 | * Verifies that getScanResults returns both home and roaming scans. |
| 1307 | */ |
| 1308 | @Test |
| 1309 | public void testGetScanResults_showsHomeAndRoamingScans() { |
| 1310 | WifiConfiguration spyConfig = spy(new WifiConfiguration()); |
| 1311 | when(spyConfig.isPasspoint()).thenReturn(true); |
| 1312 | AccessPoint passpointAccessPoint = new AccessPoint(mContext, spyConfig, |
| 1313 | mScanResults, mRoamingScans); |
| 1314 | Set<ScanResult> fullSet = new ArraySet<>(); |
| 1315 | fullSet.addAll(mScanResults); |
| 1316 | fullSet.addAll(mRoamingScans); |
| 1317 | assertThat(passpointAccessPoint.getScanResults()).isEqualTo(fullSet); |
| 1318 | } |
| 1319 | |
| 1320 | /** |
| 1321 | * Verifies that the Passpoint AccessPoint takes the ssid of the strongest scan result. |
| 1322 | */ |
| 1323 | @Test |
| 1324 | public void testPasspointAccessPoint_setsBestSsid() { |
| 1325 | WifiConfiguration spyConfig = spy(new WifiConfiguration()); |
| 1326 | when(spyConfig.isPasspoint()).thenReturn(true); |
| 1327 | |
| 1328 | String badSsid = "badSsid"; |
| 1329 | String goodSsid = "goodSsid"; |
| 1330 | String bestSsid = "bestSsid"; |
| 1331 | ScanResult badScanResult = createScanResult(badSsid, TEST_BSSID, -100); |
| 1332 | ScanResult goodScanResult = createScanResult(goodSsid, TEST_BSSID, -10); |
| 1333 | ScanResult bestScanResult = createScanResult(bestSsid, TEST_BSSID, -1); |
| 1334 | |
| 1335 | AccessPoint passpointAccessPoint = new AccessPoint(mContext, spyConfig, |
| 1336 | Arrays.asList(badScanResult, goodScanResult), null); |
| 1337 | assertThat(passpointAccessPoint.getConfig().SSID) |
| 1338 | .isEqualTo(AccessPoint.convertToQuotedString(goodSsid)); |
| 1339 | passpointAccessPoint.setScanResultsPasspoint( |
| 1340 | Arrays.asList(badScanResult, goodScanResult, bestScanResult), null); |
| 1341 | assertThat(passpointAccessPoint.getConfig().SSID) |
| 1342 | .isEqualTo(AccessPoint.convertToQuotedString(bestSsid)); |
| 1343 | } |
| 1344 | |
| 1345 | /** |
| 1346 | * Verifies that the OSU AccessPoint constructor creates AccessPoints whose isOsuProvider() |
| 1347 | * returns true. |
| 1348 | */ |
| 1349 | @Test |
| 1350 | public void testOsuAccessPointConstructor_createdAccessPointIsOsuProvider() { |
| 1351 | AccessPoint osuAccessPoint = new AccessPoint(mContext, createOsuProvider(), |
| 1352 | mScanResults); |
| 1353 | |
| 1354 | assertThat(osuAccessPoint.isOsuProvider()).isTrue(); |
| 1355 | } |
| 1356 | |
| 1357 | /** |
| 1358 | * Verifies that the summary of an OSU entry only shows the tap_to_sign_up string. |
| 1359 | */ |
| 1360 | @Test |
| 1361 | public void testOsuAccessPointSummary_showsTapToSignUp() { |
| 1362 | AccessPoint osuAccessPoint = new AccessPoint(mContext, createOsuProvider(), |
| 1363 | mScanResults); |
| 1364 | |
| 1365 | assertThat(osuAccessPoint.getSummary()) |
| 1366 | .isEqualTo(mContext.getString(R.string.tap_to_sign_up)); |
| 1367 | } |
| 1368 | |
Quang Luong | 7cfa527 | 2019-03-08 12:37:15 -0800 | [diff] [blame] | 1369 | /** |
| 1370 | * Verifies that the summary of an OSU entry updates based on provisioning status. |
| 1371 | */ |
Quang Luong | 8123f77 | 2019-02-08 16:30:12 -0800 | [diff] [blame] | 1372 | @Test |
| 1373 | public void testOsuAccessPointSummary_showsProvisioningUpdates() { |
| 1374 | AccessPoint osuAccessPoint = new AccessPoint(mContext, createOsuProvider(), |
| 1375 | mScanResults); |
| 1376 | |
| 1377 | osuAccessPoint.setListener(mMockAccessPointListener); |
| 1378 | |
| 1379 | AccessPoint.AccessPointProvisioningCallback provisioningCallback = |
| 1380 | osuAccessPoint.new AccessPointProvisioningCallback(); |
| 1381 | |
| 1382 | int[] openingProviderStatuses = { |
| 1383 | ProvisioningCallback.OSU_STATUS_AP_CONNECTING, |
| 1384 | ProvisioningCallback.OSU_STATUS_AP_CONNECTED, |
| 1385 | ProvisioningCallback.OSU_STATUS_SERVER_CONNECTING, |
| 1386 | ProvisioningCallback.OSU_STATUS_SERVER_VALIDATED, |
| 1387 | ProvisioningCallback.OSU_STATUS_SERVER_CONNECTED, |
| 1388 | ProvisioningCallback.OSU_STATUS_INIT_SOAP_EXCHANGE, |
| 1389 | ProvisioningCallback.OSU_STATUS_WAITING_FOR_REDIRECT_RESPONSE |
| 1390 | }; |
| 1391 | int[] completingSignUpStatuses = { |
| 1392 | ProvisioningCallback.OSU_STATUS_REDIRECT_RESPONSE_RECEIVED, |
| 1393 | ProvisioningCallback.OSU_STATUS_SECOND_SOAP_EXCHANGE, |
| 1394 | ProvisioningCallback.OSU_STATUS_THIRD_SOAP_EXCHANGE, |
| 1395 | ProvisioningCallback.OSU_STATUS_RETRIEVING_TRUST_ROOT_CERTS, |
| 1396 | }; |
| 1397 | |
| 1398 | for (int status : openingProviderStatuses) { |
| 1399 | provisioningCallback.onProvisioningStatus(status); |
| 1400 | assertThat(osuAccessPoint.getSummary()) |
| 1401 | .isEqualTo(String.format(mContext.getString(R.string.osu_opening_provider), |
| 1402 | OSU_FRIENDLY_NAME)); |
| 1403 | } |
| 1404 | |
| 1405 | provisioningCallback.onProvisioningFailure(0); |
| 1406 | assertThat(osuAccessPoint.getSummary()) |
| 1407 | .isEqualTo(mContext.getString(R.string.osu_connect_failed)); |
| 1408 | |
| 1409 | for (int status : completingSignUpStatuses) { |
| 1410 | provisioningCallback.onProvisioningStatus(status); |
| 1411 | assertThat(osuAccessPoint.getSummary()) |
| 1412 | .isEqualTo(mContext.getString(R.string.osu_completing_sign_up)); |
| 1413 | } |
| 1414 | |
| 1415 | provisioningCallback.onProvisioningFailure(0); |
| 1416 | assertThat(osuAccessPoint.getSummary()) |
| 1417 | .isEqualTo(mContext.getString(R.string.osu_sign_up_failed)); |
| 1418 | |
| 1419 | provisioningCallback.onProvisioningComplete(); |
| 1420 | assertThat(osuAccessPoint.getSummary()) |
| 1421 | .isEqualTo(mContext.getString(R.string.osu_sign_up_complete)); |
| 1422 | } |
Quang Luong | 7cfa527 | 2019-03-08 12:37:15 -0800 | [diff] [blame] | 1423 | |
| 1424 | /** |
| 1425 | * Verifies that after provisioning through an OSU provider, we connect to the freshly |
| 1426 | * provisioned network. |
| 1427 | */ |
| 1428 | @Test |
| 1429 | public void testOsuAccessPoint_connectsAfterProvisioning() { |
| 1430 | // Set up mock for WifiManager.getAllMatchingWifiConfigs |
| 1431 | WifiConfiguration config = new WifiConfiguration(); |
| 1432 | config.FQDN = "fqdn"; |
| 1433 | Map<Integer, List<ScanResult>> scanMapping = new HashMap<>(); |
| 1434 | scanMapping.put(WifiManager.PASSPOINT_HOME_NETWORK, mScanResults); |
| 1435 | Pair<WifiConfiguration, Map<Integer, List<ScanResult>>> configMapPair = |
| 1436 | new Pair<>(config, scanMapping); |
| 1437 | List<Pair<WifiConfiguration, Map<Integer, List<ScanResult>>>> matchingWifiConfig = |
| 1438 | new ArrayList<>(); |
| 1439 | matchingWifiConfig.add(configMapPair); |
| 1440 | when(mMockWifiManager.getAllMatchingWifiConfigs(any())).thenReturn(matchingWifiConfig); |
| 1441 | |
| 1442 | // Set up mock for WifiManager.getMatchingPasspointConfigsForOsuProviders |
| 1443 | OsuProvider provider = createOsuProvider(); |
| 1444 | PasspointConfiguration passpointConfig = new PasspointConfiguration(); |
| 1445 | HomeSp homeSp = new HomeSp(); |
| 1446 | homeSp.setFqdn("fqdn"); |
| 1447 | homeSp.setFriendlyName("Test Provider"); |
| 1448 | passpointConfig.setHomeSp(homeSp); |
| 1449 | Map<OsuProvider, PasspointConfiguration> osuProviderConfigMap = new HashMap<>(); |
| 1450 | osuProviderConfigMap.put(provider, passpointConfig); |
| 1451 | when(mMockWifiManager |
| 1452 | .getMatchingPasspointConfigsForOsuProviders(Collections.singleton(provider))) |
| 1453 | .thenReturn(osuProviderConfigMap); |
| 1454 | |
| 1455 | when(mMockContext.getSystemService(Context.WIFI_SERVICE)).thenReturn(mMockWifiManager); |
| 1456 | |
| 1457 | AccessPoint osuAccessPoint = new AccessPoint(mMockContext, provider, mScanResults); |
| 1458 | osuAccessPoint.setListener(mMockAccessPointListener); |
| 1459 | |
| 1460 | AccessPoint.AccessPointProvisioningCallback provisioningCallback = |
| 1461 | osuAccessPoint.new AccessPointProvisioningCallback(); |
| 1462 | provisioningCallback.onProvisioningComplete(); |
| 1463 | |
| 1464 | verify(mMockWifiManager).connect(any(), any()); |
| 1465 | } |
| 1466 | |
| 1467 | /** |
| 1468 | * Verifies that after provisioning through an OSU provider, we call the connect listener's |
| 1469 | * onFailure() method if we cannot find the network we just provisioned. |
| 1470 | */ |
| 1471 | @Test |
| 1472 | public void testOsuAccessPoint_noMatchingConfigsAfterProvisioning_callsOnFailure() { |
| 1473 | // Set up mock for WifiManager.getAllMatchingWifiConfigs |
| 1474 | when(mMockWifiManager.getAllMatchingWifiConfigs(any())).thenReturn(new ArrayList<>()); |
| 1475 | |
| 1476 | // Set up mock for WifiManager.getMatchingPasspointConfigsForOsuProviders |
| 1477 | OsuProvider provider = createOsuProvider(); |
| 1478 | PasspointConfiguration passpointConfig = new PasspointConfiguration(); |
| 1479 | HomeSp homeSp = new HomeSp(); |
| 1480 | homeSp.setFqdn("fqdn"); |
| 1481 | homeSp.setFriendlyName("Test Provider"); |
| 1482 | passpointConfig.setHomeSp(homeSp); |
| 1483 | Map<OsuProvider, PasspointConfiguration> osuProviderConfigMap = new HashMap<>(); |
| 1484 | osuProviderConfigMap.put(provider, passpointConfig); |
| 1485 | when(mMockWifiManager |
| 1486 | .getMatchingPasspointConfigsForOsuProviders(Collections.singleton(provider))) |
| 1487 | .thenReturn(osuProviderConfigMap); |
| 1488 | |
| 1489 | when(mMockContext.getSystemService(Context.WIFI_SERVICE)).thenReturn(mMockWifiManager); |
| 1490 | |
| 1491 | AccessPoint osuAccessPoint = new AccessPoint(mMockContext, provider, mScanResults); |
| 1492 | osuAccessPoint.setListener(mMockAccessPointListener); |
| 1493 | osuAccessPoint.startOsuProvisioning(mMockConnectListener); |
| 1494 | |
| 1495 | AccessPoint.AccessPointProvisioningCallback provisioningCallback = |
| 1496 | osuAccessPoint.new AccessPointProvisioningCallback(); |
| 1497 | provisioningCallback.onProvisioningComplete(); |
| 1498 | |
| 1499 | verify(mMockConnectListener).onFailure(anyInt()); |
| 1500 | } |
Fan Zhang | eb83a0d | 2016-09-21 11:34:08 -0700 | [diff] [blame] | 1501 | } |