Merge "Merge "Use CompletableFuture instead of a latch." am: a5f8e9b3d7 am:... (a811c892) · Commits · e / os / android_frameworks_base

packages/Tethering/tests/integration/src/android/net/EthernetTetheringTest.java

+18 −19

Original line number	Original line	Diff line number	Diff line
	@@ -63,6 +63,7 @@ import java.nio.ByteBuffer;
	import java.util.Collection;		import java.util.Collection;
	import java.util.List;		import java.util.List;
	import java.util.Random;		import java.util.Random;
			import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.CountDownLatch;		import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.TimeUnit;		import java.util.concurrent.TimeUnit;

	@@ -150,10 +151,7 @@ public class EthernetTetheringTest {
	Log.d(TAG, "Including test interfaces");		Log.d(TAG, "Including test interfaces");
	mEm.setIncludeTestInterfaces(true);		mEm.setIncludeTestInterfaces(true);

	Log.d(TAG, "Requesting tethered interface");		final String iface = mTetheredInterfaceRequester.getInterface();
	mTetheredInterfaceRequester.requestInterface();

	final String iface = mTetheredInterfaceRequester.awaitRequestedInterface();
	assertEquals("TetheredInterfaceCallback for unexpected interface",		assertEquals("TetheredInterfaceCallback for unexpected interface",
	mTestIface.getInterfaceName(), iface);		mTestIface.getInterfaceName(), iface);

	@@ -165,14 +163,13 @@ public class EthernetTetheringTest {
	// This test requires manipulating packets. Skip if there is a physical Ethernet connected.		// This test requires manipulating packets. Skip if there is a physical Ethernet connected.
	assumeFalse(mEm.isAvailable());		assumeFalse(mEm.isAvailable());

	Log.d(TAG, "Requesting tethered interface");		CompletableFuture<String> futureIface = mTetheredInterfaceRequester.requestInterface();
	mTetheredInterfaceRequester.requestInterface();

	mEm.setIncludeTestInterfaces(true);		mEm.setIncludeTestInterfaces(true);

	mTestIface = createTestInterface();		mTestIface = createTestInterface();

	final String iface = mTetheredInterfaceRequester.awaitRequestedInterface();		final String iface = futureIface.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
	assertEquals("TetheredInterfaceCallback for unexpected interface",		assertEquals("TetheredInterfaceCallback for unexpected interface",
	mTestIface.getInterfaceName(), iface);		mTestIface.getInterfaceName(), iface);

	@@ -184,8 +181,7 @@ public class EthernetTetheringTest {
	assumeTrue(mEm.isAvailable());		assumeTrue(mEm.isAvailable());

	// Get an interface to use.		// Get an interface to use.
	mTetheredInterfaceRequester.requestInterface();		final String iface = mTetheredInterfaceRequester.getInterface();
	String iface = mTetheredInterfaceRequester.awaitRequestedInterface();

	// Enable Ethernet tethering and check that it starts.		// Enable Ethernet tethering and check that it starts.
	mTetheringEventCallback = enableEthernetTethering(iface);		mTetheringEventCallback = enableEthernetTethering(iface);
	@@ -373,8 +369,8 @@ public class EthernetTetheringTest {
	private final Handler mHandler;		private final Handler mHandler;
	private final EthernetManager mEm;		private final EthernetManager mEm;

	private volatile TetheredInterfaceRequest mRequest;		private TetheredInterfaceRequest mRequest;
	private volatile String mIface;		private final CompletableFuture<String> mFuture = new CompletableFuture<>();

	TetheredInterfaceRequester(Handler handler, EthernetManager em) {		TetheredInterfaceRequester(Handler handler, EthernetManager em) {
	mHandler = handler;		mHandler = handler;
	@@ -384,25 +380,28 @@ public class EthernetTetheringTest {
	@Override		@Override
	public void onAvailable(String iface) {		public void onAvailable(String iface) {
	Log.d(TAG, "Ethernet interface available: " + iface);		Log.d(TAG, "Ethernet interface available: " + iface);
	mIface = iface;		mFuture.complete(iface);
	mInterfaceAvailableLatch.countDown();
	}		}

	@Override		@Override
	public void onUnavailable() {}		public void onUnavailable() {
			mFuture.completeExceptionally(new IllegalStateException("onUnavailable received"));
			}

	public void requestInterface() {		public CompletableFuture<String> requestInterface() {
	assertNull("BUG: more than one tethered interface request", mRequest);		assertNull("BUG: more than one tethered interface request", mRequest);
			Log.d(TAG, "Requesting tethered interface");
	mRequest = mEm.requestTetheredInterface(mHandler::post, this);		mRequest = mEm.requestTetheredInterface(mHandler::post, this);
			return mFuture;
	}		}

	public String awaitRequestedInterface() throws InterruptedException {		public String getInterface() throws Exception {
	assertTrue("No tethered interface available after " + TIMEOUT_MS + "ms",		return requestInterface().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
	mInterfaceAvailableLatch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
	return mIface;
	}		}

	public void release() {		public void release() {
	if (mRequest != null) {		if (mRequest != null) {
			mFuture.obtrudeException(new IllegalStateException("Request already released"));
	mRequest.release();		mRequest.release();
	mRequest = null;		mRequest = null;
	}		}