1 /* 2 * Copyright (C) 2020 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 17 package android.net 18 19 import android.app.usage.NetworkStatsManager.NETWORK_TYPE_5G_NSA 20 import android.content.Context 21 import android.net.ConnectivityManager.TYPE_MOBILE 22 import android.net.ConnectivityManager.TYPE_TEST 23 import android.net.ConnectivityManager.TYPE_WIFI 24 import android.net.NetworkCapabilities.TRANSPORT_TEST 25 import android.net.NetworkCapabilities.TRANSPORT_WIFI 26 import android.net.NetworkIdentity.OEM_NONE 27 import android.net.NetworkIdentity.OEM_PAID 28 import android.net.NetworkIdentity.OEM_PRIVATE 29 import android.net.NetworkIdentity.buildNetworkIdentity 30 import android.net.NetworkStats.DEFAULT_NETWORK_ALL 31 import android.net.NetworkStats.METERED_ALL 32 import android.net.NetworkStats.METERED_NO 33 import android.net.NetworkStats.METERED_YES 34 import android.net.NetworkStats.ROAMING_ALL 35 import android.net.NetworkTemplate.MATCH_CARRIER 36 import android.net.NetworkTemplate.MATCH_MOBILE 37 import android.net.NetworkTemplate.MATCH_TEST 38 import android.net.NetworkTemplate.MATCH_WIFI 39 import android.net.NetworkTemplate.NETWORK_TYPE_ALL 40 import android.net.NetworkTemplate.OEM_MANAGED_ALL 41 import android.net.NetworkTemplate.OEM_MANAGED_NO 42 import android.net.NetworkTemplate.OEM_MANAGED_YES 43 import android.net.NetworkTemplate.buildTemplateMobileAll 44 import android.net.NetworkTemplate.buildTemplateMobileWildcard 45 import android.net.NetworkTemplate.buildTemplateWifiWildcard 46 import android.net.NetworkTemplate.normalize 47 import android.net.wifi.WifiInfo 48 import android.os.Build 49 import android.telephony.TelephonyManager 50 import com.android.testutils.DevSdkIgnoreRule 51 import com.android.testutils.DevSdkIgnoreRunner 52 import com.android.testutils.assertParcelSane 53 import kotlin.test.assertEquals 54 import kotlin.test.assertFalse 55 import kotlin.test.assertNotEquals 56 import kotlin.test.assertTrue 57 import org.junit.Before 58 import org.junit.Rule 59 import org.junit.Test 60 import org.junit.runner.RunWith 61 import org.mockito.Mockito.mock 62 import org.mockito.Mockito.`when` 63 import org.mockito.MockitoAnnotations 64 65 private const val TEST_IMSI1 = "imsi1" 66 private const val TEST_IMSI2 = "imsi2" 67 private const val TEST_IMSI3 = "imsi3" 68 private const val TEST_WIFI_KEY1 = "wifiKey1" 69 private const val TEST_WIFI_KEY2 = "wifiKey2" 70 71 @RunWith(DevSdkIgnoreRunner::class) 72 @DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.S_V2) 73 class NetworkTemplateTest { 74 @get:Rule 75 val ignoreRule = DevSdkIgnoreRule() 76 private val mockContext = mock(Context::class.java) 77 private val mockWifiInfo = mock(WifiInfo::class.java) 78 buildMobileNetworkStatenull79 private fun buildMobileNetworkState(subscriberId: String): NetworkStateSnapshot = 80 buildNetworkState(TYPE_MOBILE, subscriberId = subscriberId) 81 private fun buildWifiNetworkState(subscriberId: String?, wifiKey: String?): 82 NetworkStateSnapshot = buildNetworkState(TYPE_WIFI, 83 subscriberId = subscriberId, wifiKey = wifiKey) 84 85 private fun buildNetworkState( 86 type: Int, 87 subscriberId: String? = null, 88 wifiKey: String? = null, 89 oemManaged: Int = OEM_NONE, 90 metered: Boolean = true 91 ): NetworkStateSnapshot { 92 `when`(mockWifiInfo.getNetworkKey()).thenReturn(wifiKey) 93 val lp = LinkProperties() 94 val caps = NetworkCapabilities().apply { 95 setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED, !metered) 96 setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING, true) 97 setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID, 98 (oemManaged and OEM_PAID) == OEM_PAID) 99 setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE, 100 (oemManaged and OEM_PRIVATE) == OEM_PRIVATE) 101 if (type == TYPE_TEST) { 102 wifiKey?.let { TestNetworkSpecifier(it) }?.let { 103 // Must have a single non-test transport specified to use setNetworkSpecifier. 104 // Put an arbitrary transport type which is not used in this test. 105 addTransportType(TRANSPORT_TEST) 106 addTransportType(TRANSPORT_WIFI) 107 setNetworkSpecifier(it) } 108 } 109 setTransportInfo(mockWifiInfo) 110 } 111 return NetworkStateSnapshot(mock(Network::class.java), caps, lp, subscriberId, type) 112 } 113 NetworkTemplatenull114 private fun NetworkTemplate.assertMatches(ident: NetworkIdentity) = 115 assertTrue(matches(ident), "$this does not match $ident") 116 117 private fun NetworkTemplate.assertDoesNotMatch(ident: NetworkIdentity) = 118 assertFalse(matches(ident), "$this should match $ident") 119 120 @Before 121 fun setup() { 122 MockitoAnnotations.initMocks(this) 123 } 124 125 @Test testWifiWildcardMatchesnull126 fun testWifiWildcardMatches() { 127 val templateWifiWildcard = buildTemplateWifiWildcard() 128 129 val identMobileImsi1 = buildNetworkIdentity(mockContext, 130 buildMobileNetworkState(TEST_IMSI1), 131 false, TelephonyManager.NETWORK_TYPE_UMTS) 132 val identWifiImsiNullKey1 = buildNetworkIdentity( 133 mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) 134 val identWifiImsi1Key1 = buildNetworkIdentity( 135 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 136 // This identity with a null wifiNetworkKey is to test matchesWifiNetworkKey won't crash 137 // the system when a null wifiNetworkKey is provided, which happens because of a bug in wifi 138 // and it should still match the wifi wildcard template. See b/266598304. 139 val identWifiNullKey = buildNetworkIdentity( 140 mockContext, buildWifiNetworkState(null /* subscriberId */, 141 null /* wifiNetworkKey */), true, 0) 142 143 templateWifiWildcard.assertDoesNotMatch(identMobileImsi1) 144 templateWifiWildcard.assertMatches(identWifiImsiNullKey1) 145 templateWifiWildcard.assertMatches(identWifiImsi1Key1) 146 templateWifiWildcard.assertMatches(identWifiNullKey) 147 } 148 149 @Test testWifiMatchesnull150 fun testWifiMatches() { 151 val templateWifiKey1 = NetworkTemplate.Builder(MATCH_WIFI) 152 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() 153 val templateWifiKey1ImsiNull = NetworkTemplate.Builder(MATCH_WIFI) 154 .setSubscriberIds(setOf(null)) 155 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() 156 val templateWifiKey1Imsi1 = NetworkTemplate.Builder(MATCH_WIFI) 157 .setSubscriberIds(setOf(TEST_IMSI1)) 158 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() 159 val templateWifiKeyAllImsi1 = NetworkTemplate.Builder(MATCH_WIFI) 160 .setSubscriberIds(setOf(TEST_IMSI1)).build() 161 val templateNullWifiKey = NetworkTemplate(MATCH_WIFI, 162 emptyArray<String>() /* subscriberIds */, arrayOf(null) /* wifiNetworkKeys */, 163 METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL) 164 165 val identMobile1 = buildNetworkIdentity(mockContext, buildMobileNetworkState(TEST_IMSI1), 166 false, TelephonyManager.NETWORK_TYPE_UMTS) 167 val identWifiImsiNullKey1 = buildNetworkIdentity( 168 mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) 169 val identWifiImsi1Key1 = buildNetworkIdentity( 170 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 171 val identWifiImsi2Key1 = buildNetworkIdentity( 172 mockContext, buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), true, 0) 173 val identWifiImsi1Key2 = buildNetworkIdentity( 174 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY2), true, 0) 175 // This identity with a null wifiNetworkKey is to test the matchesWifiNetworkKey won't crash 176 // the system when a null wifiNetworkKey is provided, which would happen in some unknown 177 // cases, see b/266598304. 178 val identWifiNullKey = buildNetworkIdentity( 179 mockContext, buildWifiNetworkState(null /* subscriberId */, 180 null /* wifiNetworkKey */), true, 0) 181 182 // Verify that template with WiFi Network Key only matches any subscriberId and 183 // specific WiFi Network Key. 184 templateWifiKey1.assertDoesNotMatch(identMobile1) 185 templateWifiKey1.assertMatches(identWifiImsiNullKey1) 186 templateWifiKey1.assertMatches(identWifiImsi1Key1) 187 templateWifiKey1.assertMatches(identWifiImsi2Key1) 188 templateWifiKey1.assertDoesNotMatch(identWifiImsi1Key2) 189 190 // Verify that template with WiFi Network Key1 and null imsi matches any network with 191 // WiFi Network Key1 and null imsi. 192 templateWifiKey1ImsiNull.assertDoesNotMatch(identMobile1) 193 templateWifiKey1ImsiNull.assertMatches(identWifiImsiNullKey1) 194 templateWifiKey1ImsiNull.assertDoesNotMatch(identWifiImsi1Key1) 195 templateWifiKey1ImsiNull.assertDoesNotMatch(identWifiImsi2Key1) 196 templateWifiKey1ImsiNull.assertDoesNotMatch(identWifiImsi1Key2) 197 198 // Verify that template with WiFi Network Key1 and imsi1 matches any network with 199 // WiFi Network Key1 and imsi1. 200 templateWifiKey1Imsi1.assertDoesNotMatch(identMobile1) 201 templateWifiKey1Imsi1.assertDoesNotMatch(identWifiImsiNullKey1) 202 templateWifiKey1Imsi1.assertMatches(identWifiImsi1Key1) 203 templateWifiKey1Imsi1.assertDoesNotMatch(identWifiImsi2Key1) 204 templateWifiKey1Imsi1.assertDoesNotMatch(identWifiImsi1Key2) 205 206 // Verify that template with WiFi Network Key all and imsi1 matches any network with 207 // any WiFi Network Key and imsi1. 208 templateWifiKeyAllImsi1.assertDoesNotMatch(identMobile1) 209 templateWifiKeyAllImsi1.assertDoesNotMatch(identWifiImsiNullKey1) 210 templateWifiKeyAllImsi1.assertMatches(identWifiImsi1Key1) 211 templateWifiKeyAllImsi1.assertDoesNotMatch(identWifiImsi2Key1) 212 templateWifiKeyAllImsi1.assertMatches(identWifiImsi1Key2) 213 214 // Test a network identity with null wifiNetworkKey won't crash. 215 // It should not match a template with wifiNetworkKeys is non-null. 216 // Also, it should not match a template with wifiNetworkKeys that contains null. 217 templateWifiKey1.assertDoesNotMatch(identWifiNullKey) 218 templateNullWifiKey.assertDoesNotMatch(identWifiNullKey) 219 } 220 221 @DevSdkIgnoreRule.IgnoreAfter(Build.VERSION_CODES.TIRAMISU) 222 @Test testBuildTemplateMobileAll_nullSubscriberIdnull223 fun testBuildTemplateMobileAll_nullSubscriberId() { 224 val templateMobileAllWithNullImsi = buildTemplateMobileAll(null) 225 val setWithNull = HashSet<String?>().apply { 226 add(null) 227 } 228 val templateFromBuilder = NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES) 229 .setSubscriberIds(setWithNull).build() 230 assertEquals(templateFromBuilder, templateMobileAllWithNullImsi) 231 } 232 233 @Test testMobileMatchesnull234 fun testMobileMatches() { 235 val templateMobileImsi1 = buildTemplateMobileAll(TEST_IMSI1) 236 val templateMobileImsi2WithRatType = NetworkTemplate.Builder(MATCH_MOBILE) 237 .setMeteredness(METERED_YES) 238 .setSubscriberIds(setOf(TEST_IMSI2)) 239 .setRatType(TelephonyManager.NETWORK_TYPE_UMTS).build() 240 241 val mobileImsi1 = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, null /* wifiKey */, 242 OEM_NONE, true /* metered */) 243 val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, 244 false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 245 val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) 246 val identMobile2Umts = buildNetworkIdentity(mockContext, mobileImsi2, 247 false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 248 249 val identWifiImsi1Key1 = buildNetworkIdentity( 250 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 251 252 // Verify that the template matches type and the subscriberId. 253 templateMobileImsi1.assertMatches(identMobile1) 254 templateMobileImsi2WithRatType.assertMatches(identMobile2Umts) 255 256 // Verify that the template does not match the different subscriberId. 257 templateMobileImsi1.assertDoesNotMatch(identMobile2Umts) 258 templateMobileImsi2WithRatType.assertDoesNotMatch(identMobile1) 259 260 // Verify that the different type does not match. 261 templateMobileImsi1.assertDoesNotMatch(identWifiImsi1Key1) 262 } 263 264 @Test testMobileWildcardMatchesnull265 fun testMobileWildcardMatches() { 266 val templateMobileWildcard = buildTemplateMobileWildcard() 267 val templateMobileNullImsiWithRatType = NetworkTemplate.Builder(MATCH_MOBILE) 268 .setRatType(TelephonyManager.NETWORK_TYPE_UMTS).build() 269 val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) 270 val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, 271 false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 272 val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) 273 val identMobile2 = buildNetworkIdentity(mockContext, mobileImsi2, 274 false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_LTE) 275 276 // Verify that the template matches any subscriberId. 277 templateMobileWildcard.assertMatches(identMobile1) 278 templateMobileNullImsiWithRatType.assertMatches(identMobile1) 279 templateMobileWildcard.assertMatches(identMobile2) 280 templateMobileNullImsiWithRatType.assertDoesNotMatch(identMobile2) 281 282 val identWifiImsi1Key1 = buildNetworkIdentity( 283 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 284 285 // Verify that the different type does not match. 286 templateMobileWildcard.assertDoesNotMatch(identWifiImsi1Key1) 287 templateMobileNullImsiWithRatType.assertDoesNotMatch(identWifiImsi1Key1) 288 } 289 290 @Test testTestNetworkTemplateMatchesnull291 fun testTestNetworkTemplateMatches() { 292 val templateTestKey1 = NetworkTemplate.Builder(MATCH_TEST) 293 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() 294 val templateTestKey2 = NetworkTemplate.Builder(MATCH_TEST) 295 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY2)).build() 296 val templateTestAll = NetworkTemplate.Builder(MATCH_TEST).build() 297 298 val stateWifiKey1 = buildNetworkState(TYPE_WIFI, null /* subscriberId */, TEST_WIFI_KEY1, 299 OEM_NONE, true /* metered */) 300 val stateTestKey1 = buildNetworkState(TYPE_TEST, null /* subscriberId */, TEST_WIFI_KEY1, 301 OEM_NONE, true /* metered */) 302 val identWifi1 = buildNetworkIdentity(mockContext, stateWifiKey1, 303 false /* defaultNetwork */, NetworkTemplate.NETWORK_TYPE_ALL) 304 val identTest1 = buildNetworkIdentity(mockContext, stateTestKey1, 305 false /* defaultNetwork */, NETWORK_TYPE_ALL) 306 307 // Verify that the template matches corresponding type and the subscriberId. 308 templateTestKey1.assertDoesNotMatch(identWifi1) 309 templateTestKey1.assertMatches(identTest1) 310 templateTestKey2.assertDoesNotMatch(identWifi1) 311 templateTestKey2.assertDoesNotMatch(identTest1) 312 templateTestAll.assertDoesNotMatch(identWifi1) 313 templateTestAll.assertMatches(identTest1) 314 } 315 316 @Test testCarrierMeteredMatchesnull317 fun testCarrierMeteredMatches() { 318 val templateCarrierImsi1Metered = NetworkTemplate.Builder(MATCH_CARRIER) 319 .setMeteredness(METERED_YES) 320 .setSubscriberIds(setOf(TEST_IMSI1)).build() 321 322 val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) 323 val mobileImsi1Unmetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, 324 null /* wifiKey */, OEM_NONE, false /* metered */) 325 val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) 326 val wifiKey1 = buildWifiNetworkState(null /* subscriberId */, 327 TEST_WIFI_KEY1) 328 val wifiImsi1Key1 = buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1) 329 val wifiImsi1Key1Unmetered = buildNetworkState(TYPE_WIFI, TEST_IMSI1, 330 TEST_WIFI_KEY1, OEM_NONE, false /* metered */) 331 332 val identMobileImsi1Metered = buildNetworkIdentity(mockContext, 333 mobileImsi1, false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 334 val identMobileImsi1Unmetered = buildNetworkIdentity(mockContext, 335 mobileImsi1Unmetered, false /* defaultNetwork */, 336 TelephonyManager.NETWORK_TYPE_UMTS) 337 val identMobileImsi2Metered = buildNetworkIdentity(mockContext, 338 mobileImsi2, false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 339 val identWifiKey1Metered = buildNetworkIdentity( 340 mockContext, wifiKey1, true /* defaultNetwork */, 0 /* subType */) 341 val identCarrierWifiImsi1Metered = buildNetworkIdentity( 342 mockContext, wifiImsi1Key1, true /* defaultNetwork */, 0 /* subType */) 343 val identCarrierWifiImsi1NonMetered = buildNetworkIdentity(mockContext, 344 wifiImsi1Key1Unmetered, true /* defaultNetwork */, 0 /* subType */) 345 346 templateCarrierImsi1Metered.assertMatches(identMobileImsi1Metered) 347 templateCarrierImsi1Metered.assertDoesNotMatch(identMobileImsi1Unmetered) 348 templateCarrierImsi1Metered.assertDoesNotMatch(identMobileImsi2Metered) 349 templateCarrierImsi1Metered.assertDoesNotMatch(identWifiKey1Metered) 350 templateCarrierImsi1Metered.assertMatches(identCarrierWifiImsi1Metered) 351 templateCarrierImsi1Metered.assertDoesNotMatch(identCarrierWifiImsi1NonMetered) 352 } 353 354 // TODO: Refactor this test to reduce the line of codes. 355 @Test testRatTypeGroupMatchesnull356 fun testRatTypeGroupMatches() { 357 val stateMobileImsi1Metered = buildMobileNetworkState(TEST_IMSI1) 358 val stateMobileImsi1NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, 359 null /* wifiKey */, OEM_NONE, false /* metered */) 360 val stateMobileImsi2NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI2, 361 null /* wifiKey */, OEM_NONE, false /* metered */) 362 363 // Build UMTS template that matches mobile identities with RAT in the same 364 // group with any IMSI. See {@link NetworkTemplate#getCollapsedRatType}. 365 val templateUmtsMetered = NetworkTemplate.Builder(MATCH_MOBILE) 366 .setMeteredness(METERED_YES) 367 .setRatType(TelephonyManager.NETWORK_TYPE_UMTS).build() 368 // Build normal template that matches mobile identities with any RAT and IMSI. 369 val templateAllMetered = NetworkTemplate.Builder(MATCH_MOBILE) 370 .setMeteredness(METERED_YES).build() 371 // Build template with UNKNOWN RAT that matches mobile identities with RAT that 372 // cannot be determined. 373 val templateUnknownMetered = NetworkTemplate.Builder(MATCH_MOBILE) 374 .setMeteredness(METERED_YES) 375 .setRatType(TelephonyManager.NETWORK_TYPE_UNKNOWN).build() 376 val templateUmtsNonMetered = NetworkTemplate.Builder(MATCH_MOBILE) 377 .setMeteredness(METERED_NO) 378 .setRatType(TelephonyManager.NETWORK_TYPE_UMTS).build() 379 val templateAllNonMetered = NetworkTemplate.Builder(MATCH_MOBILE) 380 .setMeteredness(METERED_NO).build() 381 val templateUnknownNonMetered = NetworkTemplate.Builder(MATCH_MOBILE) 382 .setMeteredness(METERED_NO) 383 .setRatType(TelephonyManager.NETWORK_TYPE_UNKNOWN).build() 384 385 val identUmtsMetered = buildNetworkIdentity( 386 mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_UMTS) 387 val identHsdpaMetered = buildNetworkIdentity( 388 mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_HSDPA) 389 val identLteMetered = buildNetworkIdentity( 390 mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_LTE) 391 val identCombinedMetered = buildNetworkIdentity( 392 mockContext, stateMobileImsi1Metered, false, NetworkTemplate.NETWORK_TYPE_ALL) 393 val identImsi2UmtsMetered = buildNetworkIdentity(mockContext, 394 buildMobileNetworkState(TEST_IMSI2), false, TelephonyManager.NETWORK_TYPE_UMTS) 395 val identWifi = buildNetworkIdentity( 396 mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) 397 398 val identUmtsNonMetered = buildNetworkIdentity( 399 mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) 400 val identHsdpaNonMetered = buildNetworkIdentity( 401 mockContext, stateMobileImsi1NonMetered, false, 402 TelephonyManager.NETWORK_TYPE_HSDPA) 403 val identLteNonMetered = buildNetworkIdentity( 404 mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_LTE) 405 val identCombinedNonMetered = buildNetworkIdentity( 406 mockContext, stateMobileImsi1NonMetered, false, NetworkTemplate.NETWORK_TYPE_ALL) 407 val identImsi2UmtsNonMetered = buildNetworkIdentity(mockContext, 408 stateMobileImsi2NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) 409 410 // Assert that identity with the same RAT and meteredness matches. 411 // Verify metered template. 412 templateUmtsMetered.assertMatches(identUmtsMetered) 413 templateAllMetered.assertMatches(identUmtsMetered) 414 templateUnknownMetered.assertDoesNotMatch(identUmtsMetered) 415 // Verify non-metered template. 416 templateUmtsNonMetered.assertMatches(identUmtsNonMetered) 417 templateAllNonMetered.assertMatches(identUmtsNonMetered) 418 templateUnknownNonMetered.assertDoesNotMatch(identUmtsNonMetered) 419 420 // Assert that identity with the same RAT but meteredness is different. 421 // Thus, it does not match. 422 templateUmtsNonMetered.assertDoesNotMatch(identUmtsMetered) 423 templateAllNonMetered.assertDoesNotMatch(identUmtsMetered) 424 425 // Assert that identity with the RAT within the same group matches. 426 // Verify metered template. 427 templateUmtsMetered.assertMatches(identHsdpaMetered) 428 templateAllMetered.assertMatches(identHsdpaMetered) 429 templateUnknownMetered.assertDoesNotMatch(identHsdpaMetered) 430 // Verify non-metered template. 431 templateUmtsNonMetered.assertMatches(identHsdpaNonMetered) 432 templateAllNonMetered.assertMatches(identHsdpaNonMetered) 433 templateUnknownNonMetered.assertDoesNotMatch(identHsdpaNonMetered) 434 435 // Assert that identity with the RAT out of the same group only matches template with 436 // NETWORK_TYPE_ALL. 437 // Verify metered template. 438 templateUmtsMetered.assertDoesNotMatch(identLteMetered) 439 templateAllMetered.assertMatches(identLteMetered) 440 templateUnknownMetered.assertDoesNotMatch(identLteMetered) 441 // Verify non-metered template. 442 templateUmtsNonMetered.assertDoesNotMatch(identLteNonMetered) 443 templateAllNonMetered.assertMatches(identLteNonMetered) 444 templateUnknownNonMetered.assertDoesNotMatch(identLteNonMetered) 445 // Verify non-metered template does not match identity with metered. 446 templateAllNonMetered.assertDoesNotMatch(identLteMetered) 447 448 // Assert that identity with combined RAT only matches with template with NETWORK_TYPE_ALL 449 // and NETWORK_TYPE_UNKNOWN. 450 // Verify metered template. 451 templateUmtsMetered.assertDoesNotMatch(identCombinedMetered) 452 templateAllMetered.assertMatches(identCombinedMetered) 453 templateUnknownMetered.assertMatches(identCombinedMetered) 454 // Verify non-metered template. 455 templateUmtsNonMetered.assertDoesNotMatch(identCombinedNonMetered) 456 templateAllNonMetered.assertMatches(identCombinedNonMetered) 457 templateUnknownNonMetered.assertMatches(identCombinedNonMetered) 458 // Verify that identity with metered does not match non-metered template. 459 templateAllNonMetered.assertDoesNotMatch(identCombinedMetered) 460 templateUnknownNonMetered.assertDoesNotMatch(identCombinedMetered) 461 462 // Assert that identity with different IMSI matches. 463 // Verify metered template. 464 templateUmtsMetered.assertMatches(identImsi2UmtsMetered) 465 templateAllMetered.assertMatches(identImsi2UmtsMetered) 466 templateUnknownMetered.assertDoesNotMatch(identImsi2UmtsMetered) 467 // Verify non-metered template. 468 templateUmtsNonMetered.assertMatches(identImsi2UmtsNonMetered) 469 templateAllNonMetered.assertMatches(identImsi2UmtsNonMetered) 470 templateUnknownNonMetered.assertDoesNotMatch(identImsi2UmtsNonMetered) 471 // Verify that the same RAT but different meteredness should not match. 472 templateUmtsNonMetered.assertDoesNotMatch(identImsi2UmtsMetered) 473 templateAllNonMetered.assertDoesNotMatch(identImsi2UmtsMetered) 474 475 // Assert that wifi identity does not match. 476 templateUmtsMetered.assertDoesNotMatch(identWifi) 477 templateUnknownMetered.assertDoesNotMatch(identWifi) 478 templateUmtsNonMetered.assertDoesNotMatch(identWifi) 479 templateUnknownNonMetered.assertDoesNotMatch(identWifi) 480 } 481 482 @Test testEqualsnull483 fun testEquals() { 484 val templateImsi1 = NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES) 485 .setSubscriberIds(setOf(TEST_IMSI1)).setRatType(TelephonyManager.NETWORK_TYPE_UMTS) 486 .build() 487 val dupTemplateImsi1 = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1), 488 emptyArray<String>(), METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL, 489 TelephonyManager.NETWORK_TYPE_UMTS, OEM_MANAGED_ALL) 490 val templateImsi2 = NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES) 491 .setSubscriberIds(setOf(TEST_IMSI2)).setRatType(TelephonyManager.NETWORK_TYPE_UMTS) 492 .build() 493 494 assertEquals(templateImsi1, dupTemplateImsi1) 495 assertEquals(dupTemplateImsi1, templateImsi1) 496 assertNotEquals(templateImsi1, templateImsi2) 497 498 val templateWifiKey1 = NetworkTemplate.Builder(MATCH_WIFI) 499 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() 500 val dupTemplateWifiKey1 = NetworkTemplate(MATCH_WIFI, emptyArray<String>(), 501 arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 502 NETWORK_TYPE_ALL, OEM_MANAGED_ALL) 503 val templateWifiKey2 = NetworkTemplate.Builder(MATCH_WIFI) 504 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY2)).build() 505 506 assertEquals(templateWifiKey1, dupTemplateWifiKey1) 507 assertEquals(dupTemplateWifiKey1, templateWifiKey1) 508 assertNotEquals(templateWifiKey1, templateWifiKey2) 509 } 510 511 @Test testParcelUnparcelnull512 fun testParcelUnparcel() { 513 val templateMobile = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1), 514 emptyArray<String>(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 515 TelephonyManager.NETWORK_TYPE_LTE, OEM_MANAGED_ALL) 516 val templateWifi = NetworkTemplate(MATCH_WIFI, emptyArray<String>(), 517 arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, 518 OEM_MANAGED_ALL) 519 val templateOem = NetworkTemplate(MATCH_MOBILE, emptyArray<String>(), 520 emptyArray<String>(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, 521 OEM_MANAGED_YES) 522 assertParcelSane(templateMobile, 8) 523 assertParcelSane(templateWifi, 8) 524 assertParcelSane(templateOem, 8) 525 } 526 527 // Verify NETWORK_TYPE_* constants in NetworkTemplate do not conflict with 528 // TelephonyManager#NETWORK_TYPE_* constants. 529 @Test testNetworkTypeConstantsnull530 fun testNetworkTypeConstants() { 531 for (ratType in TelephonyManager.getAllNetworkTypes()) { 532 assertNotEquals(NETWORK_TYPE_ALL, ratType) 533 assertNotEquals(NETWORK_TYPE_5G_NSA, ratType) 534 } 535 } 536 537 @Test testOemNetworkConstantsnull538 fun testOemNetworkConstants() { 539 val constantValues = arrayOf(OEM_MANAGED_YES, OEM_MANAGED_ALL, OEM_MANAGED_NO, 540 OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE) 541 542 // Verify that "not OEM managed network" constants are equal. 543 assertEquals(OEM_MANAGED_NO, OEM_NONE) 544 545 // Verify the constants don't conflict. 546 assertEquals(constantValues.size, constantValues.distinct().count()) 547 } 548 549 /** 550 * Helper to enumerate and assert OEM managed wifi and mobile {@code NetworkTemplate}s match 551 * their the appropriate OEM managed {@code NetworkIdentity}s. 552 * 553 * @param networkType {@code TYPE_MOBILE} or {@code TYPE_WIFI} 554 * @param matchType A match rule from {@code NetworkTemplate.MATCH_*} corresponding to the 555 * networkType. 556 * @param subscriberId To be populated with {@code TEST_IMSI*} only if networkType is 557 * {@code TYPE_MOBILE}. Note that {@code MATCH_MOBILE} with an empty subscriberId list 558 * will match any subscriber ID. 559 * @param templateWifiKey To be populated with {@code TEST_WIFI_KEY*} only if networkType is 560 * {@code TYPE_WIFI}. Note that {@code MATCH_WIFI} with both an empty subscriberId list 561 * and an empty wifiNetworkKey list will match any subscriber ID and/or any wifi network 562 * key. 563 * @param identWifiKey If networkType is {@code TYPE_WIFI}, this value must *NOT* be null. 564 * Provide one of {@code TEST_WIFI_KEY*}. 565 */ matchOemManagedIdentnull566 private fun matchOemManagedIdent( 567 networkType: Int, 568 matchType: Int, 569 subscriberId: String? = null, 570 templateWifiKey: String? = null, 571 identWifiKey: String? = null 572 ) { 573 val oemManagedStates = arrayOf(OEM_NONE, OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE) 574 val matchSubscriberIds = 575 if (subscriberId == null) emptyArray<String>() else arrayOf(subscriberId) 576 val matchWifiNetworkKeys = 577 if (templateWifiKey == null) emptyArray<String>() else arrayOf(templateWifiKey) 578 579 val templateOemYes = NetworkTemplate(matchType, matchSubscriberIds, 580 matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, 581 DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_YES) 582 val templateOemAll = NetworkTemplate(matchType, matchSubscriberIds, 583 matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, 584 DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL) 585 586 for (identityOemManagedState in oemManagedStates) { 587 val ident = buildNetworkIdentity(mockContext, buildNetworkState(networkType, 588 subscriberId, identWifiKey, identityOemManagedState), 589 /*defaultNetwork=*/false, /*subType=*/0) 590 591 // Create a template with each OEM managed type and match it against the NetworkIdentity 592 for (templateOemManagedState in oemManagedStates) { 593 val template = NetworkTemplate(matchType, matchSubscriberIds, 594 matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, 595 DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, templateOemManagedState) 596 if (identityOemManagedState == templateOemManagedState) { 597 template.assertMatches(ident) 598 } else { 599 template.assertDoesNotMatch(ident) 600 } 601 } 602 // OEM_MANAGED_ALL ignores OEM state. 603 templateOemAll.assertMatches(ident) 604 if (identityOemManagedState == OEM_NONE) { 605 // OEM_MANAGED_YES matches everything except OEM_NONE. 606 templateOemYes.assertDoesNotMatch(ident) 607 } else { 608 templateOemYes.assertMatches(ident) 609 } 610 } 611 } 612 613 @Test testOemManagedMatchesIdentnull614 fun testOemManagedMatchesIdent() { 615 matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE, subscriberId = TEST_IMSI1) 616 matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE) 617 matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, templateWifiKey = TEST_WIFI_KEY1, 618 identWifiKey = TEST_WIFI_KEY1) 619 matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, identWifiKey = TEST_WIFI_KEY1) 620 } 621 622 @Test testNormalizenull623 fun testNormalize() { 624 var mergedImsiList = arrayOf(TEST_IMSI1, TEST_IMSI2) 625 val identMobileImsi1 = buildNetworkIdentity(mockContext, 626 buildMobileNetworkState(TEST_IMSI1), false /* defaultNetwork */, 627 TelephonyManager.NETWORK_TYPE_UMTS) 628 val identMobileImsi2 = buildNetworkIdentity(mockContext, 629 buildMobileNetworkState(TEST_IMSI2), false /* defaultNetwork */, 630 TelephonyManager.NETWORK_TYPE_UMTS) 631 val identMobileImsi3 = buildNetworkIdentity(mockContext, 632 buildMobileNetworkState(TEST_IMSI3), false /* defaultNetwork */, 633 TelephonyManager.NETWORK_TYPE_UMTS) 634 val identWifiImsi1Key1 = buildNetworkIdentity( 635 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 636 val identWifiImsi2Key1 = buildNetworkIdentity( 637 mockContext, buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), true, 0) 638 val identWifiImsi3WifiKey1 = buildNetworkIdentity( 639 mockContext, buildWifiNetworkState(TEST_IMSI3, TEST_WIFI_KEY1), true, 0) 640 641 normalize(buildTemplateMobileAll(TEST_IMSI1), mergedImsiList).also { 642 it.assertMatches(identMobileImsi1) 643 it.assertMatches(identMobileImsi2) 644 it.assertDoesNotMatch(identMobileImsi3) 645 } 646 val templateCarrierImsi1 = NetworkTemplate.Builder(MATCH_CARRIER) 647 .setMeteredness(METERED_YES) 648 .setSubscriberIds(setOf(TEST_IMSI1)).build() 649 normalize(templateCarrierImsi1, mergedImsiList).also { 650 it.assertMatches(identMobileImsi1) 651 it.assertMatches(identMobileImsi2) 652 it.assertDoesNotMatch(identMobileImsi3) 653 } 654 val templateWifiKey1Imsi1 = NetworkTemplate.Builder(MATCH_WIFI) 655 .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)) 656 .setSubscriberIds(setOf(TEST_IMSI1)).build() 657 normalize(templateWifiKey1Imsi1, mergedImsiList).also { 658 it.assertMatches(identWifiImsi1Key1) 659 it.assertMatches(identWifiImsi2Key1) 660 it.assertDoesNotMatch(identWifiImsi3WifiKey1) 661 } 662 normalize(buildTemplateMobileWildcard(), mergedImsiList).also { 663 it.assertMatches(identMobileImsi1) 664 it.assertMatches(identMobileImsi2) 665 it.assertMatches(identMobileImsi3) 666 } 667 } 668 } 669