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

Start Ethernet tethering test once before testing

Browse source 
The first tethering test case might have a tethering restart when
handling IP conflicts. Currently, we start a hotspot once before
tethering, but the test is still flaky in Cuttlefish because it
doesn't support hotspots. Instead, we'll start ethernet tethering.

Bug: 254183718
Test: atest CtsTetheringTest
Change-Id: I695d4e1b3f961893bc30b3144faf7ad7d2d70574
This commit is contained in:
Mark 2023-12-05 05:53:43 +00:00 • committed by Mark Chien
commit 2d0652a465
1 changed files with 31 additions and 19 deletions
Download patch file Download diff file Expand all files Collapse all files

50
Tethering/tests/integration/base/android/net/EthernetTetheringTestBase.java
View file

@ -57,8 +57,6 @@ import android.net.TetheringManager.TetheringEventCallback;
import android.net.TetheringManager.TetheringRequest;
import android.net.TetheringTester.TetheredDevice;
import android.net.cts.util.CtsNetUtils;
import android.net.cts.util.CtsTetheringUtils;
import android.net.cts.util.CtsTetheringUtils.TestTetheringEventCallback;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.SystemClock;
@ -172,18 +170,24 @@ public abstract class EthernetTetheringTestBase {
// Tethering would cache the last upstreams so that the next enabled tethering avoids
// picking up the address that is in conflict with the upstreams. To protect subsequent
// tests, turn tethering on and off before running them.
final CtsTetheringUtils utils = new CtsTetheringUtils(sContext);
final TestTetheringEventCallback callback = utils.registerTetheringEventCallback();
MyTetheringEventCallback callback = null;
TestNetworkInterface testIface = null;
try {
if (!callback.isWifiTetheringSupported(sContext)) return;
// If the physical ethernet interface is available, do nothing.
if (isInterfaceForTetheringAvailable()) return;
callback.expectNoTetheringActive();
testIface = createTestInterface();
setIncludeTestInterfaces(true);
utils.startWifiTethering(callback);
callback.getCurrentValidUpstream();
utils.stopWifiTethering(callback);
callback = enableEthernetTethering(testIface.getInterfaceName(), null);
callback.awaitUpstreamChanged(true /* throwTimeoutException */);
} catch (TimeoutException e) {
Log.d(TAG, "WARNNING " + e);
} finally {
utils.unregisterTetheringEventCallback(callback);
maybeCloseTestInterface(testIface);
maybeUnregisterTetheringEventCallback(callback);
setIncludeTestInterfaces(false);
}
}
@ -213,7 +217,7 @@ public abstract class EthernetTetheringTestBase {
}
}
protected void maybeCloseTestInterface(final TestNetworkInterface testInterface)
protected static void maybeCloseTestInterface(final TestNetworkInterface testInterface)
throws Exception {
if (testInterface != null) {
testInterface.getFileDescriptor().close();
@ -221,8 +225,8 @@ public abstract class EthernetTetheringTestBase {
}
}
protected void maybeUnregisterTetheringEventCallback(final MyTetheringEventCallback callback)
throws Exception {
protected static void maybeUnregisterTetheringEventCallback(
final MyTetheringEventCallback callback) throws Exception {
if (callback != null) {
callback.awaitInterfaceUntethered();
callback.unregister();
@ -307,13 +311,13 @@ public abstract class EthernetTetheringTestBase {
}
}
protected void setIncludeTestInterfaces(boolean include) {
protected static void setIncludeTestInterfaces(boolean include) {
runAsShell(NETWORK_SETTINGS, () -> {
sEm.setIncludeTestInterfaces(include);
});
}
protected void setPreferTestNetworks(boolean prefer) {
protected static void setPreferTestNetworks(boolean prefer) {
runAsShell(NETWORK_SETTINGS, () -> {
sTm.setPreferTestNetworks(prefer);
});
@ -355,7 +359,7 @@ public abstract class EthernetTetheringTestBase {
private final TetheringInterface mIface;
private final Network mExpectedUpstream;
private boolean mAcceptAnyUpstream = false;
private final boolean mAcceptAnyUpstream;
private volatile boolean mInterfaceWasTethered = false;
private volatile boolean mInterfaceWasLocalOnly = false;
@ -369,13 +373,16 @@ public abstract class EthernetTetheringTestBase {
private static final int EXPANDED_TIMEOUT_MS = 30000;
MyTetheringEventCallback(String iface) {
this(iface, null);
mIface = new TetheringInterface(TETHERING_ETHERNET, iface);
mExpectedUpstream = null;
mAcceptAnyUpstream = true;
}
MyTetheringEventCallback(String iface, Network expectedUpstream) {
MyTetheringEventCallback(String iface, @NonNull Network expectedUpstream) {
Objects.requireNonNull(expectedUpstream);
mIface = new TetheringInterface(TETHERING_ETHERNET, iface);
mExpectedUpstream = expectedUpstream;
mAcceptAnyUpstream = false;
}
public void unregister() {
@ -503,6 +510,11 @@ public abstract class EthernetTetheringTestBase {
Log.d(TAG, "Got upstream changed: " + network);
mUpstream = network;
// The callback always updates the current tethering status when it's first registered.
// If the caller registers the callback before tethering starts, the null upstream
// would be updated. Filtering out the null case because it's not a valid upstream that
// we care about.
if (mUpstream == null) return;
if (mAcceptAnyUpstream || Objects.equals(mUpstream, mExpectedUpstream)) {
mUpstreamLatch.countDown();
}
@ -643,7 +655,7 @@ public abstract class EthernetTetheringTestBase {
}
}
protected TestNetworkInterface createTestInterface() throws Exception {
protected static TestNetworkInterface createTestInterface() throws Exception {
TestNetworkManager tnm = runAsShell(MANAGE_TEST_NETWORKS, () ->
sContext.getSystemService(TestNetworkManager.class));
TestNetworkInterface iface = runAsShell(MANAGE_TEST_NETWORKS, () ->