From bbd10f21a0b7ffa4584f1066170d34ffb2856cc8 Mon Sep 17 00:00:00 2001 From: Mark Chien Date: Wed, 8 Apr 2020 13:10:26 +0000 Subject: [PATCH 1/5] Add testRegisterTetheringEventCallback for CtsTetheringTest Bug: 150632712 Bug: 150631563 Test: atest CtsTetheringTest Merged-In: I55895c8b26acb7ec905d75d1f4b2a8964b13187a Change-Id: I55895c8b26acb7ec905d75d1f4b2a8964b13187a --- .../tethering/cts/TetheringManagerTest.java | 181 +++++++++++++++++- 1 file changed, 179 insertions(+), 2 deletions(-) diff --git a/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java b/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java index 86fe54ce54..b132982e1a 100644 --- a/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java +++ b/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java @@ -29,9 +29,14 @@ import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.net.LinkAddress; +import android.net.Network; +import android.net.TetheredClient; import android.net.TetheringManager; +import android.net.TetheringManager.TetheringEventCallback; +import android.net.TetheringManager.TetheringInterfaceRegexps; import android.net.TetheringManager.TetheringRequest; +import androidx.annotation.NonNull; import androidx.test.InstrumentationRegistry; import androidx.test.runner.AndroidJUnit4; @@ -42,6 +47,8 @@ import org.junit.runner.RunWith; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collection; +import java.util.List; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; @@ -195,8 +202,12 @@ public class TetheringManagerTest { } } - private static boolean isIfaceMatch(final String[] ifaceRegexs, - final ArrayList ifaces) { + private static boolean isIfaceMatch(final List ifaceRegexs, + final List ifaces) { + return isIfaceMatch(ifaceRegexs.toArray(new String[0]), ifaces); + } + + private static boolean isIfaceMatch(final String[] ifaceRegexs, final List ifaces) { if (ifaceRegexs == null) fail("ifaceRegexs should not be null"); if (ifaces == null) return false; @@ -251,4 +262,170 @@ public class TetheringManagerTest { assertTrue(tr2.isExemptFromEntitlementCheck()); assertFalse(tr2.getShouldShowEntitlementUi()); } + + // Must poll the callback before looking at the member. + private static class TestTetheringEventCallback implements TetheringEventCallback { + public enum CallbackType { + ON_SUPPORTED, + ON_UPSTREAM, + ON_TETHERABLE_REGEX, + ON_TETHERABLE_IFACES, + ON_TETHERED_IFACES, + ON_ERROR, + ON_CLIENTS, + }; + + public static class CallbackValue { + public final CallbackType callbackType; + public final Object callbackParam; + public final int callbackParam2; + + private CallbackValue(final CallbackType type, final Object param, final int param2) { + this.callbackType = type; + this.callbackParam = param; + this.callbackParam2 = param2; + } + } + private final LinkedBlockingQueue mCallbacks = new LinkedBlockingQueue<>(); + + private TetheringInterfaceRegexps mTetherableRegex; + private List mTetherableIfaces; + private List mTetheredIfaces; + + @Override + public void onTetheringSupported(boolean supported) { + mCallbacks.add(new CallbackValue(CallbackType.ON_SUPPORTED, null, 0)); + } + + @Override + public void onUpstreamChanged(Network network) { + mCallbacks.add(new CallbackValue(CallbackType.ON_UPSTREAM, network, 0)); + } + + @Override + public void onTetherableInterfaceRegexpsChanged(TetheringInterfaceRegexps reg) { + mTetherableRegex = reg; + mCallbacks.add(new CallbackValue(CallbackType.ON_TETHERABLE_REGEX, reg, 0)); + } + + @Override + public void onTetherableInterfacesChanged(List interfaces) { + mTetherableIfaces = interfaces; + mCallbacks.add(new CallbackValue(CallbackType.ON_TETHERABLE_IFACES, interfaces, 0)); + } + + @Override + public void onTetheredInterfacesChanged(List interfaces) { + mTetheredIfaces = interfaces; + mCallbacks.add(new CallbackValue(CallbackType.ON_TETHERED_IFACES, interfaces, 0)); + } + + @Override + public void onError(String ifName, int error) { + mCallbacks.add(new CallbackValue(CallbackType.ON_ERROR, ifName, error)); + } + + @Override + public void onClientsChanged(Collection clients) { + mCallbacks.add(new CallbackValue(CallbackType.ON_CLIENTS, clients, 0)); + } + + public CallbackValue pollCallback() { + try { + return mCallbacks.poll(DEFAULT_TIMEOUT_MS, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + fail("Callback not seen"); + } + return null; + } + + public void expectTetherableInterfacesChanged(@NonNull List regexs) { + while (true) { + final CallbackValue cv = pollCallback(); + if (cv == null) fail("No expected tetherable ifaces callback"); + if (cv.callbackType != CallbackType.ON_TETHERABLE_IFACES) continue; + + final List interfaces = (List) cv.callbackParam; + if (isIfaceMatch(regexs, interfaces)) break; + } + } + + public void expectTetheredInterfacesChanged(@NonNull List regexs) { + while (true) { + final CallbackValue cv = pollCallback(); + if (cv == null) fail("No expected tethered ifaces callback"); + if (cv.callbackType != CallbackType.ON_TETHERED_IFACES) continue; + + final List interfaces = (List) cv.callbackParam; + + // Null regexs means no active tethering. + if (regexs == null) { + if (interfaces.size() == 0) break; + } else if (isIfaceMatch(regexs, interfaces)) { + break; + } + } + } + + public void expectCallbackStarted() { + // The each bit represent a type from CallbackType.ON_*. + // Expect all of callbacks except for ON_ERROR. + final int expectedBitMap = 0x7f ^ (1 << CallbackType.ON_ERROR.ordinal()); + int receivedBitMap = 0; + while (receivedBitMap != expectedBitMap) { + final CallbackValue cv = pollCallback(); + if (cv == null) { + fail("No expected callbacks, " + "expected bitmap: " + + expectedBitMap + ", actual: " + receivedBitMap); + } + receivedBitMap = receivedBitMap | (1 << cv.callbackType.ordinal()); + } + } + + public TetheringInterfaceRegexps getTetheringInterfaceRegexps() { + return mTetherableRegex; + } + + public List getTetherableInterfaces() { + return mTetherableIfaces; + } + + public List getTetheredInterfaces() { + return mTetheredIfaces; + } + } + + @Test + public void testRegisterTetheringEventCallback() throws Exception { + if (!mTM.isTetheringSupported()) return; + + final TestTetheringEventCallback tetherEventCallback = new TestTetheringEventCallback(); + + mTM.registerTetheringEventCallback(c -> c.run(), tetherEventCallback); + tetherEventCallback.expectCallbackStarted(); + + final TetheringInterfaceRegexps tetherableRegexs = + tetherEventCallback.getTetheringInterfaceRegexps(); + final List wifiRegexs = tetherableRegexs.getTetherableWifiRegexs(); + if (wifiRegexs.size() == 0) return; + + final boolean isIfaceAvailWhenNoTethering = + isIfaceMatch(wifiRegexs, tetherEventCallback.getTetherableInterfaces()); + + mTM.startTethering(new TetheringRequest.Builder(TETHERING_WIFI).build(), c -> c.run(), + new StartTetheringCallback()); + + // If interface is already available before starting tethering, the available callback may + // not be sent after tethering enabled. + if (!isIfaceAvailWhenNoTethering) { + tetherEventCallback.expectTetherableInterfacesChanged(wifiRegexs); + } + + tetherEventCallback.expectTetheredInterfacesChanged(wifiRegexs); + + mTM.stopTethering(TETHERING_WIFI); + + tetherEventCallback.expectTetheredInterfacesChanged(null); + mTM.unregisterTetheringEventCallback(tetherEventCallback); + } } From 5eaf009a929d4f7a4bdd1f53767e6ec95cb0cee4 Mon Sep 17 00:00:00 2001 From: Treehugger Robot Date: Mon, 13 Apr 2020 15:02:00 +0000 Subject: [PATCH 2/5] Add tethering CTS owners. Test: none Bug: 153921802 Change-Id: I0651e7fa2a705b553f2d24ca573936c28591bb84 Merged-In: I552b3bf8d79c4e4480396edc201b51ec5901b87b (cherry picked from commit 7f210a41827742b1448a82d093a651898f40ad2e) --- tests/cts/tethering/OWNERS | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 tests/cts/tethering/OWNERS diff --git a/tests/cts/tethering/OWNERS b/tests/cts/tethering/OWNERS new file mode 100644 index 0000000000..cd6abeb6e8 --- /dev/null +++ b/tests/cts/tethering/OWNERS @@ -0,0 +1,4 @@ +# Bug component: 31808 +lorenzo@google.com +satk@google.com + From 524f93613fdb5f8ad180681be593133cf77474fb Mon Sep 17 00:00:00 2001 From: Chalard Jean Date: Sun, 12 Apr 2020 14:53:45 +0000 Subject: [PATCH 3/5] Test onBandwidthUpdateRequested Test: this Bug: 139268426 Change-Id: I5f4b42dc68fdd13f26e59b4e2217d39dcee8f2a1 Merged-In: I427ae6ac2c8910683e47f503ba71a05e35507571 (cherry picked from commit bbe53cd710440468520d5d5713eaa503b6c9d8b9, aosp/1258136) --- .../net/src/android/net/cts/NetworkAgentTest.kt | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt index 85c94e7db2..2fdd5fb201 100644 --- a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt +++ b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt @@ -24,6 +24,7 @@ import android.net.NetworkAgentConfig import android.net.NetworkCapabilities import android.net.NetworkProvider import android.net.NetworkRequest +import android.net.cts.NetworkAgentTest.TestableNetworkAgent.CallbackEntry.OnBandwidthUpdateRequested import android.net.cts.NetworkAgentTest.TestableNetworkAgent.CallbackEntry.OnNetworkUnwanted import android.os.Build import android.os.HandlerThread @@ -88,9 +89,15 @@ class NetworkAgentTest { private val history = ArrayTrackRecord().newReadHead() sealed class CallbackEntry { + object OnBandwidthUpdateRequested : CallbackEntry() object OnNetworkUnwanted : CallbackEntry() } + override fun onBandwidthUpdateRequested() { + super.onBandwidthUpdateRequested() + history.add(OnBandwidthUpdateRequested) + } + override fun onNetworkUnwanted() { super.onNetworkUnwanted() history.add(OnNetworkUnwanted) @@ -139,4 +146,13 @@ class NetworkAgentTest { agent.register() } } + + @Test + fun testOnBandwidthUpdateRequested() { + val (agent, callback) = createConnectedNetworkAgent() + callback.expectAvailableThenValidatedCallbacks(agent.network) + mCM.requestBandwidthUpdate(agent.network) + agent.expectCallback() + agent.unregister() + } } From 9849d899e82ca196032c5c212e09c3db25f6e005 Mon Sep 17 00:00:00 2001 From: Paul Hu Date: Tue, 14 Apr 2020 10:04:07 +0000 Subject: [PATCH 4/5] Add TetherableInterfaceRegexps CTS tests Test APIs below: getTetherableWifiRegexs() getTetherableUsbRegexs() getTetherableBluetoothRegexs() TetheringInterfaceRegexps.getTetherableWifiRegexs() TetheringInterfaceRegexps.getTetherableUsbRegexs() TetheringInterfaceRegexps.getTetherableBluetoothRegexs() Bug: 152737526 Test: atest CtsTetheringTest Change-Id: Icb7d8718d0aa6574b4c9dd1e17d7feb300fad2aa Merged-In: Icb7d8718d0aa6574b4c9dd1e17d7feb300fad2aa (cherry picked from commit 9f11d903a1d8cc6705481360bae4fb97cfbb966d, aosp/1271822) --- .../tethering/cts/TetheringManagerTest.java | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java b/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java index b132982e1a..193a5dc3a4 100644 --- a/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java +++ b/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java @@ -428,4 +428,30 @@ public class TetheringManagerTest { tetherEventCallback.expectTetheredInterfacesChanged(null); mTM.unregisterTetheringEventCallback(tetherEventCallback); } + + @Test + public void testGetTetherableInterfaceRegexps() { + if (!mTM.isTetheringSupported()) return; + + final TestTetheringEventCallback tetherEventCallback = new TestTetheringEventCallback(); + mTM.registerTetheringEventCallback(c -> c.run(), tetherEventCallback); + tetherEventCallback.expectCallbackStarted(); + + final TetheringInterfaceRegexps tetherableRegexs = + tetherEventCallback.getTetheringInterfaceRegexps(); + final List wifiRegexs = tetherableRegexs.getTetherableWifiRegexs(); + final List usbRegexs = tetherableRegexs.getTetherableUsbRegexs(); + final List btRegexs = tetherableRegexs.getTetherableBluetoothRegexs(); + + assertEquals(wifiRegexs, Arrays.asList(mTM.getTetherableWifiRegexs())); + assertEquals(usbRegexs, Arrays.asList(mTM.getTetherableUsbRegexs())); + assertEquals(btRegexs, Arrays.asList(mTM.getTetherableBluetoothRegexs())); + + //Verify that any of interface name should only contain in one array. + wifiRegexs.forEach(s -> assertFalse(usbRegexs.contains(s))); + wifiRegexs.forEach(s -> assertFalse(btRegexs.contains(s))); + usbRegexs.forEach(s -> assertFalse(btRegexs.contains(s))); + + mTM.unregisterTetheringEventCallback(tetherEventCallback); + } } From 643abc73d93c0fcc3b316b0b56bc371ebdf47932 Mon Sep 17 00:00:00 2001 From: Sudheer Shanka Date: Mon, 13 Apr 2020 22:39:21 -0700 Subject: [PATCH 5/5] Ensure location is enabled before getting SSID. When location is disabled, Wi-Fi scan results and SSID are not available to apps. Fixes: 153850762 Fixes: 153396893 Test: atest hostsidetests/net/src/com/android/cts/net/HostsideRestrictBackgroundNetworkTests.java Change-Id: I05285811d7131e116d5e1d072137ed2cf9576d05 --- tests/cts/hostside/AndroidTest.xml | 1 + ...ractRestrictBackgroundNetworkTestCase.java | 31 ---------------- .../net/hostside/NetworkPolicyTestUtils.java | 35 +++++++++++++++++-- 3 files changed, 33 insertions(+), 34 deletions(-) diff --git a/tests/cts/hostside/AndroidTest.xml b/tests/cts/hostside/AndroidTest.xml index 7cc0dd19cc..b7fefaf3b5 100644 --- a/tests/cts/hostside/AndroidTest.xml +++ b/tests/cts/hostside/AndroidTest.xml @@ -20,6 +20,7 @@