1 /* 2 * Copyright (C) 2017 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 static android.net.NetworkCapabilities.LINK_BANDWIDTH_UNSPECIFIED; 20 import static android.net.NetworkCapabilities.MAX_TRANSPORT; 21 import static android.net.NetworkCapabilities.MIN_TRANSPORT; 22 import static android.net.NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL; 23 import static android.net.NetworkCapabilities.NET_CAPABILITY_CBS; 24 import static android.net.NetworkCapabilities.NET_CAPABILITY_EIMS; 25 import static android.net.NetworkCapabilities.NET_CAPABILITY_ENTERPRISE; 26 import static android.net.NetworkCapabilities.NET_CAPABILITY_FOREGROUND; 27 import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET; 28 import static android.net.NetworkCapabilities.NET_CAPABILITY_MMS; 29 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED; 30 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED; 31 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING; 32 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED; 33 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN; 34 import static android.net.NetworkCapabilities.NET_CAPABILITY_OEM_PAID; 35 import static android.net.NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE; 36 import static android.net.NetworkCapabilities.NET_CAPABILITY_PARTIAL_CONNECTIVITY; 37 import static android.net.NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH; 38 import static android.net.NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY; 39 import static android.net.NetworkCapabilities.NET_CAPABILITY_TRUSTED; 40 import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED; 41 import static android.net.NetworkCapabilities.NET_CAPABILITY_WIFI_P2P; 42 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_1; 43 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_2; 44 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_3; 45 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_4; 46 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_5; 47 import static android.net.NetworkCapabilities.REDACT_FOR_ACCESS_FINE_LOCATION; 48 import static android.net.NetworkCapabilities.REDACT_FOR_LOCAL_MAC_ADDRESS; 49 import static android.net.NetworkCapabilities.REDACT_FOR_NETWORK_SETTINGS; 50 import static android.net.NetworkCapabilities.SIGNAL_STRENGTH_UNSPECIFIED; 51 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR; 52 import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET; 53 import static android.net.NetworkCapabilities.TRANSPORT_TEST; 54 import static android.net.NetworkCapabilities.TRANSPORT_USB; 55 import static android.net.NetworkCapabilities.TRANSPORT_VPN; 56 import static android.net.NetworkCapabilities.TRANSPORT_WIFI; 57 import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE; 58 import static android.os.Process.INVALID_UID; 59 60 import static com.android.modules.utils.build.SdkLevel.isAtLeastR; 61 import static com.android.modules.utils.build.SdkLevel.isAtLeastS; 62 import static com.android.modules.utils.build.SdkLevel.isAtLeastT; 63 import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2; 64 import static com.android.testutils.MiscAsserts.assertEmpty; 65 import static com.android.testutils.MiscAsserts.assertThrows; 66 import static com.android.testutils.ParcelUtils.assertParcelingIsLossless; 67 68 import static org.junit.Assert.assertArrayEquals; 69 import static org.junit.Assert.assertEquals; 70 import static org.junit.Assert.assertFalse; 71 import static org.junit.Assert.assertNotEquals; 72 import static org.junit.Assert.assertNull; 73 import static org.junit.Assert.assertTrue; 74 import static org.junit.Assert.fail; 75 import static org.junit.Assume.assumeTrue; 76 77 import android.net.wifi.aware.DiscoverySession; 78 import android.net.wifi.aware.PeerHandle; 79 import android.net.wifi.aware.WifiAwareNetworkSpecifier; 80 import android.os.Build; 81 import android.test.suitebuilder.annotation.SmallTest; 82 import android.util.ArraySet; 83 import android.util.Range; 84 85 import com.android.testutils.CompatUtil; 86 import com.android.testutils.ConnectivityModuleTest; 87 import com.android.testutils.DevSdkIgnoreRule; 88 import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo; 89 import com.android.testutils.DevSdkIgnoreRunner; 90 91 import org.junit.Rule; 92 import org.junit.Test; 93 import org.junit.runner.RunWith; 94 import org.mockito.Mockito; 95 96 import java.util.ArrayList; 97 import java.util.Arrays; 98 import java.util.List; 99 import java.util.Set; 100 101 @SmallTest 102 @RunWith(DevSdkIgnoreRunner.class) 103 // NetworkCapabilities is only updatable on S+, and this test covers behavior which implementation 104 // is self-contained within NetworkCapabilities.java, so it does not need to be run on, or 105 // compatible with, earlier releases. 106 @IgnoreUpTo(Build.VERSION_CODES.R) 107 @ConnectivityModuleTest 108 public class NetworkCapabilitiesTest { 109 private static final String TEST_SSID = "TEST_SSID"; 110 private static final String DIFFERENT_TEST_SSID = "DIFFERENT_TEST_SSID"; 111 private static final int TEST_SUBID1 = 1; 112 private static final int TEST_SUBID2 = 2; 113 private static final int TEST_SUBID3 = 3; 114 115 @Rule 116 public DevSdkIgnoreRule mDevSdkIgnoreRule = new DevSdkIgnoreRule(); 117 118 private DiscoverySession mDiscoverySession = Mockito.mock(DiscoverySession.class); 119 private PeerHandle mPeerHandle = Mockito.mock(PeerHandle.class); 120 121 @Test testMaybeMarkCapabilitiesRestricted()122 public void testMaybeMarkCapabilitiesRestricted() { 123 // check that internet does not get restricted 124 NetworkCapabilities netCap = new NetworkCapabilities(); 125 netCap.addCapability(NET_CAPABILITY_INTERNET); 126 netCap.maybeMarkCapabilitiesRestricted(); 127 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 128 129 // metered-ness shouldn't matter 130 netCap = new NetworkCapabilities(); 131 netCap.addCapability(NET_CAPABILITY_INTERNET); 132 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 133 netCap.maybeMarkCapabilitiesRestricted(); 134 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 135 netCap = new NetworkCapabilities(); 136 netCap.addCapability(NET_CAPABILITY_INTERNET); 137 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 138 netCap.maybeMarkCapabilitiesRestricted(); 139 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 140 141 // add EIMS - bundled with unrestricted means it's unrestricted 142 netCap = new NetworkCapabilities(); 143 netCap.addCapability(NET_CAPABILITY_INTERNET); 144 netCap.addCapability(NET_CAPABILITY_EIMS); 145 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 146 netCap.maybeMarkCapabilitiesRestricted(); 147 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 148 netCap = new NetworkCapabilities(); 149 netCap.addCapability(NET_CAPABILITY_INTERNET); 150 netCap.addCapability(NET_CAPABILITY_EIMS); 151 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 152 netCap.maybeMarkCapabilitiesRestricted(); 153 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 154 155 // just a restricted cap should be restricted regardless of meteredness 156 netCap = new NetworkCapabilities(); 157 netCap.addCapability(NET_CAPABILITY_EIMS); 158 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 159 netCap.maybeMarkCapabilitiesRestricted(); 160 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 161 netCap = new NetworkCapabilities(); 162 netCap.addCapability(NET_CAPABILITY_EIMS); 163 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 164 netCap.maybeMarkCapabilitiesRestricted(); 165 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 166 167 // try 2 restricted caps 168 netCap = new NetworkCapabilities(); 169 netCap.addCapability(NET_CAPABILITY_CBS); 170 netCap.addCapability(NET_CAPABILITY_EIMS); 171 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 172 netCap.maybeMarkCapabilitiesRestricted(); 173 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 174 netCap = new NetworkCapabilities(); 175 netCap.addCapability(NET_CAPABILITY_CBS); 176 netCap.addCapability(NET_CAPABILITY_EIMS); 177 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 178 netCap.maybeMarkCapabilitiesRestricted(); 179 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 180 } 181 182 @Test testDescribeImmutableDifferences()183 public void testDescribeImmutableDifferences() { 184 NetworkCapabilities nc1; 185 NetworkCapabilities nc2; 186 187 // Transports changing 188 nc1 = new NetworkCapabilities().addTransportType(TRANSPORT_CELLULAR); 189 nc2 = new NetworkCapabilities().addTransportType(TRANSPORT_WIFI); 190 assertNotEquals("", nc1.describeImmutableDifferences(nc2)); 191 assertEquals("", nc1.describeImmutableDifferences(nc1)); 192 193 // Mutable capability changing 194 nc1 = new NetworkCapabilities().addCapability(NET_CAPABILITY_VALIDATED); 195 nc2 = new NetworkCapabilities(); 196 assertEquals("", nc1.describeImmutableDifferences(nc2)); 197 assertEquals("", nc1.describeImmutableDifferences(nc1)); 198 199 // NOT_METERED changing (http://b/63326103) 200 nc1 = new NetworkCapabilities() 201 .addCapability(NET_CAPABILITY_NOT_METERED) 202 .addCapability(NET_CAPABILITY_INTERNET); 203 nc2 = new NetworkCapabilities().addCapability(NET_CAPABILITY_INTERNET); 204 assertEquals("", nc1.describeImmutableDifferences(nc2)); 205 assertEquals("", nc1.describeImmutableDifferences(nc1)); 206 207 // Immutable capability changing 208 nc1 = new NetworkCapabilities() 209 .addCapability(NET_CAPABILITY_INTERNET) 210 .removeCapability(NET_CAPABILITY_NOT_RESTRICTED); 211 nc2 = new NetworkCapabilities().addCapability(NET_CAPABILITY_INTERNET); 212 assertNotEquals("", nc1.describeImmutableDifferences(nc2)); 213 assertEquals("", nc1.describeImmutableDifferences(nc1)); 214 215 // Specifier changing 216 nc1 = new NetworkCapabilities().addTransportType(TRANSPORT_WIFI); 217 nc2 = new NetworkCapabilities() 218 .addTransportType(TRANSPORT_WIFI) 219 .setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier("eth42")); 220 assertNotEquals("", nc1.describeImmutableDifferences(nc2)); 221 assertEquals("", nc1.describeImmutableDifferences(nc1)); 222 } 223 224 @Test testLinkBandwidthUtils()225 public void testLinkBandwidthUtils() { 226 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, NetworkCapabilities 227 .minBandwidth(LINK_BANDWIDTH_UNSPECIFIED, LINK_BANDWIDTH_UNSPECIFIED)); 228 assertEquals(10, NetworkCapabilities 229 .minBandwidth(LINK_BANDWIDTH_UNSPECIFIED, 10)); 230 assertEquals(10, NetworkCapabilities 231 .minBandwidth(10, LINK_BANDWIDTH_UNSPECIFIED)); 232 assertEquals(10, NetworkCapabilities 233 .minBandwidth(10, 20)); 234 235 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, NetworkCapabilities 236 .maxBandwidth(LINK_BANDWIDTH_UNSPECIFIED, LINK_BANDWIDTH_UNSPECIFIED)); 237 assertEquals(10, NetworkCapabilities 238 .maxBandwidth(LINK_BANDWIDTH_UNSPECIFIED, 10)); 239 assertEquals(10, NetworkCapabilities 240 .maxBandwidth(10, LINK_BANDWIDTH_UNSPECIFIED)); 241 assertEquals(20, NetworkCapabilities 242 .maxBandwidth(10, 20)); 243 } 244 245 @Test testSetUids()246 public void testSetUids() { 247 final NetworkCapabilities netCap = new NetworkCapabilities(); 248 // Null uids match all UIDs 249 netCap.setUids(null); 250 assertTrue(netCap.appliesToUid(10)); 251 assertTrue(netCap.appliesToUid(200)); 252 assertTrue(netCap.appliesToUid(3000)); 253 assertTrue(netCap.appliesToUid(10010)); 254 assertTrue(netCap.appliesToUidRange(new UidRange(50, 100))); 255 assertTrue(netCap.appliesToUidRange(new UidRange(70, 72))); 256 assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912))); 257 assertTrue(netCap.appliesToUidRange(new UidRange(1, 100000))); 258 259 if (isAtLeastS()) { 260 final Set<Range<Integer>> uids = new ArraySet<>(); 261 uids.add(uidRange(50, 100)); 262 uids.add(uidRange(3000, 4000)); 263 netCap.setUids(uids); 264 assertTrue(netCap.appliesToUid(50)); 265 assertTrue(netCap.appliesToUid(80)); 266 assertTrue(netCap.appliesToUid(100)); 267 assertTrue(netCap.appliesToUid(3000)); 268 assertTrue(netCap.appliesToUid(3001)); 269 assertFalse(netCap.appliesToUid(10)); 270 assertFalse(netCap.appliesToUid(25)); 271 assertFalse(netCap.appliesToUid(49)); 272 assertFalse(netCap.appliesToUid(101)); 273 assertFalse(netCap.appliesToUid(2000)); 274 assertFalse(netCap.appliesToUid(100000)); 275 276 assertTrue(netCap.appliesToUidRange(new UidRange(50, 100))); 277 assertTrue(netCap.appliesToUidRange(new UidRange(70, 72))); 278 assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912))); 279 assertFalse(netCap.appliesToUidRange(new UidRange(1, 100))); 280 assertFalse(netCap.appliesToUidRange(new UidRange(49, 100))); 281 assertFalse(netCap.appliesToUidRange(new UidRange(1, 10))); 282 assertFalse(netCap.appliesToUidRange(new UidRange(60, 101))); 283 assertFalse(netCap.appliesToUidRange(new UidRange(60, 3400))); 284 285 NetworkCapabilities netCap2 = new NetworkCapabilities(); 286 // A new netcap object has null UIDs, so anything will satisfy it. 287 assertTrue(netCap2.satisfiedByUids(netCap)); 288 // Still not equal though. 289 assertFalse(netCap2.equalsUids(netCap)); 290 netCap2.setUids(uids); 291 assertTrue(netCap2.satisfiedByUids(netCap)); 292 assertTrue(netCap.equalsUids(netCap2)); 293 assertTrue(netCap2.equalsUids(netCap)); 294 295 uids.add(uidRange(600, 700)); 296 netCap2.setUids(uids); 297 assertFalse(netCap2.satisfiedByUids(netCap)); 298 assertFalse(netCap.appliesToUid(650)); 299 assertTrue(netCap2.appliesToUid(650)); 300 netCap.setUids(uids); 301 assertTrue(netCap2.satisfiedByUids(netCap)); 302 assertTrue(netCap.appliesToUid(650)); 303 assertFalse(netCap.appliesToUid(500)); 304 305 // Null uids satisfies everything. 306 netCap.setUids(null); 307 assertTrue(netCap2.satisfiedByUids(netCap)); 308 assertTrue(netCap.satisfiedByUids(netCap2)); 309 netCap2.setUids(null); 310 assertTrue(netCap2.satisfiedByUids(netCap)); 311 assertTrue(netCap.satisfiedByUids(netCap2)); 312 } 313 } 314 315 @Test @IgnoreUpTo(SC_V2) testSetAllowedUids()316 public void testSetAllowedUids() { 317 final NetworkCapabilities nc = new NetworkCapabilities(); 318 assertThrows(NullPointerException.class, () -> nc.setAllowedUids(null)); 319 assertFalse(nc.hasAllowedUids()); 320 assertFalse(nc.isUidWithAccess(0)); 321 assertFalse(nc.isUidWithAccess(1000)); 322 assertEquals(0, nc.getAllowedUids().size()); 323 nc.setAllowedUids(new ArraySet<>()); 324 assertFalse(nc.hasAllowedUids()); 325 assertFalse(nc.isUidWithAccess(0)); 326 assertFalse(nc.isUidWithAccess(1000)); 327 assertEquals(0, nc.getAllowedUids().size()); 328 329 final ArraySet<Integer> uids = new ArraySet<>(); 330 uids.add(200); 331 uids.add(250); 332 uids.add(-1); 333 uids.add(Integer.MAX_VALUE); 334 nc.setAllowedUids(uids); 335 assertNotEquals(nc, new NetworkCapabilities()); 336 assertTrue(nc.hasAllowedUids()); 337 338 final List<Integer> includedList = List.of(-2, 0, 199, 700, 901, 1000, Integer.MIN_VALUE); 339 final List<Integer> excludedList = List.of(-1, 200, 250, Integer.MAX_VALUE); 340 for (final int uid : includedList) { 341 assertFalse(nc.isUidWithAccess(uid)); 342 } 343 for (final int uid : excludedList) { 344 assertTrue(nc.isUidWithAccess(uid)); 345 } 346 347 final Set<Integer> outUids = nc.getAllowedUids(); 348 assertEquals(4, outUids.size()); 349 for (final int uid : includedList) { 350 assertFalse(outUids.contains(uid)); 351 } 352 for (final int uid : excludedList) { 353 assertTrue(outUids.contains(uid)); 354 } 355 } 356 357 @Test testParcelNetworkCapabilities()358 public void testParcelNetworkCapabilities() { 359 final Set<Range<Integer>> uids = new ArraySet<>(); 360 uids.add(uidRange(50, 100)); 361 uids.add(uidRange(3000, 4000)); 362 final NetworkCapabilities netCap = new NetworkCapabilities() 363 .addCapability(NET_CAPABILITY_INTERNET) 364 .addCapability(NET_CAPABILITY_EIMS) 365 .addCapability(NET_CAPABILITY_NOT_METERED); 366 if (isAtLeastS()) { 367 final ArraySet<Integer> allowedUids = new ArraySet<>(); 368 allowedUids.add(4); 369 allowedUids.add(9); 370 netCap.setAllowedUids(allowedUids); 371 netCap.setSubscriptionIds(Set.of(TEST_SUBID1, TEST_SUBID2)); 372 netCap.setUids(uids); 373 } 374 if (isAtLeastR()) { 375 netCap.setOwnerUid(123); 376 netCap.setAdministratorUids(new int[] {5, 11}); 377 } 378 assertParcelingIsLossless(netCap); 379 netCap.setSSID(TEST_SSID); 380 testParcelSane(netCap); 381 } 382 383 @Test testParcelNetworkCapabilitiesWithRequestorUidAndPackageName()384 public void testParcelNetworkCapabilitiesWithRequestorUidAndPackageName() { 385 final NetworkCapabilities netCap = new NetworkCapabilities() 386 .addCapability(NET_CAPABILITY_INTERNET) 387 .addCapability(NET_CAPABILITY_EIMS) 388 .addCapability(NET_CAPABILITY_NOT_METERED); 389 if (isAtLeastR()) { 390 netCap.setRequestorPackageName("com.android.test"); 391 netCap.setRequestorUid(9304); 392 } 393 assertParcelingIsLossless(netCap); 394 netCap.setSSID(TEST_SSID); 395 testParcelSane(netCap); 396 } 397 testParcelSane(NetworkCapabilities cap)398 private void testParcelSane(NetworkCapabilities cap) { 399 assertParcelingIsLossless(cap); 400 } 401 createNetworkCapabilitiesWithTransportInfo()402 private static NetworkCapabilities createNetworkCapabilitiesWithTransportInfo() { 403 return new NetworkCapabilities() 404 .addCapability(NET_CAPABILITY_INTERNET) 405 .addCapability(NET_CAPABILITY_EIMS) 406 .addCapability(NET_CAPABILITY_NOT_METERED) 407 .setSSID(TEST_SSID) 408 .setTransportInfo(new TestTransportInfo()) 409 .setRequestorPackageName("com.android.test") 410 .setRequestorUid(9304); 411 } 412 413 @Test testNetworkCapabilitiesCopyWithNoRedactions()414 public void testNetworkCapabilitiesCopyWithNoRedactions() { 415 assumeTrue(isAtLeastS()); 416 417 final NetworkCapabilities netCap = createNetworkCapabilitiesWithTransportInfo(); 418 final NetworkCapabilities netCapWithNoRedactions = 419 new NetworkCapabilities(netCap, NetworkCapabilities.REDACT_NONE); 420 TestTransportInfo testTransportInfo = 421 (TestTransportInfo) netCapWithNoRedactions.getTransportInfo(); 422 assertFalse(testTransportInfo.locationRedacted); 423 assertFalse(testTransportInfo.localMacAddressRedacted); 424 assertFalse(testTransportInfo.settingsRedacted); 425 } 426 427 @Test testNetworkCapabilitiesCopyWithoutLocationSensitiveFields()428 public void testNetworkCapabilitiesCopyWithoutLocationSensitiveFields() { 429 assumeTrue(isAtLeastS()); 430 431 final NetworkCapabilities netCap = createNetworkCapabilitiesWithTransportInfo(); 432 final NetworkCapabilities netCapWithNoRedactions = 433 new NetworkCapabilities(netCap, REDACT_FOR_ACCESS_FINE_LOCATION); 434 TestTransportInfo testTransportInfo = 435 (TestTransportInfo) netCapWithNoRedactions.getTransportInfo(); 436 assertTrue(testTransportInfo.locationRedacted); 437 assertFalse(testTransportInfo.localMacAddressRedacted); 438 assertFalse(testTransportInfo.settingsRedacted); 439 } 440 441 @Test testOemPaid()442 public void testOemPaid() { 443 NetworkCapabilities nc = new NetworkCapabilities(); 444 // By default OEM_PAID is neither in the required or forbidden lists and the network is not 445 // restricted. 446 if (isAtLeastS()) { 447 assertFalse(nc.hasForbiddenCapability(NET_CAPABILITY_OEM_PAID)); 448 } 449 assertFalse(nc.hasCapability(NET_CAPABILITY_OEM_PAID)); 450 nc.maybeMarkCapabilitiesRestricted(); 451 assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 452 453 // Adding OEM_PAID to capability list should make network restricted. 454 nc.addCapability(NET_CAPABILITY_OEM_PAID); 455 nc.addCapability(NET_CAPABILITY_INTERNET); // Combine with unrestricted capability. 456 nc.maybeMarkCapabilitiesRestricted(); 457 assertTrue(nc.hasCapability(NET_CAPABILITY_OEM_PAID)); 458 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 459 460 // Now let's make request for OEM_PAID network. 461 NetworkCapabilities nr = new NetworkCapabilities(); 462 nr.addCapability(NET_CAPABILITY_OEM_PAID); 463 nr.maybeMarkCapabilitiesRestricted(); 464 assertTrue(nr.satisfiedByNetworkCapabilities(nc)); 465 466 // Request fails for network with the default capabilities. 467 assertFalse(nr.satisfiedByNetworkCapabilities(new NetworkCapabilities())); 468 } 469 470 @Test @IgnoreUpTo(SC_V2) // TODO: Use to Build.VERSION_CODES.SC_V2 when available testPrioritizeLatencyAndBandwidth()471 public void testPrioritizeLatencyAndBandwidth() { 472 NetworkCapabilities netCap = new NetworkCapabilities(); 473 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_LATENCY); 474 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 475 netCap.maybeMarkCapabilitiesRestricted(); 476 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 477 netCap = new NetworkCapabilities(); 478 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_LATENCY); 479 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 480 netCap.maybeMarkCapabilitiesRestricted(); 481 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 482 483 netCap = new NetworkCapabilities(); 484 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_BANDWIDTH); 485 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 486 netCap.maybeMarkCapabilitiesRestricted(); 487 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 488 netCap = new NetworkCapabilities(); 489 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_BANDWIDTH); 490 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 491 netCap.maybeMarkCapabilitiesRestricted(); 492 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 493 } 494 495 @Test testOemPrivate()496 public void testOemPrivate() { 497 NetworkCapabilities nc = new NetworkCapabilities(); 498 // By default OEM_PRIVATE is neither in the required or forbidden lists and the network is 499 // not restricted. 500 assertFalse(nc.hasForbiddenCapability(NET_CAPABILITY_OEM_PRIVATE)); 501 assertFalse(nc.hasCapability(NET_CAPABILITY_OEM_PRIVATE)); 502 nc.maybeMarkCapabilitiesRestricted(); 503 assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 504 505 // Adding OEM_PRIVATE to capability list should make network restricted. 506 nc.addCapability(NET_CAPABILITY_OEM_PRIVATE); 507 nc.addCapability(NET_CAPABILITY_INTERNET); // Combine with unrestricted capability. 508 nc.maybeMarkCapabilitiesRestricted(); 509 assertTrue(nc.hasCapability(NET_CAPABILITY_OEM_PRIVATE)); 510 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 511 512 // Now let's make request for OEM_PRIVATE network. 513 NetworkCapabilities nr = new NetworkCapabilities(); 514 nr.addCapability(NET_CAPABILITY_OEM_PRIVATE); 515 nr.maybeMarkCapabilitiesRestricted(); 516 assertTrue(nr.satisfiedByNetworkCapabilities(nc)); 517 518 // Request fails for network with the default capabilities. 519 assertFalse(nr.satisfiedByNetworkCapabilities(new NetworkCapabilities())); 520 } 521 522 @Test testForbiddenCapabilities()523 public void testForbiddenCapabilities() { 524 NetworkCapabilities network = new NetworkCapabilities(); 525 526 NetworkCapabilities request = new NetworkCapabilities(); 527 assertTrue("Request: " + request + ", Network:" + network, 528 request.satisfiedByNetworkCapabilities(network)); 529 530 // Requesting absence of capabilities that network doesn't have. Request should satisfy. 531 request.addForbiddenCapability(NET_CAPABILITY_WIFI_P2P); 532 request.addForbiddenCapability(NET_CAPABILITY_NOT_METERED); 533 assertTrue(request.satisfiedByNetworkCapabilities(network)); 534 assertArrayEquals(new int[]{NET_CAPABILITY_WIFI_P2P, 535 NET_CAPABILITY_NOT_METERED}, 536 request.getForbiddenCapabilities()); 537 538 // This is a default capability, just want to make sure its there because we use it below. 539 assertTrue(network.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 540 541 // Verify that adding forbidden capability will effectively remove it from capability list. 542 request.addForbiddenCapability(NET_CAPABILITY_NOT_RESTRICTED); 543 assertTrue(request.hasForbiddenCapability(NET_CAPABILITY_NOT_RESTRICTED)); 544 assertFalse(request.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 545 546 // Now this request won't be satisfied because network contains NOT_RESTRICTED. 547 assertFalse(request.satisfiedByNetworkCapabilities(network)); 548 network.removeCapability(NET_CAPABILITY_NOT_RESTRICTED); 549 assertTrue(request.satisfiedByNetworkCapabilities(network)); 550 551 // Verify that adding capability will effectively remove it from forbidden list 552 request.addCapability(NET_CAPABILITY_NOT_RESTRICTED); 553 assertTrue(request.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 554 assertFalse(request.hasForbiddenCapability(NET_CAPABILITY_NOT_RESTRICTED)); 555 556 assertFalse(request.satisfiedByNetworkCapabilities(network)); 557 network.addCapability(NET_CAPABILITY_NOT_RESTRICTED); 558 assertTrue(request.satisfiedByNetworkCapabilities(network)); 559 } 560 561 @Test testConnectivityManagedCapabilities()562 public void testConnectivityManagedCapabilities() { 563 NetworkCapabilities nc = new NetworkCapabilities(); 564 assertFalse(nc.hasConnectivityManagedCapability()); 565 // Check every single system managed capability. 566 nc.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL); 567 assertTrue(nc.hasConnectivityManagedCapability()); 568 nc.removeCapability(NET_CAPABILITY_CAPTIVE_PORTAL); 569 nc.addCapability(NET_CAPABILITY_FOREGROUND); 570 assertTrue(nc.hasConnectivityManagedCapability()); 571 nc.removeCapability(NET_CAPABILITY_FOREGROUND); 572 nc.addCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY); 573 assertTrue(nc.hasConnectivityManagedCapability()); 574 nc.removeCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY); 575 nc.addCapability(NET_CAPABILITY_VALIDATED); 576 assertTrue(nc.hasConnectivityManagedCapability()); 577 } 578 579 @Test testEqualsNetCapabilities()580 public void testEqualsNetCapabilities() { 581 NetworkCapabilities nc1 = new NetworkCapabilities(); 582 NetworkCapabilities nc2 = new NetworkCapabilities(); 583 assertTrue(nc1.equalsNetCapabilities(nc2)); 584 assertEquals(nc1, nc2); 585 586 nc1.addCapability(NET_CAPABILITY_MMS); 587 assertFalse(nc1.equalsNetCapabilities(nc2)); 588 assertNotEquals(nc1, nc2); 589 nc2.addCapability(NET_CAPABILITY_MMS); 590 assertTrue(nc1.equalsNetCapabilities(nc2)); 591 assertEquals(nc1, nc2); 592 593 if (isAtLeastS()) { 594 nc1.addForbiddenCapability(NET_CAPABILITY_INTERNET); 595 assertFalse(nc1.equalsNetCapabilities(nc2)); 596 nc2.addForbiddenCapability(NET_CAPABILITY_INTERNET); 597 assertTrue(nc1.equalsNetCapabilities(nc2)); 598 599 // Remove a required capability doesn't affect forbidden capabilities. 600 // This is a behaviour change from R to S. 601 nc1.removeCapability(NET_CAPABILITY_INTERNET); 602 assertTrue(nc1.equalsNetCapabilities(nc2)); 603 604 nc1.removeForbiddenCapability(NET_CAPABILITY_INTERNET); 605 assertFalse(nc1.equalsNetCapabilities(nc2)); 606 nc2.removeForbiddenCapability(NET_CAPABILITY_INTERNET); 607 assertTrue(nc1.equalsNetCapabilities(nc2)); 608 } 609 } 610 611 @Test testSSID()612 public void testSSID() { 613 NetworkCapabilities nc1 = new NetworkCapabilities(); 614 NetworkCapabilities nc2 = new NetworkCapabilities(); 615 assertTrue(nc2.satisfiedBySSID(nc1)); 616 617 nc1.setSSID(TEST_SSID); 618 assertTrue(nc2.satisfiedBySSID(nc1)); 619 nc2.setSSID("different " + TEST_SSID); 620 assertFalse(nc2.satisfiedBySSID(nc1)); 621 622 assertTrue(nc1.satisfiedByImmutableNetworkCapabilities(nc2)); 623 assertFalse(nc1.satisfiedByNetworkCapabilities(nc2)); 624 } 625 uidRanges(int from, int to)626 private ArraySet<Range<Integer>> uidRanges(int from, int to) { 627 final ArraySet<Range<Integer>> range = new ArraySet<>(1); 628 range.add(uidRange(from, to)); 629 return range; 630 } 631 uidRange(int from, int to)632 private Range<Integer> uidRange(int from, int to) { 633 return new Range<Integer>(from, to); 634 } 635 636 @Test testSetAdministratorUids()637 public void testSetAdministratorUids() { 638 NetworkCapabilities nc = 639 new NetworkCapabilities().setAdministratorUids(new int[] {2, 1, 3}); 640 641 assertArrayEquals(new int[] {1, 2, 3}, nc.getAdministratorUids()); 642 } 643 644 @Test testSetAdministratorUidsWithDuplicates()645 public void testSetAdministratorUidsWithDuplicates() { 646 try { 647 new NetworkCapabilities().setAdministratorUids(new int[] {1, 1}); 648 fail("Expected IllegalArgumentException for duplicate uids"); 649 } catch (IllegalArgumentException expected) { 650 } 651 } 652 653 @Test testSetCapabilities()654 public void testSetCapabilities() { 655 final int[] REQUIRED_CAPABILITIES = new int[] { 656 NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN }; 657 658 NetworkCapabilities nc1 = new NetworkCapabilities(); 659 NetworkCapabilities nc2 = new NetworkCapabilities(); 660 661 nc1.setCapabilities(REQUIRED_CAPABILITIES); 662 assertArrayEquals(REQUIRED_CAPABILITIES, nc1.getCapabilities()); 663 664 // Verify that setting and adding capabilities leads to the same object state. 665 nc2.clearAll(); 666 for (int cap : REQUIRED_CAPABILITIES) { 667 nc2.addCapability(cap); 668 } 669 assertEquals(nc1, nc2); 670 671 if (isAtLeastS()) { 672 final int[] forbiddenCapabilities = new int[]{ 673 NET_CAPABILITY_NOT_METERED, NET_CAPABILITY_NOT_RESTRICTED }; 674 675 nc1.setCapabilities(REQUIRED_CAPABILITIES, forbiddenCapabilities); 676 assertArrayEquals(REQUIRED_CAPABILITIES, nc1.getCapabilities()); 677 assertArrayEquals(forbiddenCapabilities, nc1.getForbiddenCapabilities()); 678 679 nc2.clearAll(); 680 for (int cap : REQUIRED_CAPABILITIES) { 681 nc2.addCapability(cap); 682 } 683 for (int cap : forbiddenCapabilities) { 684 nc2.addForbiddenCapability(cap); 685 } 686 assertEquals(nc1, nc2); 687 } 688 } 689 690 @Test testUnderlyingNetworks()691 public void testUnderlyingNetworks() { 692 assumeTrue(isAtLeastT()); 693 final NetworkCapabilities nc = new NetworkCapabilities(); 694 final Network network1 = new Network(100); 695 final Network network2 = new Network(101); 696 final ArrayList<Network> inputNetworks = new ArrayList<>(); 697 inputNetworks.add(network1); 698 inputNetworks.add(network2); 699 nc.setUnderlyingNetworks(inputNetworks); 700 final ArrayList<Network> outputNetworks = new ArrayList<>(nc.getUnderlyingNetworks()); 701 assertEquals(network1, outputNetworks.get(0)); 702 assertEquals(network2, outputNetworks.get(1)); 703 nc.setUnderlyingNetworks(null); 704 assertNull(nc.getUnderlyingNetworks()); 705 } 706 707 @Test testEqualsForUnderlyingNetworks()708 public void testEqualsForUnderlyingNetworks() { 709 assumeTrue(isAtLeastT()); 710 final NetworkCapabilities nc1 = new NetworkCapabilities(); 711 final NetworkCapabilities nc2 = new NetworkCapabilities(); 712 assertEquals(nc1, nc2); 713 final Network network = new Network(100); 714 final ArrayList<Network> inputNetworks = new ArrayList<>(); 715 final ArrayList<Network> emptyList = new ArrayList<>(); 716 inputNetworks.add(network); 717 nc1.setUnderlyingNetworks(inputNetworks); 718 assertNotEquals(nc1, nc2); 719 nc2.setUnderlyingNetworks(inputNetworks); 720 assertEquals(nc1, nc2); 721 nc1.setUnderlyingNetworks(emptyList); 722 assertNotEquals(nc1, nc2); 723 nc2.setUnderlyingNetworks(emptyList); 724 assertEquals(nc1, nc2); 725 nc1.setUnderlyingNetworks(null); 726 assertNotEquals(nc1, nc2); 727 nc2.setUnderlyingNetworks(null); 728 assertEquals(nc1, nc2); 729 } 730 731 @Test testSetNetworkSpecifierOnMultiTransportNc()732 public void testSetNetworkSpecifierOnMultiTransportNc() { 733 // Sequence 1: Transport + Transport + NetworkSpecifier 734 NetworkCapabilities.Builder nc1 = new NetworkCapabilities.Builder(); 735 nc1.addTransportType(TRANSPORT_CELLULAR).addTransportType(TRANSPORT_WIFI); 736 final NetworkSpecifier specifier = CompatUtil.makeEthernetNetworkSpecifier("eth0"); 737 assertThrows("Cannot set NetworkSpecifier on a NetworkCapability with multiple transports!", 738 IllegalStateException.class, 739 () -> nc1.build().setNetworkSpecifier(specifier)); 740 assertThrows("Cannot set NetworkSpecifier on a NetworkCapability with multiple transports!", 741 IllegalStateException.class, 742 () -> nc1.setNetworkSpecifier(specifier)); 743 744 // Sequence 2: Transport + NetworkSpecifier + Transport 745 NetworkCapabilities.Builder nc2 = new NetworkCapabilities.Builder(); 746 nc2.addTransportType(TRANSPORT_CELLULAR).setNetworkSpecifier(specifier); 747 748 assertThrows("Cannot set a second TransportType of a network which has a NetworkSpecifier!", 749 IllegalStateException.class, 750 () -> nc2.build().addTransportType(TRANSPORT_WIFI)); 751 assertThrows("Cannot set a second TransportType of a network which has a NetworkSpecifier!", 752 IllegalStateException.class, 753 () -> nc2.addTransportType(TRANSPORT_WIFI)); 754 } 755 756 @Test testSetNetworkSpecifierOnTestMultiTransportNc()757 public void testSetNetworkSpecifierOnTestMultiTransportNc() { 758 final NetworkSpecifier specifier = CompatUtil.makeEthernetNetworkSpecifier("eth0"); 759 NetworkCapabilities nc = new NetworkCapabilities.Builder() 760 .addTransportType(TRANSPORT_TEST) 761 .addTransportType(TRANSPORT_ETHERNET) 762 .setNetworkSpecifier(specifier) 763 .build(); 764 // Adding a specifier did not crash with 2 transports if one is TEST 765 assertEquals(specifier, nc.getNetworkSpecifier()); 766 } 767 768 @Test testSetTransportInfoOnMultiTransportNc()769 public void testSetTransportInfoOnMultiTransportNc() { 770 // Sequence 1: Transport + Transport + TransportInfo 771 NetworkCapabilities nc1 = new NetworkCapabilities(); 772 nc1.addTransportType(TRANSPORT_CELLULAR).addTransportType(TRANSPORT_WIFI) 773 .setTransportInfo(new TestTransportInfo()); 774 775 // Sequence 2: Transport + NetworkSpecifier + Transport 776 NetworkCapabilities nc2 = new NetworkCapabilities(); 777 nc2.addTransportType(TRANSPORT_CELLULAR).setTransportInfo(new TestTransportInfo()) 778 .addTransportType(TRANSPORT_WIFI); 779 } 780 781 @Test testSet()782 public void testSet() { 783 NetworkCapabilities nc1 = new NetworkCapabilities(); 784 NetworkCapabilities nc2 = new NetworkCapabilities(); 785 786 if (isAtLeastS()) { 787 nc1.addForbiddenCapability(NET_CAPABILITY_CAPTIVE_PORTAL); 788 } 789 nc1.addCapability(NET_CAPABILITY_NOT_ROAMING); 790 assertNotEquals(nc1, nc2); 791 nc2.set(nc1); 792 assertEquals(nc1, nc2); 793 assertTrue(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING)); 794 if (isAtLeastS()) { 795 assertTrue(nc2.hasForbiddenCapability(NET_CAPABILITY_CAPTIVE_PORTAL)); 796 } 797 798 if (isAtLeastS()) { 799 // This will effectively move NOT_ROAMING capability from required to forbidden for nc1. 800 nc1.addForbiddenCapability(NET_CAPABILITY_NOT_ROAMING); 801 } 802 nc1.setSSID(TEST_SSID); 803 nc2.set(nc1); 804 assertEquals(nc1, nc2); 805 if (isAtLeastS()) { 806 // Contrary to combineCapabilities, set() will have removed the NOT_ROAMING capability 807 // from nc2. 808 assertFalse(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING)); 809 assertTrue(nc2.hasForbiddenCapability(NET_CAPABILITY_NOT_ROAMING)); 810 } 811 812 if (isAtLeastR()) { 813 assertTrue(TEST_SSID.equals(nc2.getSsid())); 814 } 815 816 nc1.setSSID(DIFFERENT_TEST_SSID); 817 nc2.set(nc1); 818 assertEquals(nc1, nc2); 819 if (isAtLeastR()) { 820 assertTrue(DIFFERENT_TEST_SSID.equals(nc2.getSsid())); 821 } 822 if (isAtLeastS()) { 823 nc1.setUids(uidRanges(10, 13)); 824 } else { 825 nc1.setUids(null); 826 } 827 nc2.set(nc1); // Overwrites, as opposed to combineCapabilities 828 assertEquals(nc1, nc2); 829 830 if (isAtLeastS()) { 831 assertThrows(NullPointerException.class, () -> nc1.setSubscriptionIds(null)); 832 nc1.setSubscriptionIds(Set.of()); 833 nc2.set(nc1); 834 assertEquals(nc1, nc2); 835 836 nc1.setSubscriptionIds(Set.of(TEST_SUBID1)); 837 nc2.set(nc1); 838 assertEquals(nc1, nc2); 839 840 nc2.setSubscriptionIds(Set.of(TEST_SUBID2, TEST_SUBID1)); 841 nc2.set(nc1); 842 assertEquals(nc1, nc2); 843 844 nc2.setSubscriptionIds(Set.of(TEST_SUBID3, TEST_SUBID2)); 845 assertNotEquals(nc1, nc2); 846 } 847 } 848 849 @Test testGetTransportTypes()850 public void testGetTransportTypes() { 851 final NetworkCapabilities nc = new NetworkCapabilities(); 852 nc.addTransportType(TRANSPORT_CELLULAR); 853 nc.addTransportType(TRANSPORT_WIFI); 854 nc.addTransportType(TRANSPORT_VPN); 855 nc.addTransportType(TRANSPORT_TEST); 856 857 final int[] transportTypes = nc.getTransportTypes(); 858 assertEquals(4, transportTypes.length); 859 assertEquals(TRANSPORT_CELLULAR, transportTypes[0]); 860 assertEquals(TRANSPORT_WIFI, transportTypes[1]); 861 assertEquals(TRANSPORT_VPN, transportTypes[2]); 862 assertEquals(TRANSPORT_TEST, transportTypes[3]); 863 } 864 865 @Test testTelephonyNetworkSpecifier()866 public void testTelephonyNetworkSpecifier() { 867 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1); 868 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder() 869 .addTransportType(TRANSPORT_WIFI) 870 .setNetworkSpecifier(specifier) 871 .build(); 872 assertEquals(specifier, nc1.getNetworkSpecifier()); 873 try { 874 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 875 .setNetworkSpecifier(specifier) 876 .build(); 877 fail("Must have a single transport type. Without transport type or multiple transport" 878 + " types is invalid."); 879 } catch (IllegalStateException expected) { } 880 } 881 882 @Test @IgnoreUpTo(SC_V2) // TODO: Use to Build.VERSION_CODES.SC_V2 when available testEnterpriseId()883 public void testEnterpriseId() { 884 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder() 885 .addCapability(NET_CAPABILITY_ENTERPRISE) 886 .addEnterpriseId(NET_ENTERPRISE_ID_1) 887 .build(); 888 assertEquals(1, nc1.getEnterpriseIds().length); 889 assertEquals(NET_ENTERPRISE_ID_1, 890 nc1.getEnterpriseIds()[0]); 891 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 892 .addCapability(NET_CAPABILITY_ENTERPRISE) 893 .addEnterpriseId(NET_ENTERPRISE_ID_1) 894 .addEnterpriseId(NET_ENTERPRISE_ID_2) 895 .build(); 896 assertEquals(2, nc2.getEnterpriseIds().length); 897 assertEquals(NET_ENTERPRISE_ID_1, 898 nc2.getEnterpriseIds()[0]); 899 assertEquals(NET_ENTERPRISE_ID_2, 900 nc2.getEnterpriseIds()[1]); 901 final NetworkCapabilities nc3 = new NetworkCapabilities.Builder() 902 .addCapability(NET_CAPABILITY_ENTERPRISE) 903 .addEnterpriseId(NET_ENTERPRISE_ID_1) 904 .addEnterpriseId(NET_ENTERPRISE_ID_2) 905 .addEnterpriseId(NET_ENTERPRISE_ID_3) 906 .addEnterpriseId(NET_ENTERPRISE_ID_4) 907 .addEnterpriseId(NET_ENTERPRISE_ID_5) 908 .build(); 909 assertEquals(5, nc3.getEnterpriseIds().length); 910 assertEquals(NET_ENTERPRISE_ID_1, 911 nc3.getEnterpriseIds()[0]); 912 assertEquals(NET_ENTERPRISE_ID_2, 913 nc3.getEnterpriseIds()[1]); 914 assertEquals(NET_ENTERPRISE_ID_3, 915 nc3.getEnterpriseIds()[2]); 916 assertEquals(NET_ENTERPRISE_ID_4, 917 nc3.getEnterpriseIds()[3]); 918 assertEquals(NET_ENTERPRISE_ID_5, 919 nc3.getEnterpriseIds()[4]); 920 921 final Class<IllegalArgumentException> illegalArgumentExceptionClass = 922 IllegalArgumentException.class; 923 assertThrows(illegalArgumentExceptionClass, () -> new NetworkCapabilities.Builder() 924 .addEnterpriseId(6) 925 .build()); 926 assertThrows(illegalArgumentExceptionClass, () -> new NetworkCapabilities.Builder() 927 .removeEnterpriseId(6) 928 .build()); 929 930 final Class<IllegalStateException> illegalStateException = 931 IllegalStateException.class; 932 assertThrows(illegalStateException, () -> new NetworkCapabilities.Builder() 933 .addEnterpriseId(NET_ENTERPRISE_ID_1) 934 .build()); 935 936 final NetworkCapabilities nc4 = new NetworkCapabilities.Builder() 937 .addCapability(NET_CAPABILITY_ENTERPRISE) 938 .addEnterpriseId(NET_ENTERPRISE_ID_1) 939 .addEnterpriseId(NET_ENTERPRISE_ID_2) 940 .removeEnterpriseId(NET_ENTERPRISE_ID_1) 941 .removeEnterpriseId(NET_ENTERPRISE_ID_2) 942 .build(); 943 assertEquals(1, nc4.getEnterpriseIds().length); 944 assertTrue(nc4.hasEnterpriseId(NET_ENTERPRISE_ID_1)); 945 946 final NetworkCapabilities nc5 = new NetworkCapabilities.Builder() 947 .addCapability(NET_CAPABILITY_CBS) 948 .addEnterpriseId(NET_ENTERPRISE_ID_1) 949 .addEnterpriseId(NET_ENTERPRISE_ID_2) 950 .removeEnterpriseId(NET_ENTERPRISE_ID_1) 951 .removeEnterpriseId(NET_ENTERPRISE_ID_2) 952 .build(); 953 954 assertTrue(nc4.satisfiedByNetworkCapabilities(nc1)); 955 assertTrue(nc1.satisfiedByNetworkCapabilities(nc4)); 956 957 assertFalse(nc3.satisfiedByNetworkCapabilities(nc2)); 958 assertTrue(nc2.satisfiedByNetworkCapabilities(nc3)); 959 960 assertFalse(nc1.satisfiedByNetworkCapabilities(nc5)); 961 assertFalse(nc5.satisfiedByNetworkCapabilities(nc1)); 962 } 963 964 @Test testWifiAwareNetworkSpecifier()965 public void testWifiAwareNetworkSpecifier() { 966 final NetworkCapabilities nc = new NetworkCapabilities() 967 .addTransportType(TRANSPORT_WIFI_AWARE); 968 // If NetworkSpecifier is not set, the default value is null. 969 assertNull(nc.getNetworkSpecifier()); 970 final WifiAwareNetworkSpecifier specifier = new WifiAwareNetworkSpecifier.Builder( 971 mDiscoverySession, mPeerHandle).build(); 972 nc.setNetworkSpecifier(specifier); 973 assertEquals(specifier, nc.getNetworkSpecifier()); 974 } 975 976 @Test testAdministratorUidsAndOwnerUid()977 public void testAdministratorUidsAndOwnerUid() { 978 // Test default owner uid. 979 // If the owner uid is not set, the default value should be Process.INVALID_UID. 980 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder().build(); 981 assertEquals(INVALID_UID, nc1.getOwnerUid()); 982 // Test setAdministratorUids and getAdministratorUids. 983 final int[] administratorUids = {1001, 10001}; 984 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 985 .setAdministratorUids(administratorUids) 986 .build(); 987 assertTrue(Arrays.equals(administratorUids, nc2.getAdministratorUids())); 988 // Test setOwnerUid and getOwnerUid. 989 // The owner UID must be included in administrator UIDs, or throw IllegalStateException. 990 try { 991 final NetworkCapabilities nc3 = new NetworkCapabilities.Builder() 992 .setOwnerUid(1001) 993 .build(); 994 fail("The owner UID must be included in administrator UIDs."); 995 } catch (IllegalStateException expected) { } 996 final NetworkCapabilities nc4 = new NetworkCapabilities.Builder() 997 .setAdministratorUids(administratorUids) 998 .setOwnerUid(1001) 999 .build(); 1000 assertEquals(1001, nc4.getOwnerUid()); 1001 try { 1002 final NetworkCapabilities nc5 = new NetworkCapabilities.Builder() 1003 .setAdministratorUids(null) 1004 .build(); 1005 fail("Should not set null into setAdministratorUids"); 1006 } catch (NullPointerException expected) { } 1007 } 1008 capsWithSubIds(Integer .... subIds)1009 private static NetworkCapabilities capsWithSubIds(Integer ... subIds) { 1010 // Since the NetworkRequest would put NOT_VCN_MANAGED capabilities in general, for 1011 // every NetworkCapabilities that simulates networks needs to add it too in order to 1012 // satisfy these requests. 1013 final NetworkCapabilities nc = new NetworkCapabilities.Builder() 1014 .addCapability(NET_CAPABILITY_NOT_VCN_MANAGED) 1015 .setSubscriptionIds(new ArraySet<>(subIds)).build(); 1016 assertEquals(new ArraySet<>(subIds), nc.getSubscriptionIds()); 1017 return nc; 1018 } 1019 1020 @Test testSubIds()1021 public void testSubIds() throws Exception { 1022 final NetworkCapabilities ncWithoutId = capsWithSubIds(); 1023 final NetworkCapabilities ncWithId = capsWithSubIds(TEST_SUBID1); 1024 final NetworkCapabilities ncWithOtherIds = capsWithSubIds(TEST_SUBID1, TEST_SUBID3); 1025 final NetworkCapabilities ncWithoutRequestedIds = capsWithSubIds(TEST_SUBID3); 1026 1027 final NetworkRequest requestWithoutId = new NetworkRequest.Builder().build(); 1028 assertEmpty(requestWithoutId.networkCapabilities.getSubscriptionIds()); 1029 final NetworkRequest requestWithIds = new NetworkRequest.Builder() 1030 .setSubscriptionIds(Set.of(TEST_SUBID1, TEST_SUBID2)).build(); 1031 assertEquals(Set.of(TEST_SUBID1, TEST_SUBID2), 1032 requestWithIds.networkCapabilities.getSubscriptionIds()); 1033 1034 assertFalse(requestWithIds.canBeSatisfiedBy(ncWithoutId)); 1035 assertTrue(requestWithIds.canBeSatisfiedBy(ncWithOtherIds)); 1036 assertFalse(requestWithIds.canBeSatisfiedBy(ncWithoutRequestedIds)); 1037 assertTrue(requestWithIds.canBeSatisfiedBy(ncWithId)); 1038 assertTrue(requestWithoutId.canBeSatisfiedBy(ncWithoutId)); 1039 assertTrue(requestWithoutId.canBeSatisfiedBy(ncWithId)); 1040 } 1041 1042 @Test testEqualsSubIds()1043 public void testEqualsSubIds() throws Exception { 1044 assertEquals(capsWithSubIds(), capsWithSubIds()); 1045 assertNotEquals(capsWithSubIds(), capsWithSubIds(TEST_SUBID1)); 1046 assertEquals(capsWithSubIds(TEST_SUBID1), capsWithSubIds(TEST_SUBID1)); 1047 assertNotEquals(capsWithSubIds(TEST_SUBID1), capsWithSubIds(TEST_SUBID2)); 1048 assertNotEquals(capsWithSubIds(TEST_SUBID1), capsWithSubIds(TEST_SUBID2, TEST_SUBID1)); 1049 assertEquals(capsWithSubIds(TEST_SUBID1, TEST_SUBID2), 1050 capsWithSubIds(TEST_SUBID2, TEST_SUBID1)); 1051 } 1052 1053 @Test testLinkBandwidthKbps()1054 public void testLinkBandwidthKbps() { 1055 final NetworkCapabilities nc = new NetworkCapabilities(); 1056 // The default value of LinkDown/UpstreamBandwidthKbps should be LINK_BANDWIDTH_UNSPECIFIED. 1057 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, nc.getLinkDownstreamBandwidthKbps()); 1058 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, nc.getLinkUpstreamBandwidthKbps()); 1059 nc.setLinkDownstreamBandwidthKbps(512); 1060 nc.setLinkUpstreamBandwidthKbps(128); 1061 assertEquals(512, nc.getLinkDownstreamBandwidthKbps()); 1062 assertNotEquals(128, nc.getLinkDownstreamBandwidthKbps()); 1063 assertEquals(128, nc.getLinkUpstreamBandwidthKbps()); 1064 assertNotEquals(512, nc.getLinkUpstreamBandwidthKbps()); 1065 } 1066 getMaxTransport()1067 private int getMaxTransport() { 1068 if (!isAtLeastS() && MAX_TRANSPORT == TRANSPORT_USB) return MAX_TRANSPORT - 1; 1069 return MAX_TRANSPORT; 1070 } 1071 1072 @Test testSignalStrength()1073 public void testSignalStrength() { 1074 final NetworkCapabilities nc = new NetworkCapabilities(); 1075 // The default value of signal strength should be SIGNAL_STRENGTH_UNSPECIFIED. 1076 assertEquals(SIGNAL_STRENGTH_UNSPECIFIED, nc.getSignalStrength()); 1077 nc.setSignalStrength(-80); 1078 assertEquals(-80, nc.getSignalStrength()); 1079 assertNotEquals(-50, nc.getSignalStrength()); 1080 } 1081 assertNoTransport(NetworkCapabilities nc)1082 private void assertNoTransport(NetworkCapabilities nc) { 1083 for (int i = MIN_TRANSPORT; i <= getMaxTransport(); i++) { 1084 assertFalse(nc.hasTransport(i)); 1085 } 1086 } 1087 1088 // Checks that all transport types from MIN_TRANSPORT to maxTransportType are set and all 1089 // transport types from maxTransportType + 1 to MAX_TRANSPORT are not set when positiveSequence 1090 // is true. If positiveSequence is false, then the check sequence is opposite. checkCurrentTransportTypes(NetworkCapabilities nc, int maxTransportType, boolean positiveSequence)1091 private void checkCurrentTransportTypes(NetworkCapabilities nc, int maxTransportType, 1092 boolean positiveSequence) { 1093 for (int i = MIN_TRANSPORT; i <= maxTransportType; i++) { 1094 if (positiveSequence) { 1095 assertTrue(nc.hasTransport(i)); 1096 } else { 1097 assertFalse(nc.hasTransport(i)); 1098 } 1099 } 1100 for (int i = getMaxTransport(); i > maxTransportType; i--) { 1101 if (positiveSequence) { 1102 assertFalse(nc.hasTransport(i)); 1103 } else { 1104 assertTrue(nc.hasTransport(i)); 1105 } 1106 } 1107 } 1108 1109 @Test testMultipleTransportTypes()1110 public void testMultipleTransportTypes() { 1111 final NetworkCapabilities nc = new NetworkCapabilities(); 1112 assertNoTransport(nc); 1113 // Test adding multiple transport types. 1114 for (int i = MIN_TRANSPORT; i <= getMaxTransport(); i++) { 1115 nc.addTransportType(i); 1116 checkCurrentTransportTypes(nc, i, true /* positiveSequence */); 1117 } 1118 // Test removing multiple transport types. 1119 for (int i = MIN_TRANSPORT; i <= getMaxTransport(); i++) { 1120 nc.removeTransportType(i); 1121 checkCurrentTransportTypes(nc, i, false /* positiveSequence */); 1122 } 1123 assertNoTransport(nc); 1124 nc.addTransportType(TRANSPORT_WIFI); 1125 assertTrue(nc.hasTransport(TRANSPORT_WIFI)); 1126 assertFalse(nc.hasTransport(TRANSPORT_VPN)); 1127 nc.addTransportType(TRANSPORT_VPN); 1128 assertTrue(nc.hasTransport(TRANSPORT_WIFI)); 1129 assertTrue(nc.hasTransport(TRANSPORT_VPN)); 1130 nc.removeTransportType(TRANSPORT_WIFI); 1131 assertFalse(nc.hasTransport(TRANSPORT_WIFI)); 1132 assertTrue(nc.hasTransport(TRANSPORT_VPN)); 1133 nc.removeTransportType(TRANSPORT_VPN); 1134 assertFalse(nc.hasTransport(TRANSPORT_WIFI)); 1135 assertFalse(nc.hasTransport(TRANSPORT_VPN)); 1136 assertNoTransport(nc); 1137 } 1138 1139 @Test testAddAndRemoveTransportType()1140 public void testAddAndRemoveTransportType() { 1141 final NetworkCapabilities nc = new NetworkCapabilities(); 1142 try { 1143 nc.addTransportType(-1); 1144 fail("Should not set invalid transport type into addTransportType"); 1145 } catch (IllegalArgumentException expected) { } 1146 try { 1147 nc.removeTransportType(-1); 1148 fail("Should not set invalid transport type into removeTransportType"); 1149 } catch (IllegalArgumentException e) { } 1150 } 1151 1152 /** 1153 * Test TransportInfo to verify redaction mechanism. 1154 */ 1155 private static class TestTransportInfo implements TransportInfo { 1156 public final boolean locationRedacted; 1157 public final boolean localMacAddressRedacted; 1158 public final boolean settingsRedacted; 1159 TestTransportInfo()1160 TestTransportInfo() { 1161 locationRedacted = false; 1162 localMacAddressRedacted = false; 1163 settingsRedacted = false; 1164 } 1165 TestTransportInfo(boolean locationRedacted, boolean localMacAddressRedacted, boolean settingsRedacted)1166 TestTransportInfo(boolean locationRedacted, 1167 boolean localMacAddressRedacted, 1168 boolean settingsRedacted) { 1169 this.locationRedacted = locationRedacted; 1170 this.localMacAddressRedacted = 1171 localMacAddressRedacted; 1172 this.settingsRedacted = settingsRedacted; 1173 } 1174 1175 @Override makeCopy(@etworkCapabilities.RedactionType long redactions)1176 public TransportInfo makeCopy(@NetworkCapabilities.RedactionType long redactions) { 1177 return new TestTransportInfo( 1178 (redactions & NetworkCapabilities.REDACT_FOR_ACCESS_FINE_LOCATION) != 0, 1179 (redactions & REDACT_FOR_LOCAL_MAC_ADDRESS) != 0, 1180 (redactions & REDACT_FOR_NETWORK_SETTINGS) != 0 1181 ); 1182 } 1183 1184 @Override getApplicableRedactions()1185 public @NetworkCapabilities.RedactionType long getApplicableRedactions() { 1186 return REDACT_FOR_ACCESS_FINE_LOCATION | REDACT_FOR_LOCAL_MAC_ADDRESS 1187 | REDACT_FOR_NETWORK_SETTINGS; 1188 } 1189 } 1190 1191 @Test testBuilder()1192 public void testBuilder() { 1193 final int ownerUid = 1001; 1194 final int signalStrength = -80; 1195 final int requestUid = 10100; 1196 final int[] administratorUids = {ownerUid, 10001}; 1197 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1); 1198 final TransportInfo transportInfo = new TransportInfo() {}; 1199 final String ssid = "TEST_SSID"; 1200 final String packageName = "com.google.test.networkcapabilities"; 1201 final NetworkCapabilities.Builder capBuilder = new NetworkCapabilities.Builder() 1202 .addTransportType(TRANSPORT_WIFI) 1203 .addTransportType(TRANSPORT_CELLULAR) 1204 .removeTransportType(TRANSPORT_CELLULAR) 1205 .addCapability(NET_CAPABILITY_EIMS) 1206 .addCapability(NET_CAPABILITY_CBS) 1207 .removeCapability(NET_CAPABILITY_CBS) 1208 .setAdministratorUids(administratorUids) 1209 .setOwnerUid(ownerUid) 1210 .setLinkDownstreamBandwidthKbps(512) 1211 .setLinkUpstreamBandwidthKbps(128) 1212 .setNetworkSpecifier(specifier) 1213 .setTransportInfo(transportInfo) 1214 .setSignalStrength(signalStrength) 1215 .setSsid(ssid) 1216 .setRequestorUid(requestUid) 1217 .setRequestorPackageName(packageName); 1218 final Network network1 = new Network(100); 1219 final Network network2 = new Network(101); 1220 final List<Network> inputNetworks = List.of(network1, network2); 1221 if (isAtLeastT()) { 1222 capBuilder.setUnderlyingNetworks(inputNetworks); 1223 } 1224 final NetworkCapabilities nc = capBuilder.build(); 1225 assertEquals(1, nc.getTransportTypes().length); 1226 assertEquals(TRANSPORT_WIFI, nc.getTransportTypes()[0]); 1227 assertTrue(nc.hasCapability(NET_CAPABILITY_EIMS)); 1228 assertFalse(nc.hasCapability(NET_CAPABILITY_CBS)); 1229 assertTrue(Arrays.equals(administratorUids, nc.getAdministratorUids())); 1230 assertEquals(ownerUid, nc.getOwnerUid()); 1231 assertEquals(512, nc.getLinkDownstreamBandwidthKbps()); 1232 assertNotEquals(128, nc.getLinkDownstreamBandwidthKbps()); 1233 assertEquals(128, nc.getLinkUpstreamBandwidthKbps()); 1234 assertNotEquals(512, nc.getLinkUpstreamBandwidthKbps()); 1235 assertEquals(specifier, nc.getNetworkSpecifier()); 1236 assertEquals(transportInfo, nc.getTransportInfo()); 1237 assertEquals(signalStrength, nc.getSignalStrength()); 1238 assertNotEquals(-50, nc.getSignalStrength()); 1239 assertEquals(ssid, nc.getSsid()); 1240 assertEquals(requestUid, nc.getRequestorUid()); 1241 assertEquals(packageName, nc.getRequestorPackageName()); 1242 if (isAtLeastT()) { 1243 final List<Network> outputNetworks = nc.getUnderlyingNetworks(); 1244 assertEquals(network1, outputNetworks.get(0)); 1245 assertEquals(network2, outputNetworks.get(1)); 1246 } 1247 // Cannot assign null into NetworkCapabilities.Builder 1248 try { 1249 final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder(null); 1250 fail("Should not set null into NetworkCapabilities.Builder"); 1251 } catch (NullPointerException expected) { } 1252 assertEquals(nc, new NetworkCapabilities.Builder(nc).build()); 1253 1254 if (isAtLeastS()) { 1255 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 1256 .setSubscriptionIds(Set.of(TEST_SUBID1)).build(); 1257 assertEquals(Set.of(TEST_SUBID1), nc2.getSubscriptionIds()); 1258 } 1259 } 1260 1261 @Test testBuilderWithoutDefaultCap()1262 public void testBuilderWithoutDefaultCap() { 1263 final NetworkCapabilities nc = 1264 NetworkCapabilities.Builder.withoutDefaultCapabilities().build(); 1265 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 1266 assertFalse(nc.hasCapability(NET_CAPABILITY_TRUSTED)); 1267 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_VPN)); 1268 // Ensure test case fails if new net cap is added into default cap but no update here. 1269 assertEquals(0, nc.getCapabilities().length); 1270 } 1271 1272 @Test testRestrictCapabilitiesForTestNetworkByNotOwnerWithNonRestrictedNc()1273 public void testRestrictCapabilitiesForTestNetworkByNotOwnerWithNonRestrictedNc() { 1274 testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(false /* isOwner */); 1275 } 1276 1277 @Test testRestrictCapabilitiesForTestNetworkByOwnerWithNonRestrictedNc()1278 public void testRestrictCapabilitiesForTestNetworkByOwnerWithNonRestrictedNc() { 1279 testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(true /* isOwner */); 1280 } 1281 testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(boolean isOwner)1282 private void testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(boolean isOwner) { 1283 final int ownerUid = 1234; 1284 final int signalStrength = -80; 1285 final int[] administratorUids = {1001, ownerUid}; 1286 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(TEST_SUBID1); 1287 final TransportInfo transportInfo = new TransportInfo() {}; 1288 final NetworkCapabilities nonRestrictedNc = new NetworkCapabilities.Builder() 1289 .addTransportType(TRANSPORT_CELLULAR) 1290 .addCapability(NET_CAPABILITY_MMS) 1291 .addCapability(NET_CAPABILITY_NOT_METERED) 1292 .setAdministratorUids(administratorUids) 1293 .setOwnerUid(ownerUid) 1294 .setNetworkSpecifier(specifier) 1295 .setSignalStrength(signalStrength) 1296 .setTransportInfo(transportInfo) 1297 .setSubscriptionIds(Set.of(TEST_SUBID1)).build(); 1298 final int creatorUid = isOwner ? ownerUid : INVALID_UID; 1299 nonRestrictedNc.restrictCapabilitiesForTestNetwork(creatorUid); 1300 1301 final NetworkCapabilities.Builder expectedNcBuilder = new NetworkCapabilities.Builder(); 1302 // Non-UNRESTRICTED_TEST_NETWORKS_ALLOWED_TRANSPORTS will be removed and TRANSPORT_TEST will 1303 // be appended for non-restricted net cap. 1304 expectedNcBuilder.addTransportType(TRANSPORT_TEST); 1305 // Only TEST_NETWORKS_ALLOWED_CAPABILITIES will be kept. SubIds are only allowed for Test 1306 // Networks that only declare TRANSPORT_TEST. 1307 expectedNcBuilder.addCapability(NET_CAPABILITY_NOT_METERED) 1308 .removeCapability(NET_CAPABILITY_TRUSTED) 1309 .setSubscriptionIds(Set.of(TEST_SUBID1)); 1310 1311 expectedNcBuilder.setNetworkSpecifier(specifier) 1312 .setSignalStrength(signalStrength).setTransportInfo(transportInfo); 1313 if (creatorUid == ownerUid) { 1314 // Only retain the owner and administrator UIDs if they match the app registering the 1315 // remote caller that registered the network. 1316 expectedNcBuilder.setAdministratorUids(new int[]{ownerUid}).setOwnerUid(ownerUid); 1317 } 1318 1319 assertEquals(expectedNcBuilder.build(), nonRestrictedNc); 1320 } 1321 1322 @Test testRestrictCapabilitiesForTestNetworkByNotOwnerWithRestrictedNc()1323 public void testRestrictCapabilitiesForTestNetworkByNotOwnerWithRestrictedNc() { 1324 testRestrictCapabilitiesForTestNetworkWithRestrictedNc(false /* isOwner */); 1325 } 1326 1327 @Test testRestrictCapabilitiesForTestNetworkByOwnerWithRestrictedNc()1328 public void testRestrictCapabilitiesForTestNetworkByOwnerWithRestrictedNc() { 1329 testRestrictCapabilitiesForTestNetworkWithRestrictedNc(true /* isOwner */); 1330 } 1331 testRestrictCapabilitiesForTestNetworkWithRestrictedNc(boolean isOwner)1332 private void testRestrictCapabilitiesForTestNetworkWithRestrictedNc(boolean isOwner) { 1333 final int ownerUid = 1234; 1334 final int signalStrength = -80; 1335 final int[] administratorUids = {1001, ownerUid}; 1336 final TransportInfo transportInfo = new TransportInfo() {}; 1337 // No NetworkSpecifier is set because after performing restrictCapabilitiesForTestNetwork 1338 // the networkCapabilities will contain more than one transport type. However, 1339 // networkCapabilities must have a single transport specified to use NetworkSpecifier. Thus, 1340 // do not verify this part since it's verified in other tests. 1341 final NetworkCapabilities restrictedNc = new NetworkCapabilities.Builder() 1342 .removeCapability(NET_CAPABILITY_NOT_RESTRICTED) 1343 .addTransportType(TRANSPORT_CELLULAR) 1344 .addCapability(NET_CAPABILITY_MMS) 1345 .addCapability(NET_CAPABILITY_NOT_METERED) 1346 .setAdministratorUids(administratorUids) 1347 .setOwnerUid(ownerUid) 1348 .setSignalStrength(signalStrength) 1349 .setTransportInfo(transportInfo) 1350 .setSubscriptionIds(Set.of(TEST_SUBID1)).build(); 1351 final int creatorUid = isOwner ? ownerUid : INVALID_UID; 1352 restrictedNc.restrictCapabilitiesForTestNetwork(creatorUid); 1353 1354 final NetworkCapabilities.Builder expectedNcBuilder = new NetworkCapabilities.Builder() 1355 .removeCapability(NET_CAPABILITY_NOT_RESTRICTED); 1356 // If the test network is restricted, then the network may declare any transport, and 1357 // appended with TRANSPORT_TEST. 1358 expectedNcBuilder.addTransportType(TRANSPORT_CELLULAR); 1359 expectedNcBuilder.addTransportType(TRANSPORT_TEST); 1360 // Only TEST_NETWORKS_ALLOWED_CAPABILITIES will be kept. 1361 expectedNcBuilder.addCapability(NET_CAPABILITY_NOT_METERED); 1362 expectedNcBuilder.removeCapability(NET_CAPABILITY_TRUSTED); 1363 1364 expectedNcBuilder.setSignalStrength(signalStrength).setTransportInfo(transportInfo); 1365 if (creatorUid == ownerUid) { 1366 // Only retain the owner and administrator UIDs if they match the app registering the 1367 // remote caller that registered the network. 1368 expectedNcBuilder.setAdministratorUids(new int[]{ownerUid}).setOwnerUid(ownerUid); 1369 } 1370 1371 assertEquals(expectedNcBuilder.build(), restrictedNc); 1372 } 1373 } 1374