joy/android_packages_modules_Connectivity
Watch
1
Fork
You've already forked android_packages_modules_Connectivity
 0
Code Issues Pull requests Projects Releases Wiki Activity

Remove RecorderCallback.

Browse source 
This class doesn't actually serve a purpose, it only makes
TestableNetworkCallbck more complex.

Test: CtsNetTestCases ConnectivityCoverageTests
Flag: EXEMPT test-only
Change-Id: I39a598b82a3215384bdfe04980f4b280ab2c2716
This commit is contained in:
Chalard Jean 2025-04-28 14:37:03 +09:00
commit f2994122c1
54 changed files with 407 additions and 419 deletions
Download patch file Download diff file Expand all files Collapse all files

12
Tethering/tests/integration/src/android/net/EthernetTetheringTest.java
View file

@ -93,8 +93,8 @@ import com.android.testutils.DeviceInfoUtils;
import com.android.testutils.DumpTestUtils;
import com.android.testutils.NetworkStackModuleTest;
import com.android.testutils.PollPacketReader;
import com.android.testutils.RecorderCallback.CallbackEntry;
import com.android.testutils.TestableNetworkCallback;
import com.android.testutils.TestableNetworkCallback.Event;
import org.junit.After;
import org.junit.Rule;
@ -1297,16 +1297,16 @@ public class EthernetTetheringTest extends EthernetTetheringTestBase {
}
// Verify NetworkCallback works accordingly.
final Network network = networkCallback.expect(CallbackEntry.AVAILABLE).getNetwork();
final CallbackEntry.CapabilitiesChanged capEvent =
networkCallback.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED);
final Network network = networkCallback.expect(Event.AVAILABLE).getNetwork();
final Event.CapabilitiesChanged capEvent =
networkCallback.eventuallyExpect(Event.NETWORK_CAPS_UPDATED);
assertEquals(network, capEvent.getNetwork());
assertTrue(capEvent.getCaps().hasTransport(TRANSPORT_ETHERNET));
assertTrue(capEvent.getCaps().hasCapability(NET_CAPABILITY_LOCAL_NETWORK));
// Verify details in the LinkPropertiesChanged event.
final CallbackEntry.LinkPropertiesChanged lpEvent =
networkCallback.eventuallyExpect(CallbackEntry.LINK_PROPERTIES_CHANGED);
final Event.LinkPropertiesChanged lpEvent =
networkCallback.eventuallyExpect(Event.LINK_PROPERTIES_CHANGED);
assertEquals(network, lpEvent.getNetwork());
assertEquals(iface, lpEvent.getLp().getInterfaceName());
assertTrue(lpEvent.getLp().hasIPv4Address());

52
staticlibs/tests/unit/src/com/android/testutils/TestableNetworkCallbackTest.kt
View file

