| /* |
| * Copyright (C) 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.net |
| |
| import android.content.Context |
| import android.net.ConnectivityManager.TYPE_MOBILE |
| import android.net.ConnectivityManager.TYPE_WIFI |
| import android.net.NetworkIdentity.OEM_NONE |
| import android.net.NetworkIdentity.OEM_PAID |
| import android.net.NetworkIdentity.OEM_PRIVATE |
| import android.net.NetworkIdentity.SUBTYPE_COMBINED |
| import android.net.NetworkIdentity.buildNetworkIdentity |
| import android.net.NetworkStats.DEFAULT_NETWORK_ALL |
| import android.net.NetworkStats.METERED_ALL |
| import android.net.NetworkStats.METERED_NO |
| import android.net.NetworkStats.METERED_YES |
| import android.net.NetworkStats.ROAMING_ALL |
| import android.net.NetworkTemplate.MATCH_MOBILE |
| import android.net.NetworkTemplate.MATCH_MOBILE_WILDCARD |
| import android.net.NetworkTemplate.MATCH_WIFI |
| import android.net.NetworkTemplate.MATCH_WIFI_WILDCARD |
| import android.net.NetworkTemplate.NETWORK_TYPE_5G_NSA |
| import android.net.NetworkTemplate.NETWORK_TYPE_ALL |
| import android.net.NetworkTemplate.OEM_MANAGED_ALL |
| import android.net.NetworkTemplate.OEM_MANAGED_NO |
| import android.net.NetworkTemplate.OEM_MANAGED_YES |
| import android.net.NetworkTemplate.SUBSCRIBER_ID_MATCH_RULE_EXACT |
| import android.net.NetworkTemplate.WIFI_NETWORKID_ALL |
| import android.net.NetworkTemplate.buildTemplateCarrierMetered |
| import android.net.NetworkTemplate.buildTemplateMobileAll |
| import android.net.NetworkTemplate.buildTemplateMobileWildcard |
| import android.net.NetworkTemplate.buildTemplateMobileWithRatType |
| import android.net.NetworkTemplate.buildTemplateWifi |
| import android.net.NetworkTemplate.buildTemplateWifiWildcard |
| import android.os.Build |
| import android.telephony.TelephonyManager |
| import com.android.testutils.DevSdkIgnoreRule |
| import com.android.testutils.DevSdkIgnoreRunner |
| import com.android.testutils.assertParcelSane |
| import org.junit.Before |
| import org.junit.Test |
| import org.junit.runner.RunWith |
| import org.mockito.Mockito.mock |
| import org.mockito.MockitoAnnotations |
| import kotlin.test.assertEquals |
| import kotlin.test.assertFalse |
| import kotlin.test.assertNotEquals |
| import kotlin.test.assertTrue |
| |
| private const val TEST_IMSI1 = "imsi1" |
| private const val TEST_IMSI2 = "imsi2" |
| private const val TEST_SSID1 = "ssid1" |
| private const val TEST_SSID2 = "ssid2" |
| |
| @RunWith(DevSdkIgnoreRunner::class) |
| @DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R) |
| class NetworkTemplateTest { |
| private val mockContext = mock(Context::class.java) |
| |
| private fun buildMobileNetworkState(subscriberId: String): NetworkStateSnapshot = |
| buildNetworkState(TYPE_MOBILE, subscriberId = subscriberId) |
| private fun buildWifiNetworkState(subscriberId: String?, ssid: String?): NetworkStateSnapshot = |
| buildNetworkState(TYPE_WIFI, subscriberId = subscriberId, ssid = ssid) |
| |
| private fun buildNetworkState( |
| type: Int, |
| subscriberId: String? = null, |
| ssid: String? = null, |
| oemManaged: Int = OEM_NONE, |
| metered: Boolean = true |
| ): NetworkStateSnapshot { |
| val lp = LinkProperties() |
| val caps = NetworkCapabilities().apply { |
| setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED, !metered) |
| setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING, true) |
| setSSID(ssid) |
| setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID, |
| (oemManaged and OEM_PAID) == OEM_PAID) |
| setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE, |
| (oemManaged and OEM_PRIVATE) == OEM_PRIVATE) |
| } |
| return NetworkStateSnapshot(mock(Network::class.java), caps, lp, subscriberId, type) |
| } |
| |
| private fun NetworkTemplate.assertMatches(ident: NetworkIdentity) = |
| assertTrue(matches(ident), "$this does not match $ident") |
| |
| private fun NetworkTemplate.assertDoesNotMatch(ident: NetworkIdentity) = |
| assertFalse(matches(ident), "$this should match $ident") |
| |
| @Before |
| fun setup() { |
| MockitoAnnotations.initMocks(this) |
| } |
| |
| @Test |
| fun testWifiWildcardMatches() { |
| val templateWifiWildcard = buildTemplateWifiWildcard() |
| |
| val identMobileImsi1 = buildNetworkIdentity(mockContext, |
| buildMobileNetworkState(TEST_IMSI1), |
| false, TelephonyManager.NETWORK_TYPE_UMTS) |
| val identWifiImsiNullSsid1 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(null, TEST_SSID1), true, 0) |
| val identWifiImsi1Ssid1 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_SSID1), true, 0) |
| |
| templateWifiWildcard.assertDoesNotMatch(identMobileImsi1) |
| templateWifiWildcard.assertMatches(identWifiImsiNullSsid1) |
| templateWifiWildcard.assertMatches(identWifiImsi1Ssid1) |
| } |
| |
| @Test |
| fun testWifiMatches() { |
| val templateWifiSsid1 = buildTemplateWifi(TEST_SSID1) |
| val templateWifiSsid1ImsiNull = buildTemplateWifi(TEST_SSID1, null) |
| val templateWifiSsid1Imsi1 = buildTemplateWifi(TEST_SSID1, TEST_IMSI1) |
| val templateWifiSsidAllImsi1 = buildTemplateWifi(WIFI_NETWORKID_ALL, TEST_IMSI1) |
| |
| val identMobile1 = buildNetworkIdentity(mockContext, buildMobileNetworkState(TEST_IMSI1), |
| false, TelephonyManager.NETWORK_TYPE_UMTS) |
| val identWifiImsiNullSsid1 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(null, TEST_SSID1), true, 0) |
| val identWifiImsi1Ssid1 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_SSID1), true, 0) |
| val identWifiImsi2Ssid1 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(TEST_IMSI2, TEST_SSID1), true, 0) |
| val identWifiImsi1Ssid2 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_SSID2), true, 0) |
| |
| // Verify that template with SSID only matches any subscriberId and specific SSID. |
| templateWifiSsid1.assertDoesNotMatch(identMobile1) |
| templateWifiSsid1.assertMatches(identWifiImsiNullSsid1) |
| templateWifiSsid1.assertMatches(identWifiImsi1Ssid1) |
| templateWifiSsid1.assertMatches(identWifiImsi2Ssid1) |
| templateWifiSsid1.assertDoesNotMatch(identWifiImsi1Ssid2) |
| |
| // Verify that template with SSID1 and null imsi matches any network with |
| // SSID1 and null imsi. |
| templateWifiSsid1ImsiNull.assertDoesNotMatch(identMobile1) |
| templateWifiSsid1ImsiNull.assertMatches(identWifiImsiNullSsid1) |
| templateWifiSsid1ImsiNull.assertDoesNotMatch(identWifiImsi1Ssid1) |
| templateWifiSsid1ImsiNull.assertDoesNotMatch(identWifiImsi2Ssid1) |
| templateWifiSsid1ImsiNull.assertDoesNotMatch(identWifiImsi1Ssid2) |
| |
| // Verify that template with SSID1 and imsi1 matches any network with |
| // SSID1 and imsi1. |
| templateWifiSsid1Imsi1.assertDoesNotMatch(identMobile1) |
| templateWifiSsid1Imsi1.assertDoesNotMatch(identWifiImsiNullSsid1) |
| templateWifiSsid1Imsi1.assertMatches(identWifiImsi1Ssid1) |
| templateWifiSsid1Imsi1.assertDoesNotMatch(identWifiImsi2Ssid1) |
| templateWifiSsid1Imsi1.assertDoesNotMatch(identWifiImsi1Ssid2) |
| |
| // Verify that template with SSID all and imsi1 matches any network with |
| // any SSID and imsi1. |
| templateWifiSsidAllImsi1.assertDoesNotMatch(identMobile1) |
| templateWifiSsidAllImsi1.assertDoesNotMatch(identWifiImsiNullSsid1) |
| templateWifiSsidAllImsi1.assertMatches(identWifiImsi1Ssid1) |
| templateWifiSsidAllImsi1.assertDoesNotMatch(identWifiImsi2Ssid1) |
| templateWifiSsidAllImsi1.assertMatches(identWifiImsi1Ssid2) |
| } |
| |
| @Test |
| fun testMobileMatches() { |
| val templateMobileImsi1 = buildTemplateMobileAll(TEST_IMSI1) |
| val templateMobileImsi2WithRatType = buildTemplateMobileWithRatType(TEST_IMSI2, |
| TelephonyManager.NETWORK_TYPE_UMTS, METERED_YES) |
| |
| val mobileImsi1 = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, null /* ssid */, |
| OEM_NONE, true /* metered */) |
| val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, |
| false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) |
| val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) |
| val identMobile2Umts = buildNetworkIdentity(mockContext, mobileImsi2, |
| false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) |
| |
| val identWifiImsi1Ssid1 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_SSID1), true, 0) |
| |
| // Verify that the template matches type and the subscriberId. |
| templateMobileImsi1.assertMatches(identMobile1) |
| templateMobileImsi2WithRatType.assertMatches(identMobile2Umts) |
| |
| // Verify that the template does not match the different subscriberId. |
| templateMobileImsi1.assertDoesNotMatch(identMobile2Umts) |
| templateMobileImsi2WithRatType.assertDoesNotMatch(identMobile1) |
| |
| // Verify that the different type does not match. |
| templateMobileImsi1.assertDoesNotMatch(identWifiImsi1Ssid1) |
| } |
| |
| @Test |
| fun testMobileWildcardMatches() { |
| val templateMobileWildcard = buildTemplateMobileWildcard() |
| val templateMobileNullImsiWithRatType = buildTemplateMobileWithRatType(null, |
| TelephonyManager.NETWORK_TYPE_UMTS, METERED_ALL) |
| |
| val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) |
| val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, |
| false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) |
| |
| // Verify that the template matches any subscriberId. |
| templateMobileWildcard.assertMatches(identMobile1) |
| templateMobileNullImsiWithRatType.assertMatches(identMobile1) |
| |
| val identWifiImsi1Ssid1 = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_SSID1), true, 0) |
| |
| // Verify that the different type does not match. |
| templateMobileWildcard.assertDoesNotMatch(identWifiImsi1Ssid1) |
| templateMobileNullImsiWithRatType.assertDoesNotMatch(identWifiImsi1Ssid1) |
| } |
| |
| @Test |
| fun testCarrierMeteredMatches() { |
| val templateCarrierImsi1Metered = buildTemplateCarrierMetered(TEST_IMSI1) |
| |
| val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) |
| val mobileImsi1Unmetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, null /* ssid */, |
| OEM_NONE, false /* metered */) |
| val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) |
| val wifiSsid1 = buildWifiNetworkState(null /* subscriberId */, TEST_SSID1) |
| val wifiImsi1Ssid1 = buildWifiNetworkState(TEST_IMSI1, TEST_SSID1) |
| val wifiImsi1Ssid1Unmetered = buildNetworkState(TYPE_WIFI, TEST_IMSI1, TEST_SSID1, |
| OEM_NONE, false /* metered */) |
| |
| val identMobileImsi1Metered = buildNetworkIdentity(mockContext, |
| mobileImsi1, false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) |
| val identMobileImsi1Unmetered = buildNetworkIdentity(mockContext, |
| mobileImsi1Unmetered, false /* defaultNetwork */, |
| TelephonyManager.NETWORK_TYPE_UMTS) |
| val identMobileImsi2Metered = buildNetworkIdentity(mockContext, |
| mobileImsi2, false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) |
| val identWifiSsid1Metered = buildNetworkIdentity( |
| mockContext, wifiSsid1, true /* defaultNetwork */, 0 /* subType */) |
| val identCarrierWifiImsi1Metered = buildNetworkIdentity( |
| mockContext, wifiImsi1Ssid1, true /* defaultNetwork */, 0 /* subType */) |
| val identCarrierWifiImsi1NonMetered = buildNetworkIdentity(mockContext, |
| wifiImsi1Ssid1Unmetered, true /* defaultNetwork */, 0 /* subType */) |
| |
| templateCarrierImsi1Metered.assertMatches(identMobileImsi1Metered) |
| templateCarrierImsi1Metered.assertDoesNotMatch(identMobileImsi1Unmetered) |
| templateCarrierImsi1Metered.assertDoesNotMatch(identMobileImsi2Metered) |
| templateCarrierImsi1Metered.assertDoesNotMatch(identWifiSsid1Metered) |
| templateCarrierImsi1Metered.assertMatches(identCarrierWifiImsi1Metered) |
| templateCarrierImsi1Metered.assertDoesNotMatch(identCarrierWifiImsi1NonMetered) |
| } |
| |
| // TODO: Refactor this test to reduce the line of codes. |
| @Test |
| fun testRatTypeGroupMatches() { |
| val stateMobileImsi1Metered = buildMobileNetworkState(TEST_IMSI1) |
| val stateMobileImsi1NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, |
| null /* ssid */, OEM_NONE, false /* metered */) |
| val stateMobileImsi2NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI2, |
| null /* ssid */, OEM_NONE, false /* metered */) |
| |
| // Build UMTS template that matches mobile identities with RAT in the same |
| // group with any IMSI. See {@link NetworkTemplate#getCollapsedRatType}. |
| val templateUmtsMetered = buildTemplateMobileWithRatType(null, |
| TelephonyManager.NETWORK_TYPE_UMTS, METERED_YES) |
| // Build normal template that matches mobile identities with any RAT and IMSI. |
| val templateAllMetered = buildTemplateMobileWithRatType(null, NETWORK_TYPE_ALL, |
| METERED_YES) |
| // Build template with UNKNOWN RAT that matches mobile identities with RAT that |
| // cannot be determined. |
| val templateUnknownMetered = |
| buildTemplateMobileWithRatType(null, TelephonyManager.NETWORK_TYPE_UNKNOWN, |
| METERED_YES) |
| |
| val templateUmtsNonMetered = buildTemplateMobileWithRatType(null, |
| TelephonyManager.NETWORK_TYPE_UMTS, METERED_NO) |
| val templateAllNonMetered = buildTemplateMobileWithRatType(null, NETWORK_TYPE_ALL, |
| METERED_NO) |
| val templateUnknownNonMetered = |
| buildTemplateMobileWithRatType(null, TelephonyManager.NETWORK_TYPE_UNKNOWN, |
| METERED_NO) |
| |
| val identUmtsMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_UMTS) |
| val identHsdpaMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_HSDPA) |
| val identLteMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_LTE) |
| val identCombinedMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1Metered, false, SUBTYPE_COMBINED) |
| val identImsi2UmtsMetered = buildNetworkIdentity(mockContext, |
| buildMobileNetworkState(TEST_IMSI2), false, TelephonyManager.NETWORK_TYPE_UMTS) |
| val identWifi = buildNetworkIdentity( |
| mockContext, buildWifiNetworkState(null, TEST_SSID1), true, 0) |
| |
| val identUmtsNonMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) |
| val identHsdpaNonMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1NonMetered, false, |
| TelephonyManager.NETWORK_TYPE_HSDPA) |
| val identLteNonMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_LTE) |
| val identCombinedNonMetered = buildNetworkIdentity( |
| mockContext, stateMobileImsi1NonMetered, false, SUBTYPE_COMBINED) |
| val identImsi2UmtsNonMetered = buildNetworkIdentity(mockContext, |
| stateMobileImsi2NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) |
| |
| // Assert that identity with the same RAT and meteredness matches. |
| // Verify metered template. |
| templateUmtsMetered.assertMatches(identUmtsMetered) |
| templateAllMetered.assertMatches(identUmtsMetered) |
| templateUnknownMetered.assertDoesNotMatch(identUmtsMetered) |
| // Verify non-metered template. |
| templateUmtsNonMetered.assertMatches(identUmtsNonMetered) |
| templateAllNonMetered.assertMatches(identUmtsNonMetered) |
| templateUnknownNonMetered.assertDoesNotMatch(identUmtsNonMetered) |
| |
| // Assert that identity with the same RAT but meteredness is different. |
| // Thus, it does not match. |
| templateUmtsNonMetered.assertDoesNotMatch(identUmtsMetered) |
| templateAllNonMetered.assertDoesNotMatch(identUmtsMetered) |
| |
| // Assert that identity with the RAT within the same group matches. |
| // Verify metered template. |
| templateUmtsMetered.assertMatches(identHsdpaMetered) |
| templateAllMetered.assertMatches(identHsdpaMetered) |
| templateUnknownMetered.assertDoesNotMatch(identHsdpaMetered) |
| // Verify non-metered template. |
| templateUmtsNonMetered.assertMatches(identHsdpaNonMetered) |
| templateAllNonMetered.assertMatches(identHsdpaNonMetered) |
| templateUnknownNonMetered.assertDoesNotMatch(identHsdpaNonMetered) |
| |
| // Assert that identity with the RAT out of the same group only matches template with |
| // NETWORK_TYPE_ALL. |
| // Verify metered template. |
| templateUmtsMetered.assertDoesNotMatch(identLteMetered) |
| templateAllMetered.assertMatches(identLteMetered) |
| templateUnknownMetered.assertDoesNotMatch(identLteMetered) |
| // Verify non-metered template. |
| templateUmtsNonMetered.assertDoesNotMatch(identLteNonMetered) |
| templateAllNonMetered.assertMatches(identLteNonMetered) |
| templateUnknownNonMetered.assertDoesNotMatch(identLteNonMetered) |
| // Verify non-metered template does not match identity with metered. |
| templateAllNonMetered.assertDoesNotMatch(identLteMetered) |
| |
| // Assert that identity with combined RAT only matches with template with NETWORK_TYPE_ALL |
| // and NETWORK_TYPE_UNKNOWN. |
| // Verify metered template. |
| templateUmtsMetered.assertDoesNotMatch(identCombinedMetered) |
| templateAllMetered.assertMatches(identCombinedMetered) |
| templateUnknownMetered.assertMatches(identCombinedMetered) |
| // Verify non-metered template. |
| templateUmtsNonMetered.assertDoesNotMatch(identCombinedNonMetered) |
| templateAllNonMetered.assertMatches(identCombinedNonMetered) |
| templateUnknownNonMetered.assertMatches(identCombinedNonMetered) |
| // Verify that identity with metered does not match non-metered template. |
| templateAllNonMetered.assertDoesNotMatch(identCombinedMetered) |
| templateUnknownNonMetered.assertDoesNotMatch(identCombinedMetered) |
| |
| // Assert that identity with different IMSI matches. |
| // Verify metered template. |
| templateUmtsMetered.assertMatches(identImsi2UmtsMetered) |
| templateAllMetered.assertMatches(identImsi2UmtsMetered) |
| templateUnknownMetered.assertDoesNotMatch(identImsi2UmtsMetered) |
| // Verify non-metered template. |
| templateUmtsNonMetered.assertMatches(identImsi2UmtsNonMetered) |
| templateAllNonMetered.assertMatches(identImsi2UmtsNonMetered) |
| templateUnknownNonMetered.assertDoesNotMatch(identImsi2UmtsNonMetered) |
| // Verify that the same RAT but different meteredness should not match. |
| templateUmtsNonMetered.assertDoesNotMatch(identImsi2UmtsMetered) |
| templateAllNonMetered.assertDoesNotMatch(identImsi2UmtsMetered) |
| |
| // Assert that wifi identity does not match. |
| templateUmtsMetered.assertDoesNotMatch(identWifi) |
| templateUnknownMetered.assertDoesNotMatch(identWifi) |
| templateUmtsNonMetered.assertDoesNotMatch(identWifi) |
| templateUnknownNonMetered.assertDoesNotMatch(identWifi) |
| } |
| |
| @Test |
| fun testParcelUnparcel() { |
| val templateMobile = NetworkTemplate(MATCH_MOBILE, TEST_IMSI1, null, null, METERED_ALL, |
| ROAMING_ALL, DEFAULT_NETWORK_ALL, TelephonyManager.NETWORK_TYPE_LTE, |
| OEM_MANAGED_ALL, SUBSCRIBER_ID_MATCH_RULE_EXACT) |
| val templateWifi = NetworkTemplate(MATCH_WIFI, null, null, TEST_SSID1, METERED_ALL, |
| ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, OEM_MANAGED_ALL, |
| SUBSCRIBER_ID_MATCH_RULE_EXACT) |
| val templateOem = NetworkTemplate(MATCH_MOBILE, null, null, null, METERED_ALL, |
| ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, OEM_MANAGED_YES, |
| SUBSCRIBER_ID_MATCH_RULE_EXACT) |
| assertParcelSane(templateMobile, 10) |
| assertParcelSane(templateWifi, 10) |
| assertParcelSane(templateOem, 10) |
| } |
| |
| // Verify NETWORK_TYPE_* constants in NetworkTemplate do not conflict with |
| // TelephonyManager#NETWORK_TYPE_* constants. |
| @Test |
| fun testNetworkTypeConstants() { |
| for (ratType in TelephonyManager.getAllNetworkTypes()) { |
| assertNotEquals(NETWORK_TYPE_ALL, ratType) |
| assertNotEquals(NETWORK_TYPE_5G_NSA, ratType) |
| } |
| } |
| |
| @Test |
| fun testOemNetworkConstants() { |
| val constantValues = arrayOf(OEM_MANAGED_YES, OEM_MANAGED_ALL, OEM_MANAGED_NO, |
| OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE) |
| |
| // Verify that "not OEM managed network" constants are equal. |
| assertEquals(OEM_MANAGED_NO, OEM_NONE) |
| |
| // Verify the constants don't conflict. |
| assertEquals(constantValues.size, constantValues.distinct().count()) |
| } |
| |
| /** |
| * Helper to enumerate and assert OEM managed wifi and mobile {@code NetworkTemplate}s match |
| * their the appropriate OEM managed {@code NetworkIdentity}s. |
| * |
| * @param networkType {@code TYPE_MOBILE} or {@code TYPE_WIFI} |
| * @param matchType A match rule from {@code NetworkTemplate.MATCH_*} corresponding to the |
| * networkType. |
| * @param subscriberId To be populated with {@code TEST_IMSI*} only if networkType is |
| * {@code TYPE_MOBILE}. May be left as null when matchType is |
| * {@link NetworkTemplate.MATCH_MOBILE_WILDCARD}. |
| * @param templateSsid Top be populated with {@code TEST_SSID*} only if networkType is |
| * {@code TYPE_WIFI}. May be left as null when matchType is |
| * {@link NetworkTemplate.MATCH_WIFI_WILDCARD}. |
| * @param identSsid If networkType is {@code TYPE_WIFI}, this value must *NOT* be null. Provide |
| * one of {@code TEST_SSID*}. |
| */ |
| private fun matchOemManagedIdent( |
| networkType: Int, |
| matchType: Int, |
| subscriberId: String? = null, |
| templateSsid: String? = null, |
| identSsid: String? = null |
| ) { |
| val oemManagedStates = arrayOf(OEM_NONE, OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE) |
| val matchSubscriberIds = arrayOf(subscriberId) |
| |
| val templateOemYes = NetworkTemplate(matchType, subscriberId, matchSubscriberIds, |
| templateSsid, METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, |
| OEM_MANAGED_YES, SUBSCRIBER_ID_MATCH_RULE_EXACT) |
| val templateOemAll = NetworkTemplate(matchType, subscriberId, matchSubscriberIds, |
| templateSsid, METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, |
| OEM_MANAGED_ALL, SUBSCRIBER_ID_MATCH_RULE_EXACT) |
| |
| for (identityOemManagedState in oemManagedStates) { |
| val ident = buildNetworkIdentity(mockContext, buildNetworkState(networkType, |
| subscriberId, identSsid, identityOemManagedState), /*defaultNetwork=*/false, |
| /*subType=*/0) |
| |
| // Create a template with each OEM managed type and match it against the NetworkIdentity |
| for (templateOemManagedState in oemManagedStates) { |
| val template = NetworkTemplate(matchType, subscriberId, matchSubscriberIds, |
| templateSsid, METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, |
| NETWORK_TYPE_ALL, templateOemManagedState, SUBSCRIBER_ID_MATCH_RULE_EXACT) |
| if (identityOemManagedState == templateOemManagedState) { |
| template.assertMatches(ident) |
| } else { |
| template.assertDoesNotMatch(ident) |
| } |
| } |
| // OEM_MANAGED_ALL ignores OEM state. |
| templateOemAll.assertMatches(ident) |
| if (identityOemManagedState == OEM_NONE) { |
| // OEM_MANAGED_YES matches everything except OEM_NONE. |
| templateOemYes.assertDoesNotMatch(ident) |
| } else { |
| templateOemYes.assertMatches(ident) |
| } |
| } |
| } |
| |
| @Test |
| fun testOemManagedMatchesIdent() { |
| matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE, subscriberId = TEST_IMSI1) |
| matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE_WILDCARD) |
| matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, templateSsid = TEST_SSID1, |
| identSsid = TEST_SSID1) |
| matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI_WILDCARD, identSsid = TEST_SSID1) |
| } |
| } |
