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_WIFI 23 import android.net.NetworkIdentity.OEM_NONE 24 import android.net.NetworkIdentity.OEM_PAID 25 import android.net.NetworkIdentity.OEM_PRIVATE 26 import android.net.NetworkIdentity.buildNetworkIdentity 27 import android.net.NetworkStats.DEFAULT_NETWORK_ALL 28 import android.net.NetworkStats.METERED_ALL 29 import android.net.NetworkStats.METERED_NO 30 import android.net.NetworkStats.METERED_YES 31 import android.net.NetworkStats.ROAMING_ALL 32 import android.net.NetworkTemplate.MATCH_MOBILE 33 import android.net.NetworkTemplate.MATCH_MOBILE_WILDCARD 34 import android.net.NetworkTemplate.MATCH_WIFI 35 import android.net.NetworkTemplate.MATCH_WIFI_WILDCARD 36 import android.net.NetworkTemplate.NETWORK_TYPE_ALL 37 import android.net.NetworkTemplate.OEM_MANAGED_ALL 38 import android.net.NetworkTemplate.OEM_MANAGED_NO 39 import android.net.NetworkTemplate.OEM_MANAGED_YES 40 import android.net.NetworkTemplate.WIFI_NETWORK_KEY_ALL 41 import android.net.NetworkTemplate.buildTemplateCarrierMetered 42 import android.net.NetworkTemplate.buildTemplateMobileAll 43 import android.net.NetworkTemplate.buildTemplateMobileWildcard 44 import android.net.NetworkTemplate.buildTemplateMobileWithRatType 45 import android.net.NetworkTemplate.buildTemplateWifi 46 import android.net.NetworkTemplate.buildTemplateWifiWildcard 47 import android.net.NetworkTemplate.normalize 48 import android.net.wifi.WifiInfo 49 import android.os.Build 50 import android.telephony.TelephonyManager 51 import com.android.net.module.util.NetworkStatsUtils.SUBSCRIBER_ID_MATCH_RULE_EXACT 52 import com.android.testutils.DevSdkIgnoreRule 53 import com.android.testutils.DevSdkIgnoreRunner 54 import com.android.testutils.assertParcelSane 55 import org.junit.Before 56 import org.junit.Test 57 import org.junit.runner.RunWith 58 import org.mockito.Mockito.mock 59 import org.mockito.Mockito.`when` 60 import org.mockito.MockitoAnnotations 61 import kotlin.test.assertEquals 62 import kotlin.test.assertFalse 63 import kotlin.test.assertNotEquals 64 import kotlin.test.assertTrue 65 66 private const val TEST_IMSI1 = "imsi1" 67 private const val TEST_IMSI2 = "imsi2" 68 private const val TEST_IMSI3 = "imsi3" 69 private const val TEST_WIFI_KEY1 = "wifiKey1" 70 private const val TEST_WIFI_KEY2 = "wifiKey2" 71 72 @RunWith(DevSdkIgnoreRunner::class) 73 @DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R) 74 class NetworkTemplateTest { 75 private val mockContext = mock(Context::class.java) 76 private val mockWifiInfo = mock(WifiInfo::class.java) 77 buildMobileNetworkStatenull78 private fun buildMobileNetworkState(subscriberId: String): NetworkStateSnapshot = 79 buildNetworkState(TYPE_MOBILE, subscriberId = subscriberId) 80 private fun buildWifiNetworkState(subscriberId: String?, wifiKey: String?): 81 NetworkStateSnapshot = buildNetworkState(TYPE_WIFI, 82 subscriberId = subscriberId, wifiKey = wifiKey) 83 84 private fun buildNetworkState( 85 type: Int, 86 subscriberId: String? = null, 87 wifiKey: String? = null, 88 oemManaged: Int = OEM_NONE, 89 metered: Boolean = true 90 ): NetworkStateSnapshot { 91 `when`(mockWifiInfo.getNetworkKey()).thenReturn(wifiKey) 92 val lp = LinkProperties() 93 val caps = NetworkCapabilities().apply { 94 setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED, !metered) 95 setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING, true) 96 setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID, 97 (oemManaged and OEM_PAID) == OEM_PAID) 98 setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE, 99 (oemManaged and OEM_PRIVATE) == OEM_PRIVATE) 100 setTransportInfo(mockWifiInfo) 101 } 102 return NetworkStateSnapshot(mock(Network::class.java), caps, lp, subscriberId, type) 103 } 104 NetworkTemplatenull105 private fun NetworkTemplate.assertMatches(ident: NetworkIdentity) = 106 assertTrue(matches(ident), "$this does not match $ident") 107 108 private fun NetworkTemplate.assertDoesNotMatch(ident: NetworkIdentity) = 109 assertFalse(matches(ident), "$this should match $ident") 110 111 @Before 112 fun setup() { 113 MockitoAnnotations.initMocks(this) 114 } 115 116 @Test testWifiWildcardMatchesnull117 fun testWifiWildcardMatches() { 118 val templateWifiWildcard = buildTemplateWifiWildcard() 119 120 val identMobileImsi1 = buildNetworkIdentity(mockContext, 121 buildMobileNetworkState(TEST_IMSI1), 122 false, TelephonyManager.NETWORK_TYPE_UMTS) 123 val identWifiImsiNullKey1 = buildNetworkIdentity( 124 mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) 125 val identWifiImsi1Key1 = buildNetworkIdentity( 126 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 127 128 templateWifiWildcard.assertDoesNotMatch(identMobileImsi1) 129 templateWifiWildcard.assertMatches(identWifiImsiNullKey1) 130 templateWifiWildcard.assertMatches(identWifiImsi1Key1) 131 } 132 133 @Test testWifiMatchesnull134 fun testWifiMatches() { 135 val templateWifiKey1 = buildTemplateWifi(TEST_WIFI_KEY1) 136 val templateWifiKey1ImsiNull = buildTemplateWifi(TEST_WIFI_KEY1, null) 137 val templateWifiKey1Imsi1 = buildTemplateWifi(TEST_WIFI_KEY1, TEST_IMSI1) 138 val templateWifiKeyAllImsi1 = buildTemplateWifi(WIFI_NETWORK_KEY_ALL, TEST_IMSI1) 139 140 val identMobile1 = buildNetworkIdentity(mockContext, buildMobileNetworkState(TEST_IMSI1), 141 false, TelephonyManager.NETWORK_TYPE_UMTS) 142 val identWifiImsiNullKey1 = buildNetworkIdentity( 143 mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) 144 val identWifiImsi1Key1 = buildNetworkIdentity( 145 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 146 val identWifiImsi2Key1 = buildNetworkIdentity( 147 mockContext, buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), true, 0) 148 val identWifiImsi1Key2 = buildNetworkIdentity( 149 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY2), true, 0) 150 151 // Verify that template with WiFi Network Key only matches any subscriberId and 152 // specific WiFi Network Key. 153 templateWifiKey1.assertDoesNotMatch(identMobile1) 154 templateWifiKey1.assertMatches(identWifiImsiNullKey1) 155 templateWifiKey1.assertMatches(identWifiImsi1Key1) 156 templateWifiKey1.assertMatches(identWifiImsi2Key1) 157 templateWifiKey1.assertDoesNotMatch(identWifiImsi1Key2) 158 159 // Verify that template with WiFi Network Key1 and null imsi matches any network with 160 // WiFi Network Key1 and null imsi. 161 templateWifiKey1ImsiNull.assertDoesNotMatch(identMobile1) 162 templateWifiKey1ImsiNull.assertMatches(identWifiImsiNullKey1) 163 templateWifiKey1ImsiNull.assertDoesNotMatch(identWifiImsi1Key1) 164 templateWifiKey1ImsiNull.assertDoesNotMatch(identWifiImsi2Key1) 165 templateWifiKey1ImsiNull.assertDoesNotMatch(identWifiImsi1Key2) 166 167 // Verify that template with WiFi Network Key1 and imsi1 matches any network with 168 // WiFi Network Key1 and imsi1. 169 templateWifiKey1Imsi1.assertDoesNotMatch(identMobile1) 170 templateWifiKey1Imsi1.assertDoesNotMatch(identWifiImsiNullKey1) 171 templateWifiKey1Imsi1.assertMatches(identWifiImsi1Key1) 172 templateWifiKey1Imsi1.assertDoesNotMatch(identWifiImsi2Key1) 173 templateWifiKey1Imsi1.assertDoesNotMatch(identWifiImsi1Key2) 174 175 // Verify that template with WiFi Network Key all and imsi1 matches any network with 176 // any WiFi Network Key and imsi1. 177 templateWifiKeyAllImsi1.assertDoesNotMatch(identMobile1) 178 templateWifiKeyAllImsi1.assertDoesNotMatch(identWifiImsiNullKey1) 179 templateWifiKeyAllImsi1.assertMatches(identWifiImsi1Key1) 180 templateWifiKeyAllImsi1.assertDoesNotMatch(identWifiImsi2Key1) 181 templateWifiKeyAllImsi1.assertMatches(identWifiImsi1Key2) 182 } 183 184 @Test testMobileMatchesnull185 fun testMobileMatches() { 186 val templateMobileImsi1 = buildTemplateMobileAll(TEST_IMSI1) 187 val templateMobileImsi2WithRatType = buildTemplateMobileWithRatType(TEST_IMSI2, 188 TelephonyManager.NETWORK_TYPE_UMTS, METERED_YES) 189 190 val mobileImsi1 = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, null /* wifiKey */, 191 OEM_NONE, true /* metered */) 192 val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, 193 false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 194 val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) 195 val identMobile2Umts = buildNetworkIdentity(mockContext, mobileImsi2, 196 false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 197 198 val identWifiImsi1Key1 = buildNetworkIdentity( 199 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 200 201 // Verify that the template matches type and the subscriberId. 202 templateMobileImsi1.assertMatches(identMobile1) 203 templateMobileImsi2WithRatType.assertMatches(identMobile2Umts) 204 205 // Verify that the template does not match the different subscriberId. 206 templateMobileImsi1.assertDoesNotMatch(identMobile2Umts) 207 templateMobileImsi2WithRatType.assertDoesNotMatch(identMobile1) 208 209 // Verify that the different type does not match. 210 templateMobileImsi1.assertDoesNotMatch(identWifiImsi1Key1) 211 } 212 213 @Test testMobileWildcardMatchesnull214 fun testMobileWildcardMatches() { 215 val templateMobileWildcard = buildTemplateMobileWildcard() 216 val templateMobileNullImsiWithRatType = buildTemplateMobileWithRatType(null, 217 TelephonyManager.NETWORK_TYPE_UMTS, METERED_ALL) 218 219 val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) 220 val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, 221 false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 222 223 // Verify that the template matches any subscriberId. 224 templateMobileWildcard.assertMatches(identMobile1) 225 templateMobileNullImsiWithRatType.assertMatches(identMobile1) 226 227 val identWifiImsi1Key1 = buildNetworkIdentity( 228 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 229 230 // Verify that the different type does not match. 231 templateMobileWildcard.assertDoesNotMatch(identWifiImsi1Key1) 232 templateMobileNullImsiWithRatType.assertDoesNotMatch(identWifiImsi1Key1) 233 } 234 235 @Test testCarrierMeteredMatchesnull236 fun testCarrierMeteredMatches() { 237 val templateCarrierImsi1Metered = buildTemplateCarrierMetered(TEST_IMSI1) 238 239 val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) 240 val mobileImsi1Unmetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, 241 null /* wifiKey */, OEM_NONE, false /* metered */) 242 val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) 243 val wifiKey1 = buildWifiNetworkState(null /* subscriberId */, 244 TEST_WIFI_KEY1) 245 val wifiImsi1Key1 = buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1) 246 val wifiImsi1Key1Unmetered = buildNetworkState(TYPE_WIFI, TEST_IMSI1, 247 TEST_WIFI_KEY1, OEM_NONE, false /* metered */) 248 249 val identMobileImsi1Metered = buildNetworkIdentity(mockContext, 250 mobileImsi1, false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 251 val identMobileImsi1Unmetered = buildNetworkIdentity(mockContext, 252 mobileImsi1Unmetered, false /* defaultNetwork */, 253 TelephonyManager.NETWORK_TYPE_UMTS) 254 val identMobileImsi2Metered = buildNetworkIdentity(mockContext, 255 mobileImsi2, false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) 256 val identWifiKey1Metered = buildNetworkIdentity( 257 mockContext, wifiKey1, true /* defaultNetwork */, 0 /* subType */) 258 val identCarrierWifiImsi1Metered = buildNetworkIdentity( 259 mockContext, wifiImsi1Key1, true /* defaultNetwork */, 0 /* subType */) 260 val identCarrierWifiImsi1NonMetered = buildNetworkIdentity(mockContext, 261 wifiImsi1Key1Unmetered, true /* defaultNetwork */, 0 /* subType */) 262 263 templateCarrierImsi1Metered.assertMatches(identMobileImsi1Metered) 264 templateCarrierImsi1Metered.assertDoesNotMatch(identMobileImsi1Unmetered) 265 templateCarrierImsi1Metered.assertDoesNotMatch(identMobileImsi2Metered) 266 templateCarrierImsi1Metered.assertDoesNotMatch(identWifiKey1Metered) 267 templateCarrierImsi1Metered.assertMatches(identCarrierWifiImsi1Metered) 268 templateCarrierImsi1Metered.assertDoesNotMatch(identCarrierWifiImsi1NonMetered) 269 } 270 271 // TODO: Refactor this test to reduce the line of codes. 272 @Test testRatTypeGroupMatchesnull273 fun testRatTypeGroupMatches() { 274 val stateMobileImsi1Metered = buildMobileNetworkState(TEST_IMSI1) 275 val stateMobileImsi1NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, 276 null /* wifiKey */, OEM_NONE, false /* metered */) 277 val stateMobileImsi2NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI2, 278 null /* wifiKey */, OEM_NONE, false /* metered */) 279 280 // Build UMTS template that matches mobile identities with RAT in the same 281 // group with any IMSI. See {@link NetworkTemplate#getCollapsedRatType}. 282 val templateUmtsMetered = buildTemplateMobileWithRatType(null, 283 TelephonyManager.NETWORK_TYPE_UMTS, METERED_YES) 284 // Build normal template that matches mobile identities with any RAT and IMSI. 285 val templateAllMetered = buildTemplateMobileWithRatType(null, NETWORK_TYPE_ALL, 286 METERED_YES) 287 // Build template with UNKNOWN RAT that matches mobile identities with RAT that 288 // cannot be determined. 289 val templateUnknownMetered = 290 buildTemplateMobileWithRatType(null, TelephonyManager.NETWORK_TYPE_UNKNOWN, 291 METERED_YES) 292 293 val templateUmtsNonMetered = buildTemplateMobileWithRatType(null, 294 TelephonyManager.NETWORK_TYPE_UMTS, METERED_NO) 295 val templateAllNonMetered = buildTemplateMobileWithRatType(null, NETWORK_TYPE_ALL, 296 METERED_NO) 297 val templateUnknownNonMetered = 298 buildTemplateMobileWithRatType(null, TelephonyManager.NETWORK_TYPE_UNKNOWN, 299 METERED_NO) 300 301 val identUmtsMetered = buildNetworkIdentity( 302 mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_UMTS) 303 val identHsdpaMetered = buildNetworkIdentity( 304 mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_HSDPA) 305 val identLteMetered = buildNetworkIdentity( 306 mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_LTE) 307 val identCombinedMetered = buildNetworkIdentity( 308 mockContext, stateMobileImsi1Metered, false, NetworkTemplate.NETWORK_TYPE_ALL) 309 val identImsi2UmtsMetered = buildNetworkIdentity(mockContext, 310 buildMobileNetworkState(TEST_IMSI2), false, TelephonyManager.NETWORK_TYPE_UMTS) 311 val identWifi = buildNetworkIdentity( 312 mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) 313 314 val identUmtsNonMetered = buildNetworkIdentity( 315 mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) 316 val identHsdpaNonMetered = buildNetworkIdentity( 317 mockContext, stateMobileImsi1NonMetered, false, 318 TelephonyManager.NETWORK_TYPE_HSDPA) 319 val identLteNonMetered = buildNetworkIdentity( 320 mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_LTE) 321 val identCombinedNonMetered = buildNetworkIdentity( 322 mockContext, stateMobileImsi1NonMetered, false, NetworkTemplate.NETWORK_TYPE_ALL) 323 val identImsi2UmtsNonMetered = buildNetworkIdentity(mockContext, 324 stateMobileImsi2NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) 325 326 // Assert that identity with the same RAT and meteredness matches. 327 // Verify metered template. 328 templateUmtsMetered.assertMatches(identUmtsMetered) 329 templateAllMetered.assertMatches(identUmtsMetered) 330 templateUnknownMetered.assertDoesNotMatch(identUmtsMetered) 331 // Verify non-metered template. 332 templateUmtsNonMetered.assertMatches(identUmtsNonMetered) 333 templateAllNonMetered.assertMatches(identUmtsNonMetered) 334 templateUnknownNonMetered.assertDoesNotMatch(identUmtsNonMetered) 335 336 // Assert that identity with the same RAT but meteredness is different. 337 // Thus, it does not match. 338 templateUmtsNonMetered.assertDoesNotMatch(identUmtsMetered) 339 templateAllNonMetered.assertDoesNotMatch(identUmtsMetered) 340 341 // Assert that identity with the RAT within the same group matches. 342 // Verify metered template. 343 templateUmtsMetered.assertMatches(identHsdpaMetered) 344 templateAllMetered.assertMatches(identHsdpaMetered) 345 templateUnknownMetered.assertDoesNotMatch(identHsdpaMetered) 346 // Verify non-metered template. 347 templateUmtsNonMetered.assertMatches(identHsdpaNonMetered) 348 templateAllNonMetered.assertMatches(identHsdpaNonMetered) 349 templateUnknownNonMetered.assertDoesNotMatch(identHsdpaNonMetered) 350 351 // Assert that identity with the RAT out of the same group only matches template with 352 // NETWORK_TYPE_ALL. 353 // Verify metered template. 354 templateUmtsMetered.assertDoesNotMatch(identLteMetered) 355 templateAllMetered.assertMatches(identLteMetered) 356 templateUnknownMetered.assertDoesNotMatch(identLteMetered) 357 // Verify non-metered template. 358 templateUmtsNonMetered.assertDoesNotMatch(identLteNonMetered) 359 templateAllNonMetered.assertMatches(identLteNonMetered) 360 templateUnknownNonMetered.assertDoesNotMatch(identLteNonMetered) 361 // Verify non-metered template does not match identity with metered. 362 templateAllNonMetered.assertDoesNotMatch(identLteMetered) 363 364 // Assert that identity with combined RAT only matches with template with NETWORK_TYPE_ALL 365 // and NETWORK_TYPE_UNKNOWN. 366 // Verify metered template. 367 templateUmtsMetered.assertDoesNotMatch(identCombinedMetered) 368 templateAllMetered.assertMatches(identCombinedMetered) 369 templateUnknownMetered.assertMatches(identCombinedMetered) 370 // Verify non-metered template. 371 templateUmtsNonMetered.assertDoesNotMatch(identCombinedNonMetered) 372 templateAllNonMetered.assertMatches(identCombinedNonMetered) 373 templateUnknownNonMetered.assertMatches(identCombinedNonMetered) 374 // Verify that identity with metered does not match non-metered template. 375 templateAllNonMetered.assertDoesNotMatch(identCombinedMetered) 376 templateUnknownNonMetered.assertDoesNotMatch(identCombinedMetered) 377 378 // Assert that identity with different IMSI matches. 379 // Verify metered template. 380 templateUmtsMetered.assertMatches(identImsi2UmtsMetered) 381 templateAllMetered.assertMatches(identImsi2UmtsMetered) 382 templateUnknownMetered.assertDoesNotMatch(identImsi2UmtsMetered) 383 // Verify non-metered template. 384 templateUmtsNonMetered.assertMatches(identImsi2UmtsNonMetered) 385 templateAllNonMetered.assertMatches(identImsi2UmtsNonMetered) 386 templateUnknownNonMetered.assertDoesNotMatch(identImsi2UmtsNonMetered) 387 // Verify that the same RAT but different meteredness should not match. 388 templateUmtsNonMetered.assertDoesNotMatch(identImsi2UmtsMetered) 389 templateAllNonMetered.assertDoesNotMatch(identImsi2UmtsMetered) 390 391 // Assert that wifi identity does not match. 392 templateUmtsMetered.assertDoesNotMatch(identWifi) 393 templateUnknownMetered.assertDoesNotMatch(identWifi) 394 templateUmtsNonMetered.assertDoesNotMatch(identWifi) 395 templateUnknownNonMetered.assertDoesNotMatch(identWifi) 396 } 397 398 @Test testParcelUnparcelnull399 fun testParcelUnparcel() { 400 val templateMobile = NetworkTemplate(MATCH_MOBILE, TEST_IMSI1, null, 401 arrayOf<String>(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 402 TelephonyManager.NETWORK_TYPE_LTE, OEM_MANAGED_ALL, 403 SUBSCRIBER_ID_MATCH_RULE_EXACT) 404 val templateWifi = NetworkTemplate(MATCH_WIFI, null, null, 405 arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, 406 OEM_MANAGED_ALL, SUBSCRIBER_ID_MATCH_RULE_EXACT) 407 val templateOem = NetworkTemplate(MATCH_MOBILE, null, null, 408 arrayOf<String>(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, 409 OEM_MANAGED_YES, SUBSCRIBER_ID_MATCH_RULE_EXACT) 410 assertParcelSane(templateMobile, 10) 411 assertParcelSane(templateWifi, 10) 412 assertParcelSane(templateOem, 10) 413 } 414 415 // Verify NETWORK_TYPE_* constants in NetworkTemplate do not conflict with 416 // TelephonyManager#NETWORK_TYPE_* constants. 417 @Test testNetworkTypeConstantsnull418 fun testNetworkTypeConstants() { 419 for (ratType in TelephonyManager.getAllNetworkTypes()) { 420 assertNotEquals(NETWORK_TYPE_ALL, ratType) 421 assertNotEquals(NETWORK_TYPE_5G_NSA, ratType) 422 } 423 } 424 425 @Test testOemNetworkConstantsnull426 fun testOemNetworkConstants() { 427 val constantValues = arrayOf(OEM_MANAGED_YES, OEM_MANAGED_ALL, OEM_MANAGED_NO, 428 OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE) 429 430 // Verify that "not OEM managed network" constants are equal. 431 assertEquals(OEM_MANAGED_NO, OEM_NONE) 432 433 // Verify the constants don't conflict. 434 assertEquals(constantValues.size, constantValues.distinct().count()) 435 } 436 437 /** 438 * Helper to enumerate and assert OEM managed wifi and mobile {@code NetworkTemplate}s match 439 * their the appropriate OEM managed {@code NetworkIdentity}s. 440 * 441 * @param networkType {@code TYPE_MOBILE} or {@code TYPE_WIFI} 442 * @param matchType A match rule from {@code NetworkTemplate.MATCH_*} corresponding to the 443 * networkType. 444 * @param subscriberId To be populated with {@code TEST_IMSI*} only if networkType is 445 * {@code TYPE_MOBILE}. May be left as null when matchType is 446 * {@link NetworkTemplate.MATCH_MOBILE_WILDCARD}. 447 * @param templateWifiKey Top be populated with {@code TEST_WIFI_KEY*} only if networkType is 448 * {@code TYPE_WIFI}. May be left as null when matchType is 449 * {@link NetworkTemplate.MATCH_WIFI_WILDCARD}. 450 * @param identWifiKey If networkType is {@code TYPE_WIFI}, this value must *NOT* be null. Provide 451 * one of {@code TEST_WIFI_KEY*}. 452 */ matchOemManagedIdentnull453 private fun matchOemManagedIdent( 454 networkType: Int, 455 matchType: Int, 456 subscriberId: String? = null, 457 templateWifiKey: String? = null, 458 identWifiKey: String? = null 459 ) { 460 val oemManagedStates = arrayOf(OEM_NONE, OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE) 461 val matchSubscriberIds = arrayOf(subscriberId) 462 val matchWifiNetworkKeys = arrayOf(templateWifiKey) 463 464 val templateOemYes = NetworkTemplate(matchType, subscriberId, matchSubscriberIds, 465 matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, 466 DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_YES, 467 SUBSCRIBER_ID_MATCH_RULE_EXACT) 468 val templateOemAll = NetworkTemplate(matchType, subscriberId, matchSubscriberIds, 469 matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, 470 DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL, 471 SUBSCRIBER_ID_MATCH_RULE_EXACT) 472 473 for (identityOemManagedState in oemManagedStates) { 474 val ident = buildNetworkIdentity(mockContext, buildNetworkState(networkType, 475 subscriberId, identWifiKey, identityOemManagedState), 476 /*defaultNetwork=*/false, /*subType=*/0) 477 478 // Create a template with each OEM managed type and match it against the NetworkIdentity 479 for (templateOemManagedState in oemManagedStates) { 480 val template = NetworkTemplate(matchType, subscriberId, matchSubscriberIds, 481 matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, 482 DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, templateOemManagedState, 483 SUBSCRIBER_ID_MATCH_RULE_EXACT) 484 if (identityOemManagedState == templateOemManagedState) { 485 template.assertMatches(ident) 486 } else { 487 template.assertDoesNotMatch(ident) 488 } 489 } 490 // OEM_MANAGED_ALL ignores OEM state. 491 templateOemAll.assertMatches(ident) 492 if (identityOemManagedState == OEM_NONE) { 493 // OEM_MANAGED_YES matches everything except OEM_NONE. 494 templateOemYes.assertDoesNotMatch(ident) 495 } else { 496 templateOemYes.assertMatches(ident) 497 } 498 } 499 } 500 501 @Test testOemManagedMatchesIdentnull502 fun testOemManagedMatchesIdent() { 503 matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE, subscriberId = TEST_IMSI1) 504 matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE_WILDCARD) 505 matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, templateWifiKey = TEST_WIFI_KEY1, 506 identWifiKey = TEST_WIFI_KEY1) 507 matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI_WILDCARD, 508 identWifiKey = TEST_WIFI_KEY1) 509 } 510 511 @Test testNormalizenull512 fun testNormalize() { 513 var mergedImsiList = listOf(arrayOf(TEST_IMSI1, TEST_IMSI2)) 514 val identMobileImsi1 = buildNetworkIdentity(mockContext, 515 buildMobileNetworkState(TEST_IMSI1), false /* defaultNetwork */, 516 TelephonyManager.NETWORK_TYPE_UMTS) 517 val identMobileImsi2 = buildNetworkIdentity(mockContext, 518 buildMobileNetworkState(TEST_IMSI2), false /* defaultNetwork */, 519 TelephonyManager.NETWORK_TYPE_UMTS) 520 val identMobileImsi3 = buildNetworkIdentity(mockContext, 521 buildMobileNetworkState(TEST_IMSI3), false /* defaultNetwork */, 522 TelephonyManager.NETWORK_TYPE_UMTS) 523 val identWifiImsi1Key1 = buildNetworkIdentity( 524 mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) 525 val identWifiImsi2Key1 = buildNetworkIdentity( 526 mockContext, buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), true, 0) 527 val identWifiImsi3WifiKey1 = buildNetworkIdentity( 528 mockContext, buildWifiNetworkState(TEST_IMSI3, TEST_WIFI_KEY1), true, 0) 529 530 normalize(buildTemplateMobileAll(TEST_IMSI1), mergedImsiList).also { 531 it.assertMatches(identMobileImsi1) 532 it.assertMatches(identMobileImsi2) 533 it.assertDoesNotMatch(identMobileImsi3) 534 } 535 normalize(buildTemplateCarrierMetered(TEST_IMSI1), mergedImsiList).also { 536 it.assertMatches(identMobileImsi1) 537 it.assertMatches(identMobileImsi2) 538 it.assertDoesNotMatch(identMobileImsi3) 539 } 540 normalize(buildTemplateWifi(TEST_WIFI_KEY1, TEST_IMSI1), mergedImsiList).also { 541 it.assertMatches(identWifiImsi1Key1) 542 it.assertMatches(identWifiImsi2Key1) 543 it.assertDoesNotMatch(identWifiImsi3WifiKey1) 544 } 545 normalize(buildTemplateMobileWildcard(), mergedImsiList).also { 546 it.assertMatches(identMobileImsi1) 547 it.assertMatches(identMobileImsi2) 548 it.assertMatches(identMobileImsi3) 549 } 550 } 551 } 552