@ -21,20 +21,20 @@ import android.net.LinkAddress
import android.net.LinkProperties
import android.net.Network
import android.net.NetworkCapabilities
import com.android.testutils.RecorderCallback.CallbackEntry
import com.android.testutils.RecorderCallback.CallbackEntry.Available
import com.android.testutils.RecorderCallback.CallbackEntry.BlockedStatus
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.AVAILABLE
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.BLOCKED_STATUS
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.LINK_PROPERTIES_CHANGED
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.LOSING
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.LOST
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.NETWORK_CAPS_UPDATED
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.RESUMED
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.SUSPENDED
import com.android.testutils.RecorderCallback.CallbackEntry.Companion.UNAVAILABLE
import com.android.testutils.RecorderCallback.CallbackEntry.LinkPropertiesChanged
import com.android.testutils.TestableNetworkCallback.Event
import com.android.testutils.TestableNetworkCallback.Event.Available
import com.android.testutils.TestableNetworkCallback.Event.BlockedStatus
import com.android.testutils.TestableNetworkCallback.Event.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback.Event.Companion.AVAILABLE
import com.android.testutils.TestableNetworkCallback.Event.Companion.BLOCKED_STATUS
import com.android.testutils.TestableNetworkCallback.Event.Companion.LINK_PROPERTIES_CHANGED
import com.android.testutils.TestableNetworkCallback.Event.Companion.LOSING
import com.android.testutils.TestableNetworkCallback.Event.Companion.LOST
import com.android.testutils.TestableNetworkCallback.Event.Companion.NETWORK_CAPS_UPDATED
import com.android.testutils.TestableNetworkCallback.Event.Companion.RESUMED
import com.android.testutils.TestableNetworkCallback.Event.Companion.SUSPENDED
import com.android.testutils.TestableNetworkCallback.Event.Companion.UNAVAILABLE
import com.android.testutils.TestableNetworkCallback.Event.LinkPropertiesChanged
import kotlin.reflect.KClass
import kotlin.test.assertEquals
import kotlin.test.assertFails
@ -170,19 +170,19 @@ class TestableNetworkCallbackTest {
val net = Network(193)
val netCaps = NetworkCapabilities().addTransportType(CELLULAR)
// Check that expecting callbackThat anything fails when no callback has been received.
assertFails { mCallback.expect<CallbackEntry>(timeoutMs = SHORT_TIMEOUT_MS) { true } }
assertFails { mCallback.expect<Event>(timeoutMs = SHORT_TIMEOUT_MS) { true } }
// Basic test for true and false
mCallback.onAvailable(net)
mCallback.expect<Available> { true }
mCallback.onAvailable(net)
assertFails { mCallback.expect<CallbackEntry>(timeoutMs = SHORT_TIMEOUT_MS) { false } }
assertFails { mCallback.expect<Event>(timeoutMs = SHORT_TIMEOUT_MS) { false } }
// Try a positive and a negative case
mCallback.onBlockedStatusChanged(net, true)
mCallback.expect<CallbackEntry> { cb -> cb is BlockedStatus && cb.blocked }
mCallback.expect<Event> { cb -> cb is BlockedStatus && cb.blocked }
mCallback.onCapabilitiesChanged(net, netCaps)
assertFails { mCallback.expect<CallbackEntry>(timeoutMs = SHORT_TIMEOUT_MS) { cb ->
assertFails { mCallback.expect<Event>(timeoutMs = SHORT_TIMEOUT_MS) { cb ->
cb is CapabilitiesChanged && cb.caps.hasTransport(WIFI)
} }
}
@ -410,24 +410,24 @@ class TestableNetworkCallbackTest {
private object TNCInterpreter : ConcurrentInterpreter<TestableNetworkCallback>(interpretTable)
val EntryList = CallbackEntry::class.sealedSubclasses.map { it.simpleName }.joinToString("|")
private fun callbackEntryFromString(name: String): KClass<out CallbackEntry> {
return CallbackEntry::class.sealedSubclasses.first { it.simpleName == name }
val EntryList = Event::class.sealedSubclasses.map { it.simpleName }.joinToString("|")
private fun callbackEntryFromString(name: String): KClass<out Event> {
return Event::class.sealedSubclasses.first { it.simpleName == name }
}
@SuppressLint("NewApi") // Uses hidden APIs, which the linter would identify as missing APIs.
private val interpretTable = listOf<InterpretMatcher<TestableNetworkCallback>>(
// Interpret "Available(xx)" as "call to onAvailable with netId xx", and likewise for
// all callback types. This is implemented above by enumerating the subclasses of
// CallbackEntry and reading their simpleName.
// Event and reading their simpleName.
Regex("""(.*)\s+=\s+($EntryList)\((\d+)\)""") to { i, cb, t ->
val record = i.interpret(t.strArg(1), cb)
assertTrue(callbackEntryFromString(t.strArg(2)).isInstance(record))
// Strictly speaking testing for is CallbackEntry is useless as it's been tested above
// Strictly speaking testing for is Event is useless as it's been tested above
// but the compiler can't figure things out from the isInstance call. It does understand
// from the assertTrue(is CallbackEntry) that this is true, which allows to access
// from the assertTrue(is Event) that this is true, which allows to access
// the 'network' member below.
assertTrue(record is CallbackEntry)
assertTrue(record is Event)
assertEquals(record.network.netId, t.intArg(3))
},
// Interpret "onAvailable(xx)" as calling "onAvailable" with a netId of xx, and likewise for
@ -451,7 +451,7 @@ private val interpretTable = listOf<InterpretMatcher<TestableNetworkCallback>>(
},
Regex("""poll\((\d+)\)""") to { i, cb, t -> cb.poll(t.timeArg(1)) },
// Interpret "eventually(Available(xx), timeout)" as calling eventuallyExpect that expects
// CallbackEntry.AVAILABLE with netId of xx within timeout*INTERPRET_TIME_UNIT timeout, and
// Event.AVAILABLE with netId of xx within timeout*INTERPRET_TIME_UNIT timeout, and
// likewise for all callback types.
Regex("""eventually\(($EntryList)\((\d+)\),\s+(\d+)\)""") to { i, cb, t ->
val net = Network(t.intArg(2))

2
staticlibs/tests/unit/src/com/android/testutils/TestableNetworkCallbackTestJava.java
View file

@ -16,7 +16,7 @@
package com.android.testutils;
import static com.android.testutils.RecorderCallback.CallbackEntry.AVAILABLE;
import static com.android.testutils.TestableNetworkCallback.Event.AVAILABLE;
import static com.android.testutils.TestableNetworkCallbackKt.anyNetwork;
import static org.junit.Assume.assumeTrue;

4
staticlibs/testutils/app/connectivitychecker/src/com/android/testutils/connectivitypreparer/ConnectivityCheckTest.kt
View file

@ -34,8 +34,8 @@ import com.android.net.module.util.NetworkStackConstants.IPV4_ADDR_ANY
import com.android.net.module.util.NetworkStackConstants.IPV6_ADDR_ANY
import com.android.testutils.AutoReleaseNetworkCallbackRule
import com.android.testutils.ConnectUtil
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.RecorderCallback.CallbackEntry.LinkPropertiesChanged
import com.android.testutils.TestableNetworkCallback.Event.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback.Event.LinkPropertiesChanged
import com.android.testutils.runAsShell
import com.android.testutils.tryTest
import java.io.IOException

4
staticlibs/testutils/devicetests/com/android/testutils/AutoReleaseNetworkCallbackRule.kt
View file

@ -27,7 +27,7 @@ import android.net.NetworkCapabilities.TRANSPORT_WIFI
import android.net.NetworkRequest
import android.os.Handler
import androidx.test.platform.app.InstrumentationRegistry
import com.android.testutils.RecorderCallback.CallbackEntry
import com.android.testutils.TestableNetworkCallback.Event.Available
import java.util.Collections
import kotlin.test.fail
import org.junit.rules.TestRule
@ -84,7 +84,7 @@ open class NetworkCallbackHelper {
}
val cb = requestNetwork(getInternetRequest(TRANSPORT_CELLULAR))
cellRequestCb = cb
return cb.expect<CallbackEntry.Available>(
return cb.expect<Available>(
errorMsg = "Cell network not available. " +
"Please ensure the device has working mobile data."
).network

6
staticlibs/testutils/devicetests/com/android/testutils/ConnectUtil.kt
View file

@ -35,8 +35,8 @@ import android.os.ParcelFileDescriptor
import android.os.SystemClock
import android.util.Log
import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
import com.android.testutils.RecorderCallback.CallbackEntry
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback.Event
import com.android.testutils.TestableNetworkCallback.Event.CapabilitiesChanged
import java.util.concurrent.CompletableFuture
import java.util.concurrent.TimeUnit
import kotlin.test.assertNotNull
@ -242,7 +242,7 @@ class ConnectUtil(private val context: Context) {
}
}
private inline fun <reified T : CallbackEntry> TestableNetworkCallback.eventuallyExpect(
private inline fun <reified T : Event> TestableNetworkCallback.eventuallyExpect(
errorMsg: String,
crossinline predicate: (T) -> Boolean = { true }
): T = history.poll(defaultTimeoutMs, mark) { it is T && predicate(it) }.also {

2
staticlibs/testutils/devicetests/com/android/testutils/DefaultNetworkRestoreMonitor.kt
View file

@ -24,7 +24,7 @@ import android.net.Network
import android.net.NetworkCapabilities
import com.android.internal.annotations.VisibleForTesting
import com.android.net.module.util.BitUtils
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback.Event.CapabilitiesChanged
import java.util.concurrent.CompletableFuture
import java.util.concurrent.TimeUnit
import org.junit.runner.Description

8
staticlibs/testutils/devicetests/com/android/testutils/EthernetTestInterface.kt
View file

@ -27,7 +27,7 @@ import android.net.TestNetworkInterface
import android.os.Handler
import android.util.Log
import com.android.net.module.util.ArrayTrackRecord
import com.android.testutils.EthernetTestInterface.EthernetStateListener.CallbackEntry.InterfaceStateChanged
import com.android.testutils.EthernetTestInterface.EthernetStateListener.Event.InterfaceStateChanged
import java.net.NetworkInterface
import kotlin.concurrent.Volatile
import kotlin.test.assertNotNull
@ -47,15 +47,15 @@ class EthernetTestInterface(
val testIface: TestNetworkInterface
) {
private class EthernetStateListener(private val trackedIface: String) : InterfaceStateListener {
val events = ArrayTrackRecord<CallbackEntry>().newReadHead()
val events = ArrayTrackRecord<Event>().newReadHead()
sealed class CallbackEntry {
sealed class Event {
data class InterfaceStateChanged(
val iface: String,
val state: Int,
val role: Int,
val cfg: IpConfiguration?
) : CallbackEntry()
) : Event()
}
override fun onInterfaceStateChanged(

2
staticlibs/testutils/devicetests/com/android/testutils/PacketBridge.kt
View file

@ -28,7 +28,7 @@ import android.net.TestNetworkInterface
import android.net.TestNetworkManager
import android.net.TestNetworkSpecifier
import android.os.Binder
import com.android.testutils.RecorderCallback.CallbackEntry.Available
import com.android.testutils.TestableNetworkCallback.Event.Available
import java.net.InetAddress
import libcore.io.IoUtils

70
staticlibs/testutils/devicetests/com/android/testutils/TestableNetworkAgent.kt
View file

@ -45,21 +45,21 @@ import android.system.OsConstants.SOCK_DGRAM
import com.android.modules.utils.build.SdkLevel.isAtLeastS
import com.android.net.module.util.ArrayTrackRecord
import com.android.testutils.CompatUtil.makeTestNetworkSpecifier
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnAddKeepalivePacketFilter
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnAutomaticReconnectDisabled
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnBandwidthUpdateRequested
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnDscpPolicyStatusUpdated
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnNetworkCreated
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnNetworkDestroyed
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnNetworkUnwanted
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnRegisterQosCallback
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnRemoveKeepalivePacketFilter
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnSaveAcceptUnvalidated
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnSignalStrengthThresholdsUpdated
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnStartSocketKeepalive
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnStopSocketKeepalive
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnUnregisterQosCallback
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnValidationStatus
import com.android.testutils.TestableNetworkAgent.Event.OnAddKeepalivePacketFilter
import com.android.testutils.TestableNetworkAgent.Event.OnAutomaticReconnectDisabled
import com.android.testutils.TestableNetworkAgent.Event.OnBandwidthUpdateRequested
import com.android.testutils.TestableNetworkAgent.Event.OnDscpPolicyStatusUpdated
import com.android.testutils.TestableNetworkAgent.Event.OnNetworkCreated
import com.android.testutils.TestableNetworkAgent.Event.OnNetworkDestroyed
import com.android.testutils.TestableNetworkAgent.Event.OnNetworkUnwanted
import com.android.testutils.TestableNetworkAgent.Event.OnRegisterQosCallback
import com.android.testutils.TestableNetworkAgent.Event.OnRemoveKeepalivePacketFilter
import com.android.testutils.TestableNetworkAgent.Event.OnSaveAcceptUnvalidated
import com.android.testutils.TestableNetworkAgent.Event.OnSignalStrengthThresholdsUpdated
import com.android.testutils.TestableNetworkAgent.Event.OnStartSocketKeepalive
import com.android.testutils.TestableNetworkAgent.Event.OnStopSocketKeepalive
import com.android.testutils.TestableNetworkAgent.Event.OnUnregisterQosCallback
import com.android.testutils.TestableNetworkAgent.Event.OnValidationStatus
import java.net.NetworkInterface
import java.net.SocketException
import java.time.Duration
@ -193,34 +193,34 @@ public open class TestableNetworkAgent(
val DEFAULT_TIMEOUT_MS = 5000L
val history = ArrayTrackRecord<CallbackEntry>().newReadHead()
val history = ArrayTrackRecord<Event>().newReadHead()
sealed class CallbackEntry {
object OnBandwidthUpdateRequested : CallbackEntry()
object OnNetworkUnwanted : CallbackEntry()
sealed class Event {
object OnBandwidthUpdateRequested : Event()
object OnNetworkUnwanted : Event()
data class OnAddKeepalivePacketFilter(
val slot: Int,
val packet: KeepalivePacketData
) : CallbackEntry()
data class OnRemoveKeepalivePacketFilter(val slot: Int) : CallbackEntry()
) : Event()
data class OnRemoveKeepalivePacketFilter(val slot: Int) : Event()
data class OnStartSocketKeepalive(
val slot: Int,
val interval: Int,
val packet: KeepalivePacketData
) : CallbackEntry()
data class OnStopSocketKeepalive(val slot: Int) : CallbackEntry()
data class OnSaveAcceptUnvalidated(val accept: Boolean) : CallbackEntry()
object OnAutomaticReconnectDisabled : CallbackEntry()
data class OnValidationStatus(val status: Int, val uri: Uri?) : CallbackEntry()
data class OnSignalStrengthThresholdsUpdated(val thresholds: IntArray) : CallbackEntry()
object OnNetworkCreated : CallbackEntry()
object OnNetworkDestroyed : CallbackEntry()
data class OnDscpPolicyStatusUpdated(val policyId: Int, val status: Int) : CallbackEntry()
) : Event()
data class OnStopSocketKeepalive(val slot: Int) : Event()
data class OnSaveAcceptUnvalidated(val accept: Boolean) : Event()
object OnAutomaticReconnectDisabled : Event()
data class OnValidationStatus(val status: Int, val uri: Uri?) : Event()
data class OnSignalStrengthThresholdsUpdated(val thresholds: IntArray) : Event()
object OnNetworkCreated : Event()
object OnNetworkDestroyed : Event()
data class OnDscpPolicyStatusUpdated(val policyId: Int, val status: Int) : Event()
data class OnRegisterQosCallback(
val callbackId: Int,
val filter: QosFilter
) : CallbackEntry()
data class OnUnregisterQosCallback(val callbackId: Int) : CallbackEntry()
) : Event()
data class OnUnregisterQosCallback(val callbackId: Int) : Event()
}
override fun onBandwidthUpdateRequested() {
@ -306,19 +306,19 @@ public open class TestableNetworkAgent(
assertEquals("", it.uri.toString())
}
inline fun <reified T : CallbackEntry> expectCallback(): T {
inline fun <reified T : Event> expectCallback(): T {
val foundCallback = history.poll(DEFAULT_TIMEOUT_MS)
assertTrue(foundCallback is T, "Expected ${T::class} but found $foundCallback")
return foundCallback
}
inline fun <reified T : CallbackEntry> expectCallback(valid: (T) -> Boolean) {
inline fun <reified T : Event> expectCallback(valid: (T) -> Boolean) {
val foundCallback = history.poll(DEFAULT_TIMEOUT_MS)
assertTrue(foundCallback is T, "Expected ${T::class} but found $foundCallback")
assertTrue(valid(foundCallback), "Unexpected callback : $foundCallback")
}
inline fun <reified T : CallbackEntry> eventuallyExpect() =
inline fun <reified T : Event> eventuallyExpect() =
history.poll(DEFAULT_TIMEOUT_MS) { it is T }.also {
assertNotNull(it, "Callback ${T::class} not received")
} as T

144
staticlibs/testutils/devicetests/com/android/testutils/TestableNetworkCallback.kt
View file

@ -24,18 +24,18 @@ import android.net.NetworkCapabilities
import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
import android.util.Log
import com.android.net.module.util.ArrayTrackRecord
import com.android.testutils.RecorderCallback.CallbackEntry.Available
import com.android.testutils.RecorderCallback.CallbackEntry.BlockedStatus
import com.android.testutils.RecorderCallback.CallbackEntry.BlockedStatusInt
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.RecorderCallback.CallbackEntry.LinkPropertiesChanged
import com.android.testutils.RecorderCallback.CallbackEntry.LocalInfoChanged
import com.android.testutils.RecorderCallback.CallbackEntry.Losing
import com.android.testutils.RecorderCallback.CallbackEntry.Lost
import com.android.testutils.RecorderCallback.CallbackEntry.Reserved
import com.android.testutils.RecorderCallback.CallbackEntry.Resumed
import com.android.testutils.RecorderCallback.CallbackEntry.Suspended
import com.android.testutils.RecorderCallback.CallbackEntry.Unavailable
import com.android.testutils.TestableNetworkCallback.Event.Available
import com.android.testutils.TestableNetworkCallback.Event.BlockedStatus
import com.android.testutils.TestableNetworkCallback.Event.BlockedStatusInt
import com.android.testutils.TestableNetworkCallback.Event.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback.Event.LinkPropertiesChanged
import com.android.testutils.TestableNetworkCallback.Event.LocalInfoChanged
import com.android.testutils.TestableNetworkCallback.Event.Losing
import com.android.testutils.TestableNetworkCallback.Event.Lost
import com.android.testutils.TestableNetworkCallback.Event.Reserved
import com.android.testutils.TestableNetworkCallback.Event.Resumed
import com.android.testutils.TestableNetworkCallback.Event.Suspended
import com.android.testutils.TestableNetworkCallback.Event.Unavailable
import kotlin.reflect.KClass
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
@ -45,64 +45,72 @@ object NULL_NETWORK : Network(-1)
object ANY_NETWORK : Network(-2)
fun anyNetwork() = ANY_NETWORK
private val DEFAULT_TAG = RecorderCallback::class.simpleName
private val DEFAULT_TAG = TestableNetworkCallback::class.simpleName
?: fail("Could not determine class name")
open class RecorderCallback private constructor(
private val backingRecord: ArrayTrackRecord<CallbackEntry>,
val logTag: String
) : NetworkCallback() {
public constructor(logTag: String = DEFAULT_TAG) : this(ArrayTrackRecord(), logTag)
protected constructor(src: RecorderCallback?, logTag: String) : this(
src?.backingRecord ?: ArrayTrackRecord(),
logTag
)
private const val DEFAULT_TIMEOUT = 30_000L // ms
private const val DEFAULT_NO_CALLBACK_TIMEOUT = 200L // ms
private val NOOP = Runnable {}
sealed class CallbackEntry {
/**
* See comments on the public constructor below for a description of the arguments.
*/
open class TestableNetworkCallback private constructor(
src: TestableNetworkCallback?,
val defaultTimeoutMs: Long,
val defaultNoCallbackTimeoutMs: Long,
val waiterFunc: Runnable,
private val logTag: String
) : NetworkCallback() {
val backingRecord: ArrayTrackRecord<Event> = src?.backingRecord ?: ArrayTrackRecord()
val history: ArrayTrackRecord<Event>.ReadHead = backingRecord.newReadHead()
val mark get() = history.mark
sealed class Event {
// To get equals(), hashcode(), componentN() etc for free, the child classes of
// this class are data classes. But while data classes can inherit from other classes,
// they may only have visible members in the constructors, so they couldn't declare
// a constructor with a non-val arg to pass to CallbackEntry. Instead, force all
// a constructor with a non-val arg to pass to Event. Instead, force all
// subclasses to implement a `network' property, which can be done in a data class
// constructor by specifying override.
abstract val network: Network
data class Reserved private constructor(
override val network: Network,
val caps: NetworkCapabilities
) : CallbackEntry() {
override val network: Network,
val caps: NetworkCapabilities
) : Event() {
constructor(caps: NetworkCapabilities) : this(NULL_NETWORK, caps)
}
data class Available(override val network: Network) : CallbackEntry()
data class Available(override val network: Network) : Event()
data class CapabilitiesChanged(
override val network: Network,
val caps: NetworkCapabilities
) : CallbackEntry()
) : Event()
data class LinkPropertiesChanged(
override val network: Network,
val lp: LinkProperties
) : CallbackEntry()
) : Event()
data class LocalInfoChanged(
override val network: Network,
val info: LocalNetworkInfo
) : CallbackEntry()
data class Suspended(override val network: Network) : CallbackEntry()
data class Resumed(override val network: Network) : CallbackEntry()
data class Losing(override val network: Network, val maxMsToLive: Int) : CallbackEntry()
data class Lost(override val network: Network) : CallbackEntry()
) : Event()
data class Suspended(override val network: Network) : Event()
data class Resumed(override val network: Network) : Event()
data class Losing(override val network: Network, val maxMsToLive: Int) : Event()
data class Lost(override val network: Network) : Event()
data class Unavailable private constructor(
override val network: Network
) : CallbackEntry() {
) : Event() {
constructor() : this(NULL_NETWORK)
}
data class BlockedStatus(
override val network: Network,
val blocked: Boolean
) : CallbackEntry()
) : Event()
data class BlockedStatusInt(
override val network: Network,
val reason: Int
) : CallbackEntry()
) : Event()
// Convenience constants for expecting a type
companion object {
@ -133,9 +141,6 @@ open class RecorderCallback private constructor(
}
}
val history = backingRecord.newReadHead()
val mark get() = history.mark
override fun onReserved(caps: NetworkCapabilities) {
Log.d(logTag, "onReserved $caps")
history.add(Reserved(caps))
@ -196,22 +201,7 @@ open class RecorderCallback private constructor(
Log.d(logTag, "onUnavailable")
history.add(Unavailable())
}
}
private const val DEFAULT_TIMEOUT = 30_000L // ms
private const val DEFAULT_NO_CALLBACK_TIMEOUT = 200L // ms
private val NOOP = Runnable {}
/**
* See comments on the public constructor below for a description of the arguments.
*/
open class TestableNetworkCallback private constructor(
src: TestableNetworkCallback?,
val defaultTimeoutMs: Long,
val defaultNoCallbackTimeoutMs: Long,
val waiterFunc: Runnable,
logTag: String
) : RecorderCallback(src, logTag) {
/**
* Construct a testable network callback.
* @param timeoutMs the default timeout for expecting a callback. Default 30 seconds. This
@ -260,7 +250,7 @@ open class TestableNetworkCallback private constructor(
* Long.MAX_VALUE.
*/
@JvmOverloads
fun poll(timeoutMs: Long = defaultTimeoutMs, predicate: (CallbackEntry) -> Boolean = { true }) =
fun poll(timeoutMs: Long = defaultTimeoutMs, predicate: (Event) -> Boolean = { true }) =
history.poll(timeoutMs, predicate)
/*****
@ -269,13 +259,13 @@ open class TestableNetworkCallback private constructor(
* passed predicate. If no callback is received within the timeout, these methods fail.
*/
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: Network = ANY_NETWORK,
timeoutMs: Long = defaultTimeoutMs,
errorMsg: String? = null,
test: (T) -> Boolean = { true }
) = expect<CallbackEntry>(network, timeoutMs, errorMsg) {
) = expect<Event>(network, timeoutMs, errorMsg) {
if (type.isInstance(it)) {
test(it as T) // Cast can't fail since type.isInstance(it) and type: KClass<T>
} else {
@ -284,7 +274,7 @@ open class TestableNetworkCallback private constructor(
} as T
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: HasNetwork,
timeoutMs: Long = defaultTimeoutMs,
@ -297,7 +287,7 @@ open class TestableNetworkCallback private constructor(
// there is no need to explicitly define versions without the test predicate.
// Without |network|
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
timeoutMs: Long,
errorMsg: String?,
@ -306,7 +296,7 @@ open class TestableNetworkCallback private constructor(
// Without |timeout|, in Network and HasNetwork versions
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: Network,
errorMsg: String?,
@ -314,7 +304,7 @@ open class TestableNetworkCallback private constructor(
) = expect(type, network, defaultTimeoutMs, errorMsg, test)
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: HasNetwork,
errorMsg: String?,
@ -323,7 +313,7 @@ open class TestableNetworkCallback private constructor(
// Without |errorMsg|, in Network and HasNetwork versions
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: Network,
timeoutMs: Long,
@ -331,7 +321,7 @@ open class TestableNetworkCallback private constructor(
) = expect(type, network, timeoutMs, null, test)
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: HasNetwork,
timeoutMs: Long,
@ -340,7 +330,7 @@ open class TestableNetworkCallback private constructor(
// Without |network| or |timeout|
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
errorMsg: String?,
test: (T) -> Boolean = { true }
@ -348,7 +338,7 @@ open class TestableNetworkCallback private constructor(
// Without |network| or |errorMsg|
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
timeoutMs: Long,
test: (T) -> Boolean = { true }
@ -356,14 +346,14 @@ open class TestableNetworkCallback private constructor(
// Without |timeout| or |errorMsg|, in Network and HasNetwork versions
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: Network,
test: (T) -> Boolean
) = expect(type, network, defaultTimeoutMs, null, test)
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
network: HasNetwork,
test: (T) -> Boolean
@ -371,13 +361,13 @@ open class TestableNetworkCallback private constructor(
// Without |network| or |timeout| or |errorMsg|
@JvmOverloads
fun <T : CallbackEntry> expect(
fun <T : Event> expect(
type: KClass<T>,
test: (T) -> Boolean
) = expect(type, ANY_NETWORK, defaultTimeoutMs, null, test)
// Kotlin reified versions. Don't call methods above, or the predicate would need to be noinline
inline fun <reified T : CallbackEntry> expect(
inline fun <reified T : Event> expect(
network: Network = ANY_NETWORK,
timeoutMs: Long = defaultTimeoutMs,
errorMsg: String? = null,
@ -399,7 +389,7 @@ open class TestableNetworkCallback private constructor(
}
} as T
inline fun <reified T : CallbackEntry> expect(
inline fun <reified T : Event> expect(
network: HasNetwork,
timeoutMs: Long = defaultTimeoutMs,
errorMsg: String? = null,
@ -415,13 +405,13 @@ open class TestableNetworkCallback private constructor(
@JvmOverloads
fun assertNoCallback(
timeoutMs: Long = defaultNoCallbackTimeoutMs,
valid: (CallbackEntry) -> Boolean = { true }
valid: (Event) -> Boolean = { true }
) {
waiterFunc.run()
history.poll(timeoutMs) { valid(it) }?.let { fail("Expected no callback but got $it") }
}
fun assertNoCallback(valid: (CallbackEntry) -> Boolean) =
fun assertNoCallback(valid: (Event) -> Boolean) =
assertNoCallback(defaultNoCallbackTimeoutMs, valid)
/*****
@ -430,7 +420,7 @@ open class TestableNetworkCallback private constructor(
* Any callback of the wrong type, or doesn't match the optional predicate, is ignored.
* They fail if no callback matching the predicate is received within the timeout.
*/
inline fun <reified T : CallbackEntry> eventuallyExpect(
inline fun <reified T : Event> eventuallyExpect(
timeoutMs: Long = defaultTimeoutMs,
from: Int = mark,
crossinline predicate: (T) -> Boolean = { true }
@ -443,7 +433,7 @@ open class TestableNetworkCallback private constructor(
} as T
@JvmOverloads
fun <T : CallbackEntry> eventuallyExpect(
fun <T : Event> eventuallyExpect(
type: KClass<T>,
timeoutMs: Long = defaultTimeoutMs,
predicate: (cb: T) -> Boolean = { true }
@ -455,7 +445,7 @@ open class TestableNetworkCallback private constructor(
)
} as T
fun <T : CallbackEntry> eventuallyExpect(
fun <T : Event> eventuallyExpect(
type: KClass<T>,
timeoutMs: Long = defaultTimeoutMs,
from: Int = mark,

22
staticlibs/testutils/devicetests/com/android/testutils/TestableNetworkOfferCallback.kt
View file

@ -31,12 +31,12 @@ class TestableNetworkOfferCallback(
private val noCallbackTimeoutMs: Long = DEFAULT_NO_CALLBACK_TIMEOUT,
) : NetworkProvider.NetworkOfferCallback {
private val TAG = this::class.simpleName
val history = ArrayTrackRecord<CallbackEntry>().newReadHead()
val history = ArrayTrackRecord<Event>().newReadHead()
val mark get() = history.mark
sealed class CallbackEntry {
data class Needed(val request: NetworkRequest) : CallbackEntry()
data class Unneeded(val request: NetworkRequest) : CallbackEntry()
sealed class Event {
data class Needed(val request: NetworkRequest) : Event()
data class Unneeded(val request: NetworkRequest) : Event()
}
/**
@ -45,7 +45,7 @@ class TestableNetworkOfferCallback(
*/
override fun onNetworkNeeded(request: NetworkRequest) {
Log.d(TAG, "onNetworkNeeded $request")
history.add(CallbackEntry.Needed(request))
history.add(Event.Needed(request))
}
/**
@ -53,10 +53,10 @@ class TestableNetworkOfferCallback(
*/
override fun onNetworkUnneeded(request: NetworkRequest) {
Log.d(TAG, "onNetworkUnneeded $request")
history.add(CallbackEntry.Unneeded(request))
history.add(Event.Unneeded(request))
}
inline fun <reified T : CallbackEntry> expect(
inline fun <reified T : Event> expect(
errorMsg: String? = null,
predicate: (T) -> Boolean = { true }
): T {
@ -76,11 +76,11 @@ class TestableNetworkOfferCallback(
// TODO : remove when there are no callers
@Deprecated("Use expect instead of expectCallbackThat")
inline fun <reified T : CallbackEntry> expectCallbackThat(
inline fun <reified T : Event> expectCallbackThat(
crossinline predicate: (T) -> Boolean
): T = expect<T>(null, predicate)
inline fun <reified T : CallbackEntry> eventuallyExpect(
inline fun <reified T : Event> eventuallyExpect(
errorMsg: String? = null,
from: Int = mark,
crossinline predicate: (T) -> Boolean = { true }
@ -94,12 +94,12 @@ class TestableNetworkOfferCallback(
} as T
fun expectOnNetworkNeeded(capabilities: NetworkCapabilities) =
expectCallbackThat<CallbackEntry.Needed> {
expectCallbackThat<Event.Needed> {
it.request.canBeSatisfiedBy(capabilities)
}
fun expectOnNetworkUnneeded(capabilities: NetworkCapabilities) =
expectCallbackThat<CallbackEntry.Unneeded> {
expectCallbackThat<Event.Unneeded> {
it.request.canBeSatisfiedBy(capabilities)
}

24
tests/common/java/android/net/NetworkProviderTest.kt
View file

@ -21,9 +21,9 @@ import android.content.Context
import android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED
import android.net.NetworkCapabilities.NET_CAPABILITY_TRUSTED
import android.net.NetworkCapabilities.TRANSPORT_TEST
import android.net.NetworkProviderTest.TestNetworkCallback.CallbackEntry.OnUnavailable
import android.net.NetworkProviderTest.TestNetworkProvider.CallbackEntry.OnNetworkRequestWithdrawn
import android.net.NetworkProviderTest.TestNetworkProvider.CallbackEntry.OnNetworkRequested
import android.net.NetworkProviderTest.TestNetworkCallback.Event.OnUnavailable
import android.net.NetworkProviderTest.TestNetworkProvider.Event.OnNetworkRequestWithdrawn
import android.net.NetworkProviderTest.TestNetworkProvider.Event.OnNetworkRequested
import android.os.Build
import android.os.Handler
import android.os.HandlerThread
@ -85,15 +85,15 @@ class NetworkProviderTest {
private class TestNetworkProvider(context: Context, looper: Looper) :
NetworkProvider(context, looper, PROVIDER_NAME) {
private val TAG = this::class.simpleName
private val seenEvents = ArrayTrackRecord<CallbackEntry>().newReadHead()
private val seenEvents = ArrayTrackRecord<Event>().newReadHead()
sealed class CallbackEntry {
sealed class Event {
data class OnNetworkRequested(
val request: NetworkRequest,
val score: Int,
val id: Int
) : CallbackEntry()
data class OnNetworkRequestWithdrawn(val request: NetworkRequest) : CallbackEntry()
) : Event()
data class OnNetworkRequestWithdrawn(val request: NetworkRequest) : Event()
}
override fun onNetworkRequested(request: NetworkRequest, score: Int, id: Int) {
@ -106,7 +106,7 @@ class NetworkProviderTest {
seenEvents.add(OnNetworkRequestWithdrawn(request))
}
inline fun <reified T : CallbackEntry> eventuallyExpectCallbackThat(
inline fun <reified T : Event> eventuallyExpectCallbackThat(
crossinline predicate: (T) -> Boolean
) = seenEvents.poll(DEFAULT_TIMEOUT_MS) { it is T && predicate(it) }
?: fail("Did not receive callback after ${DEFAULT_TIMEOUT_MS}ms")
@ -356,16 +356,16 @@ class NetworkProviderTest {
}
private class TestNetworkCallback : ConnectivityManager.NetworkCallback() {
private val seenEvents = ArrayTrackRecord<CallbackEntry>().newReadHead()
sealed class CallbackEntry {
object OnUnavailable : CallbackEntry()
private val seenEvents = ArrayTrackRecord<Event>().newReadHead()
sealed class Event {
object OnUnavailable : Event()
}
override fun onUnavailable() {
seenEvents.add(OnUnavailable)
}
inline fun <reified T : CallbackEntry> expectCallback(
inline fun <reified T : Event> expectCallback(
crossinline predicate: (T) -> Boolean
) = seenEvents.poll(DEFAULT_TIMEOUT_MS) { it is T && predicate(it) }
}

35
tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java Executable file → Normal file
View file

@ -19,8 +19,8 @@ package com.android.cts.net.hostside;
import static android.Manifest.permission.MANAGE_TEST_NETWORKS;
import static android.Manifest.permission.NETWORK_SETTINGS;
import static android.Manifest.permission.READ_DEVICE_CONFIG;
import static android.Manifest.permission.WRITE_DEVICE_CONFIG;
import static android.Manifest.permission.WRITE_ALLOWLISTED_DEVICE_CONFIG;
import static android.Manifest.permission.WRITE_DEVICE_CONFIG;
import static android.content.Context.RECEIVER_EXPORTED;
import static android.content.pm.PackageManager.FEATURE_TELEPHONY;
import static android.content.pm.PackageManager.FEATURE_WIFI;
@ -52,8 +52,8 @@ import static com.android.cts.net.hostside.VpnTest.TestSocketKeepaliveCallback.C
import static com.android.cts.net.hostside.VpnTest.TestSocketKeepaliveCallback.CallbackType.ON_STARTED;
import static com.android.cts.net.hostside.VpnTest.TestSocketKeepaliveCallback.CallbackType.ON_STOPPED;
import static com.android.testutils.Cleanup.testAndCleanup;
import static com.android.testutils.RecorderCallback.CallbackEntry.BLOCKED_STATUS_INT;
import static com.android.testutils.TestPermissionUtil.runAsShell;
import static com.android.testutils.TestableNetworkCallback.Event.BLOCKED_STATUS_INT;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@ -130,9 +130,8 @@ import com.android.testutils.AutoReleaseNetworkCallbackRule;
import com.android.testutils.ConnectUtil;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
import com.android.testutils.RecorderCallback;
import com.android.testutils.RecorderCallback.CallbackEntry;
import com.android.testutils.TestableNetworkCallback;
import com.android.testutils.TestableNetworkCallback.Event;
import org.junit.After;
import org.junit.Before;
@ -886,14 +885,14 @@ public class VpnTest {
private void expectUnderlyingNetworks(TestableNetworkCallback callback,
@Nullable List<Network> expectUnderlyingNetworks) {
callback.eventuallyExpect(RecorderCallback.CallbackEntry.NETWORK_CAPS_UPDATED,
callback.eventuallyExpect(TestableNetworkCallback.Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> (Objects.equals(expectUnderlyingNetworks,
entry.getCaps().getUnderlyingNetworks())));
}
private void expectVpnNetwork(TestableNetworkCallback callback) {
callback.eventuallyExpect(RecorderCallback.CallbackEntry.NETWORK_CAPS_UPDATED,
callback.eventuallyExpect(TestableNetworkCallback.Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> entry.getCaps().hasTransport(TRANSPORT_VPN));
}
@ -1009,7 +1008,7 @@ public class VpnTest {
registerDefaultNetworkCallback(myUidCallback);
myUidCallback.expectAvailableCallbacks(defaultNetwork, false /* suspended */,
true /* validated */, false /* blocked */, TIMEOUT_MS);
myUidCallback.expect(CallbackEntry.NETWORK_CAPS_UPDATED, defaultNetwork);
myUidCallback.expect(Event.NETWORK_CAPS_UPDATED, defaultNetwork);
}
FileDescriptor fd = openSocketFdInOtherApp(TEST_HOST, 80, TIMEOUT_MS);
@ -1030,7 +1029,7 @@ public class VpnTest {
checkTrafficOnVpn();
final Network vpnNetwork = mCM.getActiveNetwork();
myUidCallback.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
myUidCallback.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> entry.getNetwork().equals(vpnNetwork)
&& entry.getCaps().hasCapability(NET_CAPABILITY_VALIDATED));
@ -1065,8 +1064,8 @@ public class VpnTest {
}
private void assertNoCallbackExceptCapOrLpChange(TestableNetworkCallback callback) {
callback.assertNoCallback(c -> !(c instanceof CallbackEntry.CapabilitiesChanged
|| c instanceof CallbackEntry.LinkPropertiesChanged));
callback.assertNoCallback(c -> !(c instanceof Event.CapabilitiesChanged
|| c instanceof Event.LinkPropertiesChanged));
}
@Test
@ -1182,12 +1181,12 @@ public class VpnTest {
final Network defaultNetwork = mCM.getActiveNetwork();
final TestableNetworkCallback cb = new TestableNetworkCallback();
registerDefaultNetworkCallback(cb);
cb.expect(CallbackEntry.AVAILABLE, defaultNetwork);
cb.expect(Event.AVAILABLE, defaultNetwork);
final NetworkCapabilities cap =
cb.expect(CallbackEntry.NETWORK_CAPS_UPDATED, defaultNetwork).getCaps();
cb.expect(Event.NETWORK_CAPS_UPDATED, defaultNetwork).getCaps();
final LinkProperties lp =
cb.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, defaultNetwork).getLp();
cb.expect(CallbackEntry.BLOCKED_STATUS, defaultNetwork);
cb.expect(Event.LINK_PROPERTIES_CHANGED, defaultNetwork).getLp();
cb.expect(Event.BLOCKED_STATUS, defaultNetwork);
// Setup VPN
final FileDescriptor fd = openSocketFdInOtherApp(TEST_HOST, 80, TIMEOUT_MS);
@ -1932,7 +1931,7 @@ public class VpnTest {
// The VPN will be the only default network for the app, so it's expected to receive
// onLost() callback.
defaultNetworkCallback.eventuallyExpect(CallbackEntry.LOST);
defaultNetworkCallback.eventuallyExpect(Event.LOST);
final ArrayList<Network> underlyingNetworks = new ArrayList<>();
underlyingNetworks.add(defaultNetwork);
@ -1944,14 +1943,14 @@ public class VpnTest {
expectVpnNetwork(defaultNetworkCallback);
}, /* cleanup */ () -> {
stopVpn();
defaultNetworkCallback.eventuallyExpect(CallbackEntry.LOST);
defaultNetworkCallback.eventuallyExpect(Event.LOST);
}, /* cleanup */ () -> {
runWithShellPermissionIdentity(() -> {
mCM.setVpnDefaultForUids(session, new ArraySet<>());
}, NETWORK_SETTINGS);
// The default network of the app will be changed back to wifi when the VPN network
// preference feature is disabled.
defaultNetworkCallback.eventuallyExpect(CallbackEntry.AVAILABLE,
defaultNetworkCallback.eventuallyExpect(Event.AVAILABLE,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> defaultNetwork.equals(entry.getNetwork()));
});
@ -2133,7 +2132,7 @@ public class VpnTest {
BLOCKED_REASON_NONE, NETWORK_CALLBACK_TIMEOUT_MS);
}
public void onBlockedStatusChanged(Network network, int blockedReasons) {
getHistory().add(new CallbackEntry.BlockedStatusInt(network, blockedReasons));
getHistory().add(new Event.BlockedStatusInt(network, blockedReasons));
}
}
}

2
tests/cts/multidevices/snippet/ConnectivityMultiDevicesSnippet.kt
View file

@ -41,8 +41,8 @@ import com.android.modules.utils.build.SdkLevel
import com.android.testutils.AutoReleaseNetworkCallbackRule
import com.android.testutils.ConnectUtil
import com.android.testutils.NetworkCallbackHelper
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback
import com.android.testutils.TestableNetworkCallback.Event.CapabilitiesChanged
import com.android.testutils.runAsShell
import com.google.android.mobly.snippet.Snippet
import com.google.android.mobly.snippet.rpc.Rpc

4
tests/cts/net/src/android/net/cts/ApfIntegrationTest.kt
View file

@ -86,8 +86,8 @@ import com.android.testutils.DevSdkIgnoreRule
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
import com.android.testutils.DevSdkIgnoreRunner
import com.android.testutils.NetworkStackModuleTest
import com.android.testutils.RecorderCallback.CallbackEntry.Available
import com.android.testutils.RecorderCallback.CallbackEntry.LinkPropertiesChanged
import com.android.testutils.TestableNetworkCallback.Event.Available
import com.android.testutils.TestableNetworkCallback.Event.LinkPropertiesChanged
import com.android.testutils.SkipPresubmit
import com.android.testutils.TestableNetworkCallback
import com.android.testutils.pollingCheck

2
tests/cts/net/src/android/net/cts/CaptivePortalTest.kt
View file

@ -48,7 +48,7 @@ import com.android.net.module.util.NetworkStackConstants.TEST_CAPTIVE_PORTAL_HTT
import com.android.net.module.util.NetworkStackConstants.TEST_CAPTIVE_PORTAL_HTTP_URL
import com.android.testutils.AutoReleaseNetworkCallbackRule
import com.android.testutils.DeviceConfigRule
import com.android.testutils.RecorderCallback.CallbackEntry.CapabilitiesChanged
import com.android.testutils.TestableNetworkCallback.Event.CapabilitiesChanged
import com.android.testutils.SkipMainlinePresubmit
import com.android.testutils.TestHttpServer
import com.android.testutils.TestHttpServer.Request

126
tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
View file

@ -232,7 +232,7 @@ import com.android.testutils.DevSdkIgnoreRunner;
import com.android.testutils.DeviceConfigRule;
import com.android.testutils.DeviceInfoUtils;
import com.android.testutils.DumpTestUtils;
import com.android.testutils.RecorderCallback.CallbackEntry;
import com.android.testutils.TestableNetworkCallback.Event;
import com.android.testutils.SkipPresubmit;
import com.android.testutils.TestHttpServer;
import com.android.testutils.TestNetworkTracker;
@ -482,9 +482,9 @@ public class ConnectivityManagerTest {
final TestableNetworkCallback callback =
networkCallbackRule.registerDefaultNetworkCallback();
assertNotNull("Couldn't restore Internet connectivity",
callback.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
callback.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> ((CallbackEntry.CapabilitiesChanged) entry)
entry -> ((Event.CapabilitiesChanged) entry)
.getCaps().hasCapability(NET_CAPABILITY_VALIDATED)));
});
}
@ -656,7 +656,7 @@ public class ConnectivityManagerTest {
// callbacks. This is guaranteed to succeed because the callback is registered
// before getAllNetworkStateSnapshots is called.
final LinkProperties lpFromSnapshot = snapshot.getLinkProperties();
allNetworkLinkPropertiesListener.eventuallyExpect(CallbackEntry.LINK_PROPERTIES_CHANGED,
allNetworkLinkPropertiesListener.eventuallyExpect(Event.LINK_PROPERTIES_CHANGED,
NETWORK_CALLBACK_TIMEOUT_MS, 0 /* mark */, entry ->
entry.getNetwork().equals(network)
&& entry.getLp().equals(lpFromSnapshot));
@ -1134,9 +1134,9 @@ public class ConnectivityManagerTest {
.build();
}
private boolean hasPrivateDnsValidated(CallbackEntry entry, Network networkForPrivateDns) {
private boolean hasPrivateDnsValidated(Event entry, Network networkForPrivateDns) {
if (!networkForPrivateDns.equals(entry.getNetwork())) return false;
final NetworkCapabilities nc = ((CallbackEntry.CapabilitiesChanged) entry).getCaps();
final NetworkCapabilities nc = ((Event.CapabilitiesChanged) entry).getCaps();
return !nc.isPrivateDnsBroken() && nc.hasCapability(NET_CAPABILITY_VALIDATED);
}
@ -1154,13 +1154,13 @@ public class ConnectivityManagerTest {
try {
// Verifying the good private DNS sever
mCtsNetUtils.setPrivateDnsStrictMode(goodPrivateDnsServer);
cb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS,
cb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> hasPrivateDnsValidated(entry, networkForPrivateDns));
// Verifying the broken private DNS sever
mCtsNetUtils.setPrivateDnsStrictMode(invalidPrivateDnsServer);
cb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> (((CallbackEntry.CapabilitiesChanged) entry).getCaps()
cb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> (((Event.CapabilitiesChanged) entry).getCaps()
.isPrivateDnsBroken()) && networkForPrivateDns.equals(entry.getNetwork()));
} finally {
mCtsNetUtils.restorePrivateDnsSetting();
@ -1215,22 +1215,22 @@ public class ConnectivityManagerTest {
// Now we should expect to get a network callback about availability of the wifi
// network even if it was already connected as a state-based action when the callback
// is registered.
wifiNetwork = callback.eventuallyExpect(CallbackEntry.AVAILABLE).getNetwork();
wifiNetwork = callback.eventuallyExpect(Event.AVAILABLE).getNetwork();
assertNotNull("Did not receive onAvailable for TRANSPORT_WIFI request",
wifiNetwork);
final Network defaultNetwork = defaultTrackingCallback.eventuallyExpect(
CallbackEntry.AVAILABLE).getNetwork();
Event.AVAILABLE).getNetwork();
assertNotNull("Did not receive onAvailable on default network callback",
defaultNetwork);
if (TestUtils.shouldTestSApis()) {
systemDefaultCallback.eventuallyExpect(CallbackEntry.AVAILABLE);
final Network perUidNetwork = perUidCallback.eventuallyExpect(CallbackEntry.AVAILABLE)
systemDefaultCallback.eventuallyExpect(Event.AVAILABLE);
final Network perUidNetwork = perUidCallback.eventuallyExpect(Event.AVAILABLE)
.getNetwork();
assertEquals(defaultNetwork, perUidNetwork);
final Network bestMatchingNetwork = bestMatchingCallback.eventuallyExpect(
CallbackEntry.AVAILABLE).getNetwork();
Event.AVAILABLE).getNetwork();
assertEquals(defaultNetwork, bestMatchingNetwork);
}
}
@ -1460,7 +1460,7 @@ public class ConnectivityManagerTest {
.build());
// Wait to get callback for availability of internet
callback.eventuallyExpect(CallbackEntry.AVAILABLE).getNetwork();
callback.eventuallyExpect(Event.AVAILABLE).getNetwork();
}
/**
@ -1484,7 +1484,7 @@ public class ConnectivityManagerTest {
100 /* timeoutMs */);
try {
// Wait to get callback for unavailability of requested network
callback.eventuallyExpect(CallbackEntry.UNAVAILABLE, 2_000 /* timeoutMs */);
callback.eventuallyExpect(Event.UNAVAILABLE, 2_000 /* timeoutMs */);
} finally {
if (previousWifiEnabledState) {
mCtsNetUtils.connectToWifi();
@ -1602,7 +1602,7 @@ public class ConnectivityManagerTest {
}
return networkCallback.eventuallyExpect(
CallbackEntry.NETWORK_CAPS_UPDATED,
Event.NETWORK_CAPS_UPDATED,
// Changing meteredness on wifi involves reconnecting, which can take several
// seconds (involves re-associating, DHCP...).
NETWORK_CALLBACK_TIMEOUT_MS,
@ -2276,10 +2276,10 @@ public class ConnectivityManagerTest {
try (Socket socket = new Socket()) {
// Verify that the network is restricted.
testNetworkCb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
testNetworkCb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> network.equals(entry.getNetwork())
&& (!((CallbackEntry.CapabilitiesChanged) entry).getCaps()
&& (!((Event.CapabilitiesChanged) entry).getCaps()
.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)));
// CtsNetTestCases package doesn't hold CONNECTIVITY_USE_RESTRICTED_NETWORKS, so it
// does not allow to bind socket to restricted network.
@ -2397,7 +2397,7 @@ public class ConnectivityManagerTest {
}
if (supportTelephony) {
telephonyCb.eventuallyExpect(
CallbackEntry.AVAILABLE, CELL_DATA_AVAILABLE_TIMEOUT_MS);
Event.AVAILABLE, CELL_DATA_AVAILABLE_TIMEOUT_MS);
}
} finally {
// Restore the previous state of airplane mode and permissions:
@ -2413,16 +2413,16 @@ public class ConnectivityManagerTest {
waitForAvailable(cb);
}
private CallbackEntry.Available waitForAvailable(@NonNull final TestableNetworkCallback cb) {
return cb.eventuallyExpect(CallbackEntry.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
c -> c instanceof CallbackEntry.Available);
private Event.Available waitForAvailable(@NonNull final TestableNetworkCallback cb) {
return cb.eventuallyExpect(Event.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
c -> c instanceof Event.Available);
}
private void waitForTransport(
@NonNull final TestableNetworkCallback cb, final int expectedTransport) {
cb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
cb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> ((CallbackEntry.CapabilitiesChanged) entry).getCaps()
entry -> ((Event.CapabilitiesChanged) entry).getCaps()
.hasTransport(expectedTransport));
}
@ -2434,8 +2434,8 @@ public class ConnectivityManagerTest {
}
private void waitForLost(@NonNull final TestableNetworkCallback cb) {
cb.eventuallyExpect(CallbackEntry.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
c -> c instanceof CallbackEntry.Lost);
cb.eventuallyExpect(Event.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
c -> c instanceof Event.Lost);
}
private void setAndVerifyAirplaneMode(Boolean expectedResult)
@ -2522,7 +2522,7 @@ public class ConnectivityManagerTest {
// Registering a callback here guarantees onCapabilitiesChanged is called immediately
// because WiFi network should be connected.
final NetworkCapabilities nc = callback.eventuallyExpect(
CallbackEntry.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS).getCaps();
Event.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS).getCaps();
// Verify if ssid is contained in the NetworkCapabilities received from callback.
assertEquals(hasSsid, Pattern.compile(ssid).matcher(nc.toString()).find());
}
@ -2588,10 +2588,10 @@ public class ConnectivityManagerTest {
// non-listen requests will get available callback before it can be put into
// background if no foreground request can be satisfied. Thus, wait for a short
// period is needed to let foreground capability go away.
callback.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
callback.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
c -> c instanceof CallbackEntry.CapabilitiesChanged
&& !((CallbackEntry.CapabilitiesChanged) c).getCaps()
c -> c instanceof Event.CapabilitiesChanged
&& !((Event.CapabilitiesChanged) c).getCaps()
.hasCapability(NET_CAPABILITY_FOREGROUND));
final NetworkCapabilities nc = mCm.getNetworkCapabilities(testNetwork);
assertFalse("expected background network, but got " + nc,
@ -2601,7 +2601,7 @@ public class ConnectivityManagerTest {
runWithShellPermissionIdentity(() -> {
if (null != n) {
tnm.teardownTestNetwork(n);
callback.eventuallyExpect(CallbackEntry.LOST,
callback.eventuallyExpect(Event.LOST,
NETWORK_CALLBACK_TIMEOUT_MS,
lost -> n.equals(lost.getNetwork()));
}
@ -2616,16 +2616,16 @@ public class ConnectivityManagerTest {
BLOCKED_REASON_NONE, NETWORK_CALLBACK_TIMEOUT_MS);
}
public void eventuallyExpectBlockedStatusCallback(Network network, int blockedStatus) {
super.eventuallyExpect(CallbackEntry.BLOCKED_STATUS_INT, NETWORK_CALLBACK_TIMEOUT_MS,
super.eventuallyExpect(Event.BLOCKED_STATUS_INT, NETWORK_CALLBACK_TIMEOUT_MS,
(it) -> it.getNetwork().equals(network) && it.getReason() == blockedStatus);
}
public void onBlockedStatusChanged(Network network, int blockedReasons) {
Log.v(TAG, "onBlockedStatusChanged " + network + " " + blockedReasons);
getHistory().add(new CallbackEntry.BlockedStatusInt(network, blockedReasons));
getHistory().add(new Event.BlockedStatusInt(network, blockedReasons));
}
private void assertNoBlockedStatusCallback() {
super.assertNoCallback(NO_CALLBACK_TIMEOUT_MS,
c -> c instanceof CallbackEntry.BlockedStatus);
c -> c instanceof Event.BlockedStatus);
}
}
@ -2671,7 +2671,7 @@ public class ConnectivityManagerTest {
() -> networkCallbackRule.registerDefaultNetworkCallbackForUid(
otherUid, otherUidCallback, handler), NETWORK_SETTINGS);
final Network defaultNetwork = myUidCallback.expect(CallbackEntry.AVAILABLE).getNetwork();
final Network defaultNetwork = myUidCallback.expect(Event.AVAILABLE).getNetwork();
final List<DetailedBlockedStatusCallback> allCallbacks =
List.of(myUidCallback, otherUidCallback);
for (DetailedBlockedStatusCallback callback : allCallbacks) {
@ -2918,14 +2918,14 @@ public class ConnectivityManagerTest {
// Validate that an unmetered network is used over other networks.
waitForAvailable(defaultCallback, wifiNetwork);
systemDefaultCallback.eventuallyExpect(CallbackEntry.AVAILABLE,
systemDefaultCallback.eventuallyExpect(Event.AVAILABLE,
NETWORK_CALLBACK_TIMEOUT_MS, cb -> wifiNetwork.equals(cb.getNetwork()));
// Validate that when setting unmetered to metered, unmetered is lost and replaced by
// the network with the TEST transport. Also wait for validation here, in case there
// is a bug that's only visible when the network is validated.
setWifiMeteredStatusAndWait(ssid, true /* isMetered */, true /* waitForValidation */);
defaultCallback.eventuallyExpect(CallbackEntry.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
defaultCallback.eventuallyExpect(Event.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
l -> l.getNetwork().equals(wifiNetwork));
waitForAvailable(defaultCallback, tnt.getNetwork());
// Depending on if this device has cellular connectivity or not, multiple available
@ -2938,7 +2938,7 @@ public class ConnectivityManagerTest {
runWithShellPermissionIdentity(tnt::teardown);
// The other callbacks (LP or NC changes) would receive before LOST callback. Use
// eventuallyExpect to check callback for avoiding test flake.
defaultCallback.eventuallyExpect(CallbackEntry.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
defaultCallback.eventuallyExpect(Event.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
lost -> tnt.getNetwork().equals(lost.getNetwork()));
waitForAvailable(defaultCallback);
}, /* cleanup */ () -> {
@ -2974,11 +2974,11 @@ public class ConnectivityManagerTest {
OemNetworkPreferences.OEM_NETWORK_PREFERENCE_TEST_ONLY);
registerTestOemNetworkPreferenceCallbacks(defaultCallback, systemDefaultCallback);
waitForAvailable(defaultCallback, testNetwork);
systemDefaultCallback.eventuallyExpect(CallbackEntry.AVAILABLE,
systemDefaultCallback.eventuallyExpect(Event.AVAILABLE,
NETWORK_CALLBACK_TIMEOUT_MS, cb -> wifiNetwork.equals(cb.getNetwork()));
}, /* cleanup */ () -> {
runWithShellPermissionIdentity(tnt::teardown);
defaultCallback.eventuallyExpect(CallbackEntry.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
defaultCallback.eventuallyExpect(Event.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
cb -> testNetwork.equals(cb.getNetwork()));
// This network preference should only ever use the test network therefore available
@ -3128,7 +3128,7 @@ public class ConnectivityManagerTest {
mCm.setAcceptPartialConnectivity(network, false /* accept */, false /* always */);
});
// Reject partial connectivity network should cause the network being torn down
assertEquals(network, cb.eventuallyExpect(CallbackEntry.LOST).getNetwork());
assertEquals(network, cb.eventuallyExpect(Event.LOST).getNetwork());
} finally {
mHttpServer.stop();
// Wifi will not automatically reconnect to the network. ensureWifiDisconnected cannot
@ -3213,9 +3213,9 @@ public class ConnectivityManagerTest {
makeWifiNetworkRequest());
// Verify wifi is the default network.
defaultCb.eventuallyExpect(CallbackEntry.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
defaultCb.eventuallyExpect(Event.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> wifiNetwork.equals(entry.getNetwork()));
wifiCb.eventuallyExpect(CallbackEntry.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
wifiCb.eventuallyExpect(Event.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> wifiNetwork.equals(entry.getNetwork()));
assertTrue(mCm.getNetworkCapabilities(wifiNetwork).hasCapability(
NET_CAPABILITY_VALIDATED));
@ -3225,20 +3225,20 @@ public class ConnectivityManagerTest {
configTestServer(Status.INTERNAL_ERROR, Status.INTERNAL_ERROR);
mCm.reportNetworkConnectivity(wifiNetwork, false);
// Default network should stay on unvalidated wifi because avoid bad wifi is disabled.
defaultCb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
defaultCb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> !((CallbackEntry.CapabilitiesChanged) entry).getCaps()
entry -> !((Event.CapabilitiesChanged) entry).getCaps()
.hasCapability(NET_CAPABILITY_VALIDATED));
wifiCb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
wifiCb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> !((CallbackEntry.CapabilitiesChanged) entry).getCaps()
entry -> !((Event.CapabilitiesChanged) entry).getCaps()
.hasCapability(NET_CAPABILITY_VALIDATED));
runAsShell(NETWORK_SETTINGS, () -> {
mCm.setAvoidUnvalidated(wifiNetwork);
});
// Default network should be updated to validated cellular network.
defaultCb.eventuallyExpect(CallbackEntry.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
defaultCb.eventuallyExpect(Event.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> cellNetwork.equals(entry.getNetwork()));
// The network should not validate again.
wifiCb.assertNoCallback(NO_CALLBACK_TIMEOUT_MS, c -> isValidatedCaps(c));
@ -3249,9 +3249,9 @@ public class ConnectivityManagerTest {
}
}
private boolean isValidatedCaps(CallbackEntry c) {
if (!(c instanceof CallbackEntry.CapabilitiesChanged)) return false;
final CallbackEntry.CapabilitiesChanged capsChanged = (CallbackEntry.CapabilitiesChanged) c;
private boolean isValidatedCaps(Event c) {
if (!(c instanceof Event.CapabilitiesChanged)) return false;
final Event.CapabilitiesChanged capsChanged = (Event.CapabilitiesChanged) c;
return capsChanged.getCaps().hasCapability(NET_CAPABILITY_VALIDATED);
}
@ -3275,7 +3275,7 @@ public class ConnectivityManagerTest {
private Network expectNetworkHasCapability(Network network, int expectedNetCap, long timeout) {
return networkCallbackRule.registerNetworkCallback(new NetworkRequest.Builder().build())
.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED, timeout,
.eventuallyExpect(Event.NETWORK_CAPS_UPDATED, timeout,
cb -> cb.getNetwork().equals(network)
&& cb.getCaps().hasCapability(expectedNetCap)).getNetwork();
}
@ -3406,8 +3406,8 @@ public class ConnectivityManagerTest {
private void assertNoCallbackExceptCapOrLpChange(
@NonNull final TestableNetworkCallback cb) {
cb.assertNoCallback(NO_CALLBACK_TIMEOUT_MS,
c -> !(c instanceof CallbackEntry.CapabilitiesChanged
|| c instanceof CallbackEntry.LinkPropertiesChanged));
c -> !(c instanceof Event.CapabilitiesChanged
|| c instanceof Event.LinkPropertiesChanged));
}
@AppModeFull(reason = "Cannot get WifiManager in instant app mode")
@ -3456,7 +3456,7 @@ public class ConnectivityManagerTest {
newMobileDataPreferredUids.add(uid);
ConnectivitySettingsManager.setMobileDataPreferredUids(
mContext, newMobileDataPreferredUids);
defaultTrackingCb.eventuallyExpect(CallbackEntry.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
defaultTrackingCb.eventuallyExpect(Event.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> cellNetwork.equals(entry.getNetwork()));
// No change for system default network. Expect no callback except CapabilitiesChanged
// or LinkPropertiesChanged which may be triggered randomly from wifi network.
@ -3469,7 +3469,7 @@ public class ConnectivityManagerTest {
newMobileDataPreferredUids.remove(uid);
ConnectivitySettingsManager.setMobileDataPreferredUids(
mContext, newMobileDataPreferredUids);
defaultTrackingCb.eventuallyExpect(CallbackEntry.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
defaultTrackingCb.eventuallyExpect(Event.AVAILABLE, NETWORK_CALLBACK_TIMEOUT_MS,
entry -> wifiNetwork.equals(entry.getNetwork()));
// No change for system default network. Expect no callback except CapabilitiesChanged
// or LinkPropertiesChanged which may be triggered randomly from wifi network.
@ -3572,10 +3572,10 @@ public class ConnectivityManagerTest {
try (Socket socket = new Socket()) {
// Verify that the network is restricted.
testNetworkCb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
testNetworkCb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> network.equals(entry.getNetwork())
&& (!((CallbackEntry.CapabilitiesChanged) entry).getCaps()
&& (!((Event.CapabilitiesChanged) entry).getCaps()
.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)));
// CtsNetTestCases package doesn't hold CONNECTIVITY_USE_RESTRICTED_NETWORKS, so it
// does not allow to bind socket to restricted network.
@ -3596,10 +3596,10 @@ public class ConnectivityManagerTest {
// Uid is in allowed list. Try file network request again.
networkCallbackRule.requestNetwork(restrictedRequest, restrictedNetworkCb);
// Verify that the network is restricted.
restrictedNetworkCb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED,
restrictedNetworkCb.eventuallyExpect(Event.NETWORK_CAPS_UPDATED,
NETWORK_CALLBACK_TIMEOUT_MS,
entry -> network.equals(entry.getNetwork())
&& (!((CallbackEntry.CapabilitiesChanged) entry).getCaps()
&& (!((Event.CapabilitiesChanged) entry).getCaps()
.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)));
}
} finally {
@ -4036,7 +4036,7 @@ public class ConnectivityManagerTest {
final DetailedBlockedStatusCallback cb = new DetailedBlockedStatusCallback();
networkCallbackRule.registerDefaultNetworkCallback(cb);
final Network network = cb.expect(CallbackEntry.AVAILABLE).getNetwork();
final Network network = cb.expect(Event.AVAILABLE).getNetwork();
testAndCleanup(() -> {
// Disable chain and set RULE_DENY on target chain
runWithShellPermissionIdentity(() -> {
@ -4086,7 +4086,7 @@ public class ConnectivityManagerTest {
final DetailedBlockedStatusCallback cb = new DetailedBlockedStatusCallback();
networkCallbackRule.registerDefaultNetworkCallback(cb);
final Network network = cb.expect(CallbackEntry.AVAILABLE).getNetwork();
final Network network = cb.expect(Event.AVAILABLE).getNetwork();
testAndCleanup(() -> {
cb.eventuallyExpectBlockedStatusCallback(network, BLOCKED_REASON_NONE);

2
tests/cts/net/src/android/net/cts/DnsResolverTapTest.kt
View file

@ -39,7 +39,7 @@ import com.android.testutils.DeviceConfigRule
import com.android.testutils.DnsResolverModuleTest
import com.android.testutils.IPv6UdpFilter
import com.android.testutils.NdResponder
import com.android.testutils.RecorderCallback.CallbackEntry.LinkPropertiesChanged
import com.android.testutils.TestableNetworkCallback.Event.LinkPropertiesChanged
import com.android.testutils.TapPacketReaderRule
import com.android.testutils.TestableNetworkAgent
import com.android.testutils.TestDnsPacket

4
tests/cts/net/src/android/net/cts/DnsResolverTest.java
View file

@ -63,7 +63,7 @@ import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
import com.android.testutils.DeviceConfigRule;
import com.android.testutils.DnsResolverModuleTest;
import com.android.testutils.RecorderCallback.CallbackEntry;
import com.android.testutils.TestableNetworkCallback.Event;
import com.android.testutils.SkipPresubmit;
import com.android.testutils.TestableNetworkCallback;
@ -194,7 +194,7 @@ public class DnsResolverTest {
private Network getDefaultNetwork() {
final TestableNetworkCallback cb = callbackRule.registerDefaultNetworkCallback();
return testAndCleanup(
() -> cb.eventuallyExpect(CallbackEntry.AVAILABLE, TIMEOUT_MS).getNetwork(),
() -> cb.eventuallyExpect(Event.AVAILABLE, TIMEOUT_MS).getNetwork(),
() -> callbackRule.unregisterNetworkCallback(cb));
}

Some files were not shown because too many files have changed in this diff Show more