From ab696ccc1b4b5fa1121dfed110b8a9b56f9f7c98 Mon Sep 17 00:00:00 2001 From: Junyu Lai Date: Thu, 22 May 2025 17:31:53 +0800 Subject: [PATCH] Fix kotlin lint errors in NetworkTemplateTests Flag: EXEMPT Test only refactor Test: atest ConnectivityCoverageTests --test-filter \ 'NetworkTemplate*' --update-device Bug: 419123367 Change-Id: I7f87c4a9f4f3e40c0274bf6539ccff4e42967cc8 --- .../net/netstats/NetworkTemplateTest.kt | 152 +++-- .../java/android/net/NetworkTemplateTest.kt | 540 ++++++++++++++---- 2 files changed, 523 insertions(+), 169 deletions(-) diff --git a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt index f6b655586d..808fa50240 100644 --- a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt +++ b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt @@ -66,9 +66,16 @@ class NetworkTemplateTest { listOf(MATCH_MOBILE, MATCH_CARRIER).forEach { matchRule -> NetworkTemplate.Builder(matchRule).setSubscriberIds(setOf(TEST_IMSI1)) .setMeteredness(METERED_YES).build().let { - val expectedTemplate = NetworkTemplate(matchRule, arrayOf(TEST_IMSI1), - emptyArray(), METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL, - NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + matchRule, + arrayOf(TEST_IMSI1), + emptyArray() /*wifiNetworkKey*/, + METERED_YES, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } } @@ -78,9 +85,16 @@ class NetworkTemplateTest { listOf(MATCH_MOBILE, MATCH_CARRIER).forEach { matchRule -> NetworkTemplate.Builder(matchRule).setSubscriberIds(setOf(TEST_IMSI1)) .setRoaming(ROAMING_YES).setMeteredness(METERED_YES).build().let { - val expectedTemplate = NetworkTemplate(matchRule, arrayOf(TEST_IMSI1), - emptyArray(), METERED_YES, ROAMING_YES, DEFAULT_NETWORK_ALL, - NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + matchRule, + arrayOf(TEST_IMSI1), + emptyArray() /*wifiNetworkKey*/, + METERED_YES, + ROAMING_YES, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } } @@ -102,14 +116,14 @@ class NetworkTemplateTest { } else { NetworkTemplate.Builder(MATCH_MOBILE).setSubscriberIds(setOf(null)).build().let { val expectedTemplate = NetworkTemplate( - MATCH_MOBILE, - arrayOfNulls(1) /*subscriberIds*/, - emptyArray() /*wifiNetworkKey*/, - METERED_ALL, - ROAMING_ALL, - DEFAULT_NETWORK_ALL, - NETWORK_TYPE_ALL, - OEM_MANAGED_ALL + MATCH_MOBILE, + arrayOfNulls(1) /*subscriberIds*/, + emptyArray() /*wifiNetworkKey*/, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL ) assertEquals(expectedTemplate, it) } @@ -118,10 +132,16 @@ class NetworkTemplateTest { // Verify template which matches metered cellular networks, // regardless of IMSI. See buildTemplateMobileWildcard. NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES).build().let { - val expectedTemplate = NetworkTemplate(MATCH_MOBILE, - emptyArray() /*subscriberIds*/, emptyArray() /*wifiNetworkKey*/, - METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, - OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + MATCH_MOBILE, + emptyArray() /*subscriberIds*/, + emptyArray() /*wifiNetworkKey*/, + METERED_YES, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } @@ -129,18 +149,32 @@ class NetworkTemplateTest { NetworkTemplate.Builder(MATCH_MOBILE).setSubscriberIds(setOf(TEST_IMSI1)) .setMeteredness(METERED_YES).setRatType(TelephonyManager.NETWORK_TYPE_UMTS) .build().let { - val expectedTemplate = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1), - emptyArray(), METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL, - TelephonyManager.NETWORK_TYPE_UMTS, OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + MATCH_MOBILE, + arrayOf(TEST_IMSI1), + emptyArray() /*wifiNetworkKey*/, + METERED_YES, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + TelephonyManager.NETWORK_TYPE_UMTS, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } // Verify template which matches all wifi networks, // regardless of Wifi Network Key. See buildTemplateWifiWildcard and buildTemplateWifi. NetworkTemplate.Builder(MATCH_WIFI).build().let { - val expectedTemplate = NetworkTemplate(MATCH_WIFI, - emptyArray() /*subscriberIds*/, emptyArray(), METERED_ALL, - ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + MATCH_WIFI, + emptyArray() /*subscriberIds*/, + emptyArray() /*wifiNetworkKey*/, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } @@ -148,9 +182,16 @@ class NetworkTemplateTest { // See buildTemplateWifi(wifiNetworkKey). NetworkTemplate.Builder(MATCH_WIFI).setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build().let { val expectedTemplate = - NetworkTemplate(MATCH_WIFI, emptyArray() /*subscriberIds*/, - arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, - NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + NetworkTemplate( + MATCH_WIFI, + emptyArray() /*subscriberIds*/, + arrayOf(TEST_WIFI_KEY1), + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } @@ -158,9 +199,16 @@ class NetworkTemplateTest { // given Wifi Network Key, and IMSI. See buildTemplateWifi(wifiNetworkKey, subscriberId). NetworkTemplate.Builder(MATCH_WIFI).setSubscriberIds(setOf(TEST_IMSI1)) .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build().let { - val expectedTemplate = NetworkTemplate(MATCH_WIFI, arrayOf(TEST_IMSI1), - arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, - NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + MATCH_WIFI, + arrayOf(TEST_IMSI1), + arrayOf(TEST_WIFI_KEY1), + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } @@ -168,10 +216,16 @@ class NetworkTemplateTest { // See buildTemplateEthernet and buildTemplateBluetooth. listOf(MATCH_ETHERNET, MATCH_BLUETOOTH, MATCH_PROXY).forEach { matchRule -> NetworkTemplate.Builder(matchRule).build().let { - val expectedTemplate = NetworkTemplate(matchRule, - emptyArray() /*subscriberIds*/, emptyArray(), - METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, - OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + matchRule, + emptyArray() /*subscriberIds*/, + emptyArray() /*wifiNetworkKey*/, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } } @@ -182,15 +236,23 @@ class NetworkTemplateTest { // Verify template builder which generates same template with the given different // sequence keys. NetworkTemplate.Builder(MATCH_WIFI).setWifiNetworkKeys( - setOf(TEST_WIFI_KEY1, TEST_WIFI_KEY2)).build().let { + setOf(TEST_WIFI_KEY1, TEST_WIFI_KEY2) + ).build().let { val expectedTemplate = NetworkTemplate.Builder(MATCH_WIFI).setWifiNetworkKeys( - setOf(TEST_WIFI_KEY2, TEST_WIFI_KEY1)).build() + setOf(TEST_WIFI_KEY2, TEST_WIFI_KEY1) + ).build() assertEquals(expectedTemplate, it) } // Verify template which matches non-wifi networks with the given key is invalid. - listOf(MATCH_MOBILE, MATCH_CARRIER, MATCH_ETHERNET, MATCH_BLUETOOTH, -1, - Integer.MAX_VALUE).forEach { matchRule -> + listOf( + MATCH_MOBILE, + MATCH_CARRIER, + MATCH_ETHERNET, + MATCH_BLUETOOTH, + -1, + Integer.MAX_VALUE + ).forEach { matchRule -> assertFailsWith { NetworkTemplate.Builder(matchRule).setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() } @@ -203,10 +265,16 @@ class NetworkTemplateTest { // Verify template which matches wifi wildcard with the given empty key set. NetworkTemplate.Builder(MATCH_WIFI).setWifiNetworkKeys(setOf()).build().let { - val expectedTemplate = NetworkTemplate(MATCH_WIFI, - emptyArray() /*subscriberIds*/, emptyArray(), - METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, - OEM_MANAGED_ALL) + val expectedTemplate = NetworkTemplate( + MATCH_WIFI, + emptyArray() /*subscriberIds*/, + emptyArray() /*wifiNetworkKey*/, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) assertEquals(expectedTemplate, it) } } diff --git a/tests/unit/java/android/net/NetworkTemplateTest.kt b/tests/unit/java/android/net/NetworkTemplateTest.kt index a8414ca8a9..f1f455b4b3 100644 --- a/tests/unit/java/android/net/NetworkTemplateTest.kt +++ b/tests/unit/java/android/net/NetworkTemplateTest.kt @@ -79,26 +79,35 @@ class NetworkTemplateTest { private fun buildMobileNetworkState(subscriberId: String): NetworkStateSnapshot = buildNetworkState(TYPE_MOBILE, subscriberId = subscriberId) - private fun buildWifiNetworkState(subscriberId: String?, wifiKey: String?): - NetworkStateSnapshot = buildNetworkState(TYPE_WIFI, - subscriberId = subscriberId, wifiKey = wifiKey) + private fun buildWifiNetworkState( + subscriberId: String?, + wifiKey: String? + ): NetworkStateSnapshot = buildNetworkState( + TYPE_WIFI, + subscriberId = subscriberId, + wifiKey = wifiKey + ) private fun buildNetworkState( - type: Int, - subscriberId: String? = null, - wifiKey: String? = null, - oemManaged: Int = OEM_NONE, - metered: Boolean = true + type: Int, + subscriberId: String? = null, + wifiKey: String? = null, + oemManaged: Int = OEM_NONE, + metered: Boolean = true ): NetworkStateSnapshot { `when`(mockWifiInfo.getNetworkKey()).thenReturn(wifiKey) val lp = LinkProperties() val caps = NetworkCapabilities().apply { setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED, !metered) setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING, true) - setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID, - (oemManaged and OEM_PAID) == OEM_PAID) - setCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE, - (oemManaged and OEM_PRIVATE) == OEM_PRIVATE) + setCapability( + NetworkCapabilities.NET_CAPABILITY_OEM_PAID, + (oemManaged and OEM_PAID) == OEM_PAID + ) + setCapability( + NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE, + (oemManaged and OEM_PRIVATE) == OEM_PRIVATE + ) if (type == TYPE_TEST) { wifiKey?.let { TestNetworkSpecifier(it) }?.let { // Must have a single non-test transport specified to use setNetworkSpecifier. @@ -127,19 +136,36 @@ class NetworkTemplateTest { fun testWifiWildcardMatches() { val templateWifiWildcard = buildTemplateWifiWildcard() - val identMobileImsi1 = buildNetworkIdentity(mockContext, + val identMobileImsi1 = buildNetworkIdentity( + mockContext, buildMobileNetworkState(TEST_IMSI1), - false, TelephonyManager.NETWORK_TYPE_UMTS) + false, + TelephonyManager.NETWORK_TYPE_UMTS + ) val identWifiImsiNullKey1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(null, TEST_WIFI_KEY1), + true, + 0 + ) val identWifiImsi1Key1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), + true, + 0 + ) // This identity with a null wifiNetworkKey is to test matchesWifiNetworkKey won't crash // the system when a null wifiNetworkKey is provided, which happens because of a bug in wifi // and it should still match the wifi wildcard template. See b/266598304. val identWifiNullKey = buildNetworkIdentity( - mockContext, buildWifiNetworkState(null /* subscriberId */, - null /* wifiNetworkKey */), true, 0) + mockContext, + buildWifiNetworkState( + null /* subscriberId */, + null /* wifiNetworkKey */ + ), + true, + 0 + ) templateWifiWildcard.assertDoesNotMatch(identMobileImsi1) templateWifiWildcard.assertMatches(identWifiImsiNullKey1) @@ -159,26 +185,56 @@ class NetworkTemplateTest { .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() val templateWifiKeyAllImsi1 = NetworkTemplate.Builder(MATCH_WIFI) .setSubscriberIds(setOf(TEST_IMSI1)).build() - val templateNullWifiKey = NetworkTemplate(MATCH_WIFI, - emptyArray() /* subscriberIds */, arrayOf(null) /* wifiNetworkKeys */, - METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + val templateNullWifiKey = NetworkTemplate( + MATCH_WIFI, + emptyArray() /* subscriberIds */, + arrayOf(null) /* wifiNetworkKeys */, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) - val identMobile1 = buildNetworkIdentity(mockContext, buildMobileNetworkState(TEST_IMSI1), - false, TelephonyManager.NETWORK_TYPE_UMTS) + val identMobile1 = buildNetworkIdentity( + mockContext, + buildMobileNetworkState(TEST_IMSI1), + false, + TelephonyManager.NETWORK_TYPE_UMTS + ) val identWifiImsiNullKey1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(null, TEST_WIFI_KEY1), + true, + 0 + ) val identWifiImsi1Key1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), + true, + 0 + ) val identWifiImsi2Key1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), + true, + 0 + ) val identWifiImsi1Key2 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY2), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY2), + true, + 0 + ) // This identity with a null wifiNetworkKey is to test the matchesWifiNetworkKey won't crash // the system when a null wifiNetworkKey is provided, which would happen in some unknown // cases, see b/266598304. val identWifiNullKey = buildNetworkIdentity( - mockContext, buildWifiNetworkState(null /* subscriberId */, - null /* wifiNetworkKey */), true, 0) + mockContext, + buildWifiNetworkState(null /* subscriberId */, null /* wifiNetworkKey */), + true, + 0 + ) // Verify that template with WiFi Network Key only matches any subscriberId and // specific WiFi Network Key. @@ -240,16 +296,33 @@ class NetworkTemplateTest { .setSubscriberIds(setOf(TEST_IMSI2)) .setRatType(TelephonyManager.NETWORK_TYPE_UMTS).build() - val mobileImsi1 = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, null /* wifiKey */, - OEM_NONE, true /* metered */) - val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, - false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) + val mobileImsi1 = buildNetworkState( + TYPE_MOBILE, + TEST_IMSI1, + null /* wifiKey */, + 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 identMobile2Umts = buildNetworkIdentity( + mockContext, + mobileImsi2, + false /* defaultNetwork */, + TelephonyManager.NETWORK_TYPE_UMTS + ) val identWifiImsi1Key1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), + true, + 0 + ) // Verify that the template matches type and the subscriberId. templateMobileImsi1.assertMatches(identMobile1) @@ -269,11 +342,19 @@ class NetworkTemplateTest { val templateMobileNullImsiWithRatType = NetworkTemplate.Builder(MATCH_MOBILE) .setRatType(TelephonyManager.NETWORK_TYPE_UMTS).build() val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) - val identMobile1 = buildNetworkIdentity(mockContext, mobileImsi1, - false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_UMTS) + val identMobile1 = buildNetworkIdentity( + mockContext, + mobileImsi1, + false /* defaultNetwork */, + TelephonyManager.NETWORK_TYPE_UMTS + ) val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) - val identMobile2 = buildNetworkIdentity(mockContext, mobileImsi2, - false /* defaultNetwork */, TelephonyManager.NETWORK_TYPE_LTE) + val identMobile2 = buildNetworkIdentity( + mockContext, + mobileImsi2, + false /* defaultNetwork */, + TelephonyManager.NETWORK_TYPE_LTE + ) // Verify that the template matches any subscriberId. templateMobileWildcard.assertMatches(identMobile1) @@ -282,7 +363,11 @@ class NetworkTemplateTest { templateMobileNullImsiWithRatType.assertDoesNotMatch(identMobile2) val identWifiImsi1Key1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), + true, + 0 + ) // Verify that the different type does not match. templateMobileWildcard.assertDoesNotMatch(identWifiImsi1Key1) @@ -297,14 +382,32 @@ class NetworkTemplateTest { .setWifiNetworkKeys(setOf(TEST_WIFI_KEY2)).build() val templateTestAll = NetworkTemplate.Builder(MATCH_TEST).build() - val stateWifiKey1 = buildNetworkState(TYPE_WIFI, null /* subscriberId */, TEST_WIFI_KEY1, - OEM_NONE, true /* metered */) - val stateTestKey1 = buildNetworkState(TYPE_TEST, null /* subscriberId */, TEST_WIFI_KEY1, - OEM_NONE, true /* metered */) - val identWifi1 = buildNetworkIdentity(mockContext, stateWifiKey1, - false /* defaultNetwork */, NetworkTemplate.NETWORK_TYPE_ALL) - val identTest1 = buildNetworkIdentity(mockContext, stateTestKey1, - false /* defaultNetwork */, NETWORK_TYPE_ALL) + val stateWifiKey1 = buildNetworkState( + TYPE_WIFI, + null /* subscriberId */, + TEST_WIFI_KEY1, + OEM_NONE, + true /* metered */ + ) + val stateTestKey1 = buildNetworkState( + TYPE_TEST, + null /* subscriberId */, + TEST_WIFI_KEY1, + OEM_NONE, + true /* metered */ + ) + val identWifi1 = buildNetworkIdentity( + mockContext, + stateWifiKey1, + false /* defaultNetwork */, + NETWORK_TYPE_ALL + ) + val identTest1 = buildNetworkIdentity( + mockContext, + stateTestKey1, + false /* defaultNetwork */, + NETWORK_TYPE_ALL + ) // Verify that the template matches corresponding type and the subscriberId. templateTestKey1.assertDoesNotMatch(identWifi1) @@ -322,28 +425,63 @@ class NetworkTemplateTest { .setSubscriberIds(setOf(TEST_IMSI1)).build() val mobileImsi1 = buildMobileNetworkState(TEST_IMSI1) - val mobileImsi1Unmetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, - null /* wifiKey */, OEM_NONE, false /* metered */) + val mobileImsi1Unmetered = buildNetworkState( + TYPE_MOBILE, + TEST_IMSI1, + null /* wifiKey */, + OEM_NONE, + false /* metered */ + ) val mobileImsi2 = buildMobileNetworkState(TEST_IMSI2) - val wifiKey1 = buildWifiNetworkState(null /* subscriberId */, - TEST_WIFI_KEY1) + val wifiKey1 = buildWifiNetworkState( + null /* subscriberId */, + TEST_WIFI_KEY1 + ) val wifiImsi1Key1 = buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1) - val wifiImsi1Key1Unmetered = buildNetworkState(TYPE_WIFI, TEST_IMSI1, - TEST_WIFI_KEY1, OEM_NONE, false /* metered */) + val wifiImsi1Key1Unmetered = buildNetworkState( + TYPE_WIFI, + TEST_IMSI1, + TEST_WIFI_KEY1, + 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 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 identWifiKey1Metered = buildNetworkIdentity( - mockContext, wifiKey1, true /* defaultNetwork */, 0 /* subType */) + mockContext, + wifiKey1, + true /* defaultNetwork */, + 0 /* subType */ + ) val identCarrierWifiImsi1Metered = buildNetworkIdentity( - mockContext, wifiImsi1Key1, true /* defaultNetwork */, 0 /* subType */) - val identCarrierWifiImsi1NonMetered = buildNetworkIdentity(mockContext, - wifiImsi1Key1Unmetered, true /* defaultNetwork */, 0 /* subType */) + mockContext, + wifiImsi1Key1, + true /* defaultNetwork */, + 0 /* subType */ + ) + val identCarrierWifiImsi1NonMetered = buildNetworkIdentity( + mockContext, + wifiImsi1Key1Unmetered, + true /* defaultNetwork */, + 0 /* subType */ + ) templateCarrierImsi1Metered.assertMatches(identMobileImsi1Metered) templateCarrierImsi1Metered.assertDoesNotMatch(identMobileImsi1Unmetered) @@ -357,10 +495,20 @@ class NetworkTemplateTest { @Test fun testRatTypeGroupMatches() { val stateMobileImsi1Metered = buildMobileNetworkState(TEST_IMSI1) - val stateMobileImsi1NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI1, - null /* wifiKey */, OEM_NONE, false /* metered */) - val stateMobileImsi2NonMetered = buildNetworkState(TYPE_MOBILE, TEST_IMSI2, - null /* wifiKey */, OEM_NONE, false /* metered */) + val stateMobileImsi1NonMetered = buildNetworkState( + TYPE_MOBILE, + TEST_IMSI1, + null /* wifiKey */, + OEM_NONE, + false /* metered */ + ) + val stateMobileImsi2NonMetered = buildNetworkState( + TYPE_MOBILE, + TEST_IMSI2, + null /* wifiKey */, + OEM_NONE, + false /* metered */ + ) // Build UMTS template that matches mobile identities with RAT in the same // group with any IMSI. See {@link NetworkTemplate#getCollapsedRatType}. @@ -385,29 +533,72 @@ class NetworkTemplateTest { .setRatType(TelephonyManager.NETWORK_TYPE_UNKNOWN).build() val identUmtsMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_UMTS) + mockContext, + stateMobileImsi1Metered, + false, + TelephonyManager.NETWORK_TYPE_UMTS + ) val identHsdpaMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_HSDPA) + mockContext, + stateMobileImsi1Metered, + false, + TelephonyManager.NETWORK_TYPE_HSDPA + ) val identLteMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1Metered, false, TelephonyManager.NETWORK_TYPE_LTE) + mockContext, + stateMobileImsi1Metered, + false, + TelephonyManager.NETWORK_TYPE_LTE + ) val identCombinedMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1Metered, false, NetworkTemplate.NETWORK_TYPE_ALL) - val identImsi2UmtsMetered = buildNetworkIdentity(mockContext, - buildMobileNetworkState(TEST_IMSI2), false, TelephonyManager.NETWORK_TYPE_UMTS) + mockContext, + stateMobileImsi1Metered, + false, + NETWORK_TYPE_ALL + ) + val identImsi2UmtsMetered = buildNetworkIdentity( + mockContext, + buildMobileNetworkState(TEST_IMSI2), + false, + TelephonyManager.NETWORK_TYPE_UMTS + ) val identWifi = buildNetworkIdentity( - mockContext, buildWifiNetworkState(null, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(null, TEST_WIFI_KEY1), + true, + 0 + ) val identUmtsNonMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) + mockContext, + stateMobileImsi1NonMetered, + false, + TelephonyManager.NETWORK_TYPE_UMTS + ) val identHsdpaNonMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1NonMetered, false, - TelephonyManager.NETWORK_TYPE_HSDPA) + mockContext, + stateMobileImsi1NonMetered, + false, + TelephonyManager.NETWORK_TYPE_HSDPA + ) val identLteNonMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1NonMetered, false, TelephonyManager.NETWORK_TYPE_LTE) + mockContext, + stateMobileImsi1NonMetered, + false, + TelephonyManager.NETWORK_TYPE_LTE + ) val identCombinedNonMetered = buildNetworkIdentity( - mockContext, stateMobileImsi1NonMetered, false, NetworkTemplate.NETWORK_TYPE_ALL) - val identImsi2UmtsNonMetered = buildNetworkIdentity(mockContext, - stateMobileImsi2NonMetered, false, TelephonyManager.NETWORK_TYPE_UMTS) + mockContext, + stateMobileImsi1NonMetered, + false, + NETWORK_TYPE_ALL + ) + val identImsi2UmtsNonMetered = buildNetworkIdentity( + mockContext, + stateMobileImsi2NonMetered, + false, + TelephonyManager.NETWORK_TYPE_UMTS + ) // Assert that identity with the same RAT and meteredness matches. // Verify metered template. @@ -486,9 +677,16 @@ class NetworkTemplateTest { val templateImsi1 = NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES) .setSubscriberIds(setOf(TEST_IMSI1)).setRatType(TelephonyManager.NETWORK_TYPE_UMTS) .build() - val dupTemplateImsi1 = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1), - emptyArray(), METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL, - TelephonyManager.NETWORK_TYPE_UMTS, OEM_MANAGED_ALL) + val dupTemplateImsi1 = NetworkTemplate( + MATCH_MOBILE, + arrayOf(TEST_IMSI1), + emptyArray() /* wifiNetworkKey */, + METERED_YES, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + TelephonyManager.NETWORK_TYPE_UMTS, + OEM_MANAGED_ALL + ) val templateImsi2 = NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES) .setSubscriberIds(setOf(TEST_IMSI2)).setRatType(TelephonyManager.NETWORK_TYPE_UMTS) .build() @@ -499,9 +697,16 @@ class NetworkTemplateTest { val templateWifiKey1 = NetworkTemplate.Builder(MATCH_WIFI) .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build() - val dupTemplateWifiKey1 = NetworkTemplate(MATCH_WIFI, emptyArray(), - arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, - NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + val dupTemplateWifiKey1 = NetworkTemplate( + MATCH_WIFI, + emptyArray(), + arrayOf(TEST_WIFI_KEY1), + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) val templateWifiKey2 = NetworkTemplate.Builder(MATCH_WIFI) .setWifiNetworkKeys(setOf(TEST_WIFI_KEY2)).build() @@ -512,15 +717,36 @@ class NetworkTemplateTest { @Test fun testParcelUnparcel() { - val templateMobile = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1), - emptyArray(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, - TelephonyManager.NETWORK_TYPE_LTE, OEM_MANAGED_ALL) - val templateWifi = NetworkTemplate(MATCH_WIFI, emptyArray(), - arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, - OEM_MANAGED_ALL) - val templateOem = NetworkTemplate(MATCH_MOBILE, emptyArray(), - emptyArray(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL, 0, - OEM_MANAGED_YES) + val templateMobile = NetworkTemplate( + MATCH_MOBILE, + arrayOf(TEST_IMSI1), + emptyArray() /* wifiNetworkKey */, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + TelephonyManager.NETWORK_TYPE_LTE, + OEM_MANAGED_ALL + ) + val templateWifi = NetworkTemplate( + MATCH_WIFI, + emptyArray() /* subscriberIds */, + arrayOf(TEST_WIFI_KEY1), + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + 0, + OEM_MANAGED_ALL + ) + val templateOem = NetworkTemplate( + MATCH_MOBILE, + emptyArray() /* subscriberIds */, + emptyArray() /* wifiNetworkKey */, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + 0, + OEM_MANAGED_YES + ) assertParcelSane(templateMobile, 8) assertParcelSane(templateWifi, 8) assertParcelSane(templateOem, 8) @@ -538,8 +764,14 @@ class NetworkTemplateTest { @Test fun testOemNetworkConstants() { - val constantValues = arrayOf(OEM_MANAGED_YES, OEM_MANAGED_ALL, OEM_MANAGED_NO, - OEM_PAID, OEM_PRIVATE, OEM_PAID or OEM_PRIVATE) + 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) @@ -578,23 +810,52 @@ class NetworkTemplateTest { val matchWifiNetworkKeys = if (templateWifiKey == null) emptyArray() else arrayOf(templateWifiKey) - val templateOemYes = NetworkTemplate(matchType, matchSubscriberIds, - matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, - DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_YES) - val templateOemAll = NetworkTemplate(matchType, matchSubscriberIds, - matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, - DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL) + val templateOemYes = NetworkTemplate( + matchType, + matchSubscriberIds, + matchWifiNetworkKeys, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_YES + ) + val templateOemAll = NetworkTemplate( + matchType, + matchSubscriberIds, + matchWifiNetworkKeys, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + OEM_MANAGED_ALL + ) for (identityOemManagedState in oemManagedStates) { - val ident = buildNetworkIdentity(mockContext, buildNetworkState(networkType, - subscriberId, identWifiKey, identityOemManagedState), - /*defaultNetwork=*/false, /*subType=*/0) + val ident = buildNetworkIdentity( + mockContext, + buildNetworkState( + networkType, + subscriberId, + identWifiKey, + identityOemManagedState + ), + false /* defaultNetwork */, + 0 /* subType */ + ) // Create a template with each OEM managed type and match it against the NetworkIdentity for (templateOemManagedState in oemManagedStates) { - val template = NetworkTemplate(matchType, matchSubscriberIds, - matchWifiNetworkKeys, METERED_ALL, ROAMING_ALL, - DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, templateOemManagedState) + val template = NetworkTemplate( + matchType, + matchSubscriberIds, + matchWifiNetworkKeys, + METERED_ALL, + ROAMING_ALL, + DEFAULT_NETWORK_ALL, + NETWORK_TYPE_ALL, + templateOemManagedState + ) if (identityOemManagedState == templateOemManagedState) { template.assertMatches(ident) } else { @@ -616,29 +877,54 @@ class NetworkTemplateTest { fun testOemManagedMatchesIdent() { matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE, subscriberId = TEST_IMSI1) matchOemManagedIdent(TYPE_MOBILE, MATCH_MOBILE) - matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, templateWifiKey = TEST_WIFI_KEY1, - identWifiKey = TEST_WIFI_KEY1) + matchOemManagedIdent( + TYPE_WIFI, + MATCH_WIFI, + templateWifiKey = TEST_WIFI_KEY1, + identWifiKey = TEST_WIFI_KEY1 + ) matchOemManagedIdent(TYPE_WIFI, MATCH_WIFI, identWifiKey = TEST_WIFI_KEY1) } @Test fun testNormalize() { var mergedImsiList = arrayOf(TEST_IMSI1, TEST_IMSI2) - val identMobileImsi1 = buildNetworkIdentity(mockContext, - buildMobileNetworkState(TEST_IMSI1), false /* defaultNetwork */, - TelephonyManager.NETWORK_TYPE_UMTS) - val identMobileImsi2 = buildNetworkIdentity(mockContext, - buildMobileNetworkState(TEST_IMSI2), false /* defaultNetwork */, - TelephonyManager.NETWORK_TYPE_UMTS) - val identMobileImsi3 = buildNetworkIdentity(mockContext, - buildMobileNetworkState(TEST_IMSI3), false /* defaultNetwork */, - TelephonyManager.NETWORK_TYPE_UMTS) + val identMobileImsi1 = buildNetworkIdentity( + mockContext, + buildMobileNetworkState(TEST_IMSI1), + false /* defaultNetwork */, + TelephonyManager.NETWORK_TYPE_UMTS + ) + val identMobileImsi2 = buildNetworkIdentity( + mockContext, + buildMobileNetworkState(TEST_IMSI2), + false /* defaultNetwork */, + TelephonyManager.NETWORK_TYPE_UMTS + ) + val identMobileImsi3 = buildNetworkIdentity( + mockContext, + buildMobileNetworkState(TEST_IMSI3), + false /* defaultNetwork */, + TelephonyManager.NETWORK_TYPE_UMTS + ) val identWifiImsi1Key1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI1, TEST_WIFI_KEY1), + true, + 0 + ) val identWifiImsi2Key1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI2, TEST_WIFI_KEY1), + true, + 0 + ) val identWifiImsi3WifiKey1 = buildNetworkIdentity( - mockContext, buildWifiNetworkState(TEST_IMSI3, TEST_WIFI_KEY1), true, 0) + mockContext, + buildWifiNetworkState(TEST_IMSI3, TEST_WIFI_KEY1), + true, + 0 + ) normalize(buildTemplateMobileAll(TEST_IMSI1), mergedImsiList).also { it.assertMatches(identMobileImsi1)