From fa4521c1a788133a59f12833aab8c424c7eb77c1 Mon Sep 17 00:00:00 2001 From: Chiachang Wang Date: Thu, 12 Mar 2020 14:45:47 +0800 Subject: [PATCH 1/4] Add KeepalivePacketDataTest Add test for constructor of KeepalivePacketData and InvalidPacketException Bug: 151109466 Test: atest CtsNetTestCasesLatestSdk:android.net.KeepalivePacketDataTest on both Q and R devices Change-Id: Ic9db4b9b83ff96c87f41c5f381763c3ee8dd27c8 Merged-In: Ic9db4b9b83ff96c87f41c5f381763c3ee8dd27c8 --- .../android/net/KeepalivePacketDataTest.kt | 120 ++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 tests/net/common/java/android/net/KeepalivePacketDataTest.kt diff --git a/tests/net/common/java/android/net/KeepalivePacketDataTest.kt b/tests/net/common/java/android/net/KeepalivePacketDataTest.kt new file mode 100644 index 0000000000..f464ec6cf0 --- /dev/null +++ b/tests/net/common/java/android/net/KeepalivePacketDataTest.kt @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package android.net + +import android.net.InvalidPacketException.ERROR_INVALID_IP_ADDRESS +import android.net.InvalidPacketException.ERROR_INVALID_PORT +import android.os.Build +import androidx.test.filters.SmallTest +import androidx.test.runner.AndroidJUnit4 +import com.android.testutils.DevSdkIgnoreRule +import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo +import java.net.InetAddress +import java.util.Arrays +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Assert.fail +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +@SmallTest +class KeepalivePacketDataTest { + @Rule @JvmField + val ignoreRule: DevSdkIgnoreRule = DevSdkIgnoreRule() + + private val INVALID_PORT = 65537 + private val TEST_DST_PORT = 4244 + private val TEST_SRC_PORT = 4243 + + private val TESTBYTES = byteArrayOf(12, 31, 22, 44) + private val TEST_SRC_ADDRV4 = "198.168.0.2".address() + private val TEST_DST_ADDRV4 = "198.168.0.1".address() + private val TEST_ADDRV6 = "2001:db8::1".address() + + private fun String.address() = InetAddresses.parseNumericAddress(this) + + // Add for test because constructor of KeepalivePacketData is protected. + private inner class TestKeepalivePacketData( + srcAddress: InetAddress? = TEST_SRC_ADDRV4, + srcPort: Int = TEST_SRC_PORT, + dstAddress: InetAddress? = TEST_DST_ADDRV4, + dstPort: Int = TEST_DST_PORT, + data: ByteArray = TESTBYTES + ) : KeepalivePacketData(srcAddress, srcPort, dstAddress, dstPort, data) + + @Test + @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testConstructor() { + var data: TestKeepalivePacketData + + try { + data = TestKeepalivePacketData(srcAddress = null) + fail("Null src address should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_IP_ADDRESS) + } + + try { + data = TestKeepalivePacketData(dstAddress = null) + fail("Null dst address should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_IP_ADDRESS) + } + + try { + data = TestKeepalivePacketData(dstAddress = TEST_ADDRV6) + fail("Ip family mismatched should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_IP_ADDRESS) + } + + try { + data = TestKeepalivePacketData(srcPort = INVALID_PORT) + fail("Invalid srcPort should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_PORT) + } + + try { + data = TestKeepalivePacketData(dstPort = INVALID_PORT) + fail("Invalid dstPort should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_PORT) + } + } + + @Test + @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testSrcAddress() = assertEquals(TEST_SRC_ADDRV4, TestKeepalivePacketData().srcAddress) + + @Test + @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testDstAddress() = assertEquals(TEST_DST_ADDRV4, TestKeepalivePacketData().dstAddress) + + @Test + @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testSrcPort() = assertEquals(TEST_SRC_PORT, TestKeepalivePacketData().srcPort) + + @Test + @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testDstPort() = assertEquals(TEST_DST_PORT, TestKeepalivePacketData().dstPort) + + @Test + @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testPacket() = assertTrue(Arrays.equals(TESTBYTES, TestKeepalivePacketData().packet)) +} \ No newline at end of file From b05dcda675daa0454ff4fa732c3e93b975df3838 Mon Sep 17 00:00:00 2001 From: Chiachang Wang Date: Fri, 13 Mar 2020 16:37:04 +0800 Subject: [PATCH 2/4] Add NattKeepalivePacketDataTest Add test for constructor and parcel Test: atest CtsNetTestCasesLatestSdk:android.net.NattKeepalivePacketDataTest on both Q and R devices Bug: 151402211 Change-Id: I97015365604be1846e3ecbaf60ac99e334705565 Merged-In: I97015365604be1846e3ecbaf60ac99e334705565 --- .../android/net/NattKeepalivePacketData.java | 17 +++ .../net/NattKeepalivePacketDataTest.kt | 114 ++++++++++++++++++ 2 files changed, 131 insertions(+) create mode 100644 tests/net/common/java/android/net/NattKeepalivePacketDataTest.kt diff --git a/core/java/android/net/NattKeepalivePacketData.java b/core/java/android/net/NattKeepalivePacketData.java index bd39c13ba0..29da4952da 100644 --- a/core/java/android/net/NattKeepalivePacketData.java +++ b/core/java/android/net/NattKeepalivePacketData.java @@ -20,6 +20,7 @@ import static android.net.InvalidPacketException.ERROR_INVALID_IP_ADDRESS; import static android.net.InvalidPacketException.ERROR_INVALID_PORT; import android.annotation.NonNull; +import android.annotation.Nullable; import android.annotation.SystemApi; import android.net.util.IpUtils; import android.os.Parcel; @@ -30,6 +31,7 @@ import java.net.Inet4Address; import java.net.InetAddress; import java.nio.ByteBuffer; import java.nio.ByteOrder; +import java.util.Objects; /** @hide */ @SystemApi @@ -121,4 +123,19 @@ public final class NattKeepalivePacketData extends KeepalivePacketData implement return new NattKeepalivePacketData[size]; } }; + + @Override + public boolean equals(@Nullable final Object o) { + if (!(o instanceof NattKeepalivePacketData)) return false; + final NattKeepalivePacketData other = (NattKeepalivePacketData) o; + return this.srcAddress.equals(other.srcAddress) + && this.dstAddress.equals(other.dstAddress) + && this.srcPort == other.srcPort + && this.dstPort == other.dstPort; + } + + @Override + public int hashCode() { + return Objects.hash(srcAddress, dstAddress, srcPort, dstPort); + } } diff --git a/tests/net/common/java/android/net/NattKeepalivePacketDataTest.kt b/tests/net/common/java/android/net/NattKeepalivePacketDataTest.kt new file mode 100644 index 0000000000..46f39dd016 --- /dev/null +++ b/tests/net/common/java/android/net/NattKeepalivePacketDataTest.kt @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.net + +import android.net.InvalidPacketException.ERROR_INVALID_IP_ADDRESS +import android.net.InvalidPacketException.ERROR_INVALID_PORT +import android.net.NattSocketKeepalive.NATT_PORT +import android.os.Build +import androidx.test.filters.SmallTest +import androidx.test.runner.AndroidJUnit4 +import com.android.testutils.assertEqualBothWays +import com.android.testutils.assertFieldCountEquals +import com.android.testutils.assertParcelSane +import com.android.testutils.DevSdkIgnoreRule +import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo +import com.android.testutils.parcelingRoundTrip +import java.net.InetAddress +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotEquals +import org.junit.Assert.fail +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +@SmallTest +class NattKeepalivePacketDataTest { + @Rule @JvmField + val ignoreRule: DevSdkIgnoreRule = DevSdkIgnoreRule() + + /* Refer to the definition in {@code NattKeepalivePacketData} */ + private val IPV4_HEADER_LENGTH = 20 + private val UDP_HEADER_LENGTH = 8 + + private val TEST_PORT = 4243 + private val TEST_PORT2 = 4244 + private val TEST_SRC_ADDRV4 = "198.168.0.2".address() + private val TEST_DST_ADDRV4 = "198.168.0.1".address() + private val TEST_ADDRV6 = "2001:db8::1".address() + + private fun String.address() = InetAddresses.parseNumericAddress(this) + private fun nattKeepalivePacket( + srcAddress: InetAddress? = TEST_SRC_ADDRV4, + srcPort: Int = TEST_PORT, + dstAddress: InetAddress? = TEST_DST_ADDRV4, + dstPort: Int = NATT_PORT + ) = NattKeepalivePacketData.nattKeepalivePacket(srcAddress, srcPort, dstAddress, dstPort) + + @Test @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testConstructor() { + try { + nattKeepalivePacket(dstPort = TEST_PORT) + fail("Dst port is not NATT port should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_PORT) + } + + try { + nattKeepalivePacket(srcAddress = TEST_ADDRV6) + fail("A v6 srcAddress should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_IP_ADDRESS) + } + + try { + nattKeepalivePacket(dstAddress = TEST_ADDRV6) + fail("A v6 dstAddress should cause exception") + } catch (e: InvalidPacketException) { + assertEquals(e.error, ERROR_INVALID_IP_ADDRESS) + } + + try { + parcelingRoundTrip( + NattKeepalivePacketData(TEST_SRC_ADDRV4, TEST_PORT, TEST_DST_ADDRV4, TEST_PORT, + byteArrayOf(12, 31, 22, 44))) + fail("Invalid data should cause exception") + } catch (e: IllegalArgumentException) { } + } + + @Test @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testParcel() { + assertParcelSane(nattKeepalivePacket(), 0) + } + + @Test @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testEquals() { + assertEqualBothWays(nattKeepalivePacket(), nattKeepalivePacket()) + assertNotEquals(nattKeepalivePacket(dstAddress = TEST_SRC_ADDRV4), nattKeepalivePacket()) + assertNotEquals(nattKeepalivePacket(srcAddress = TEST_DST_ADDRV4), nattKeepalivePacket()) + // Test src port only because dst port have to be NATT_PORT + assertNotEquals(nattKeepalivePacket(srcPort = TEST_PORT2), nattKeepalivePacket()) + // Make sure the parceling test is updated if fields are added in the base class. + assertFieldCountEquals(5, KeepalivePacketData::class.java) + } + + @Test @IgnoreUpTo(Build.VERSION_CODES.Q) + fun testHashCode() { + assertEquals(nattKeepalivePacket().hashCode(), nattKeepalivePacket().hashCode()) + } +} \ No newline at end of file From 84c3f44278a580c621cde382d6eb02d6d25ae46a Mon Sep 17 00:00:00 2001 From: Junyu Lai Date: Wed, 18 Mar 2020 10:01:45 +0000 Subject: [PATCH 3/4] Fix flaky ConnectivityServiceTest#testNetworkFactoryUnregister Test: atest ConnectivityServiceTest#testNetworkFactoryUnregister \ --geneate-new-metrics 100 Bug: 151792032 Change-Id: I1ee7a26186885d3a79a32ec9e45f5bcd656a6680 Merged-In: I1ee7a26186885d3a79a32ec9e45f5bcd656a6680 Merged-In: Iece9e8ad5c51170cd404ac995d0005392d37fe0c (cherry picked from commit 31c26cdbeb35a6fd6a53a1c25cce6d36b825bf41) --- tests/net/java/com/android/server/ConnectivityServiceTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/net/java/com/android/server/ConnectivityServiceTest.java b/tests/net/java/com/android/server/ConnectivityServiceTest.java index c21772a5d1..44216e804f 100644 --- a/tests/net/java/com/android/server/ConnectivityServiceTest.java +++ b/tests/net/java/com/android/server/ConnectivityServiceTest.java @@ -2464,8 +2464,8 @@ public class ConnectivityServiceTest { final MockNetworkFactory testFactory = new MockNetworkFactory(handlerThread.getLooper(), mServiceContext, "testFactory", filter); // Register the factory and don't be surprised when the default request arrives. - testFactory.register(); testFactory.expectAddRequestsWithScores(0); + testFactory.register(); testFactory.waitForNetworkRequests(1); testFactory.setScoreFilter(42); From 46a0db809f3873b7f9098d8cfb5dfa1ca9dbb315 Mon Sep 17 00:00:00 2001 From: Cody Kesting Date: Mon, 16 Mar 2020 18:15:28 -0700 Subject: [PATCH 4/4] Change NetworkCapabilities administrator UIDs to be stored as int[]. NetworkCapabilities#mAdministratorUids is used to track the UIDs that are administrators of the given Network. This value was previously stored as List. However, general Android API Council guidelines recommend using Arrays for primitive values. In order to be consistent with the guidelines, updating the field to use an Array. Bug: 147903575 Test: atest FrameworksNetTests Change-Id: I2652a5b0f276b8944454af5cb4b1383a3e054cfa --- .../java/android/net/NetworkCapabilities.java | 32 ++++++++----------- .../android/server/ConnectivityService.java | 11 ++++--- .../android/server/TestNetworkService.java | 11 +------ .../server/ConnectivityServiceTest.java | 8 ++--- 4 files changed, 25 insertions(+), 37 deletions(-) diff --git a/core/java/android/net/NetworkCapabilities.java b/core/java/android/net/NetworkCapabilities.java index 116e343ff2..7d8df6a8ff 100644 --- a/core/java/android/net/NetworkCapabilities.java +++ b/core/java/android/net/NetworkCapabilities.java @@ -37,9 +37,7 @@ import com.android.internal.util.Preconditions; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; +import java.util.Arrays; import java.util.Objects; import java.util.Set; import java.util.StringJoiner; @@ -96,7 +94,7 @@ public final class NetworkCapabilities implements Parcelable { mTransportInfo = null; mSignalStrength = SIGNAL_STRENGTH_UNSPECIFIED; mUids = null; - mAdministratorUids.clear(); + mAdministratorUids = new int[0]; mOwnerUid = Process.INVALID_UID; mSSID = null; mPrivateDnsBroken = false; @@ -884,10 +882,10 @@ public final class NetworkCapabilities implements Parcelable { * empty unless the destination is 1) the System Server, or 2) Telephony. In either case, the * receiving entity must have the ACCESS_FINE_LOCATION permission and target R+. */ - private final List mAdministratorUids = new ArrayList<>(); + private int[] mAdministratorUids = new int[0]; /** - * Sets the list of UIDs that are administrators of this network. + * Sets the int[] of UIDs that are administrators of this network. * *

UIDs included in administratorUids gain administrator privileges over this Network. * Examples of UIDs that should be included in administratorUids are: @@ -907,23 +905,21 @@ public final class NetworkCapabilities implements Parcelable { */ @NonNull @SystemApi - public NetworkCapabilities setAdministratorUids( - @NonNull final List administratorUids) { - mAdministratorUids.clear(); - mAdministratorUids.addAll(administratorUids); + public NetworkCapabilities setAdministratorUids(@NonNull final int[] administratorUids) { + mAdministratorUids = Arrays.copyOf(administratorUids, administratorUids.length); return this; } /** - * Retrieves the list of UIDs that are administrators of this Network. + * Retrieves the UIDs that are administrators of this Network. * - * @return the List of UIDs that are administrators of this Network + * @return the int[] of UIDs that are administrators of this Network * @hide */ @NonNull @SystemApi - public List getAdministratorUids() { - return Collections.unmodifiableList(mAdministratorUids); + public int[] getAdministratorUids() { + return Arrays.copyOf(mAdministratorUids, mAdministratorUids.length); } /** @@ -1584,7 +1580,7 @@ public final class NetworkCapabilities implements Parcelable { dest.writeArraySet(mUids); dest.writeString(mSSID); dest.writeBoolean(mPrivateDnsBroken); - dest.writeList(mAdministratorUids); + dest.writeIntArray(mAdministratorUids); dest.writeInt(mOwnerUid); dest.writeInt(mRequestorUid); dest.writeString(mRequestorPackageName); @@ -1608,7 +1604,7 @@ public final class NetworkCapabilities implements Parcelable { null /* ClassLoader, null for default */); netCap.mSSID = in.readString(); netCap.mPrivateDnsBroken = in.readBoolean(); - netCap.setAdministratorUids(in.readArrayList(null)); + netCap.setAdministratorUids(in.createIntArray()); netCap.mOwnerUid = in.readInt(); netCap.mRequestorUid = in.readInt(); netCap.mRequestorPackageName = in.readString(); @@ -1665,8 +1661,8 @@ public final class NetworkCapabilities implements Parcelable { sb.append(" OwnerUid: ").append(mOwnerUid); } - if (!mAdministratorUids.isEmpty()) { - sb.append(" AdministratorUids: ").append(mAdministratorUids); + if (mAdministratorUids.length == 0) { + sb.append(" AdministratorUids: ").append(Arrays.toString(mAdministratorUids)); } if (null != mSSID) { diff --git a/services/core/java/com/android/server/ConnectivityService.java b/services/core/java/com/android/server/ConnectivityService.java index deae459e39..b89b1eb9c8 100644 --- a/services/core/java/com/android/server/ConnectivityService.java +++ b/services/core/java/com/android/server/ConnectivityService.java @@ -1666,7 +1666,7 @@ public class ConnectivityService extends IConnectivityManager.Stub if (newNc.getNetworkSpecifier() != null) { newNc.setNetworkSpecifier(newNc.getNetworkSpecifier().redact()); } - newNc.setAdministratorUids(Collections.EMPTY_LIST); + newNc.setAdministratorUids(new int[0]); return newNc; } @@ -1727,7 +1727,7 @@ public class ConnectivityService extends IConnectivityManager.Stub nc.setSingleUid(callerUid); } nc.setRequestorUidAndPackageName(callerUid, callerPackageName); - nc.setAdministratorUids(Collections.EMPTY_LIST); + nc.setAdministratorUids(new int[0]); // Clear owner UID; this can never come from an app. nc.setOwnerUid(INVALID_UID); @@ -7864,7 +7864,7 @@ public class ConnectivityService extends IConnectivityManager.Stub private void clearNetworkCapabilitiesUids(@NonNull NetworkCapabilities nc) { nc.setUids(null); - nc.setAdministratorUids(Collections.EMPTY_LIST); + nc.setAdministratorUids(new int[0]); nc.setOwnerUid(Process.INVALID_UID); } @@ -7911,8 +7911,9 @@ public class ConnectivityService extends IConnectivityManager.Stub } // Administrator UIDs also contains the Owner UID - if (nai.networkCapabilities.getAdministratorUids().contains(callbackUid)) { - return true; + final int[] administratorUids = nai.networkCapabilities.getAdministratorUids(); + for (final int uid : administratorUids) { + if (uid == callbackUid) return true; } return false; diff --git a/services/core/java/com/android/server/TestNetworkService.java b/services/core/java/com/android/server/TestNetworkService.java index f772a4a5a3..81a1372eb1 100644 --- a/services/core/java/com/android/server/TestNetworkService.java +++ b/services/core/java/com/android/server/TestNetworkService.java @@ -53,7 +53,6 @@ import java.net.InterfaceAddress; import java.net.NetworkInterface; import java.net.SocketException; import java.util.ArrayList; -import java.util.List; import java.util.Objects; import java.util.concurrent.atomic.AtomicInteger; @@ -250,7 +249,7 @@ class TestNetworkService extends ITestNetworkManager.Stub { nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED); nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); nc.setNetworkSpecifier(new StringNetworkSpecifier(iface)); - nc.setAdministratorUids(intArrayToList(administratorUids)); + nc.setAdministratorUids(administratorUids); if (!isMetered) { nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED); } @@ -293,14 +292,6 @@ class TestNetworkService extends ITestNetworkManager.Stub { return new TestNetworkAgent(looper, context, ni, nc, lp, callingUid, binder); } - private List intArrayToList(@NonNull int[] array) { - final List list = new ArrayList<>(array.length); - for (final int i : array) { - list.add(i); - } - return list; - } - /** * Sets up a Network with extremely limited privileges, guarded by the MANAGE_TEST_NETWORKS * permission. diff --git a/tests/net/java/com/android/server/ConnectivityServiceTest.java b/tests/net/java/com/android/server/ConnectivityServiceTest.java index c21772a5d1..a5a4fa56ad 100644 --- a/tests/net/java/com/android/server/ConnectivityServiceTest.java +++ b/tests/net/java/com/android/server/ConnectivityServiceTest.java @@ -6851,7 +6851,7 @@ public class ConnectivityServiceTest { @Test public void testCheckConnectivityDiagnosticsPermissionsNetworkAdministrator() throws Exception { final NetworkCapabilities nc = new NetworkCapabilities(); - nc.setAdministratorUids(Arrays.asList(Process.myUid())); + nc.setAdministratorUids(new int[] {Process.myUid()}); final NetworkAgentInfo naiWithUid = new NetworkAgentInfo( null, null, null, null, null, nc, 0, mServiceContext, null, null, @@ -6873,7 +6873,7 @@ public class ConnectivityServiceTest { public void testCheckConnectivityDiagnosticsPermissionsFails() throws Exception { final NetworkCapabilities nc = new NetworkCapabilities(); nc.setOwnerUid(Process.myUid()); - nc.setAdministratorUids(Arrays.asList(Process.myUid())); + nc.setAdministratorUids(new int[] {Process.myUid()}); final NetworkAgentInfo naiWithUid = new NetworkAgentInfo( null, null, null, null, null, nc, 0, mServiceContext, null, null, @@ -6926,7 +6926,7 @@ public class ConnectivityServiceTest { argThat(report -> { final NetworkCapabilities nc = report.getNetworkCapabilities(); return nc.getUids() == null - && nc.getAdministratorUids().isEmpty() + && nc.getAdministratorUids().length == 0 && nc.getOwnerUid() == Process.INVALID_UID; })); } @@ -6947,7 +6947,7 @@ public class ConnectivityServiceTest { argThat(report -> { final NetworkCapabilities nc = report.getNetworkCapabilities(); return nc.getUids() == null - && nc.getAdministratorUids().isEmpty() + && nc.getAdministratorUids().length == 0 && nc.getOwnerUid() == Process.INVALID_UID; })); }