Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a0a5b5bd authored by Lorenzo Colitti's avatar Lorenzo Colitti
Browse files

Use CompletableFuture instead of a latch. 

Addresses review comments on aosp/1260100.

Bug: 150644681
Test: test-only change
Change-Id: Ia73ba8a121a3744a5e36795d2d2bff2f099c1394
parent 77481306

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;

            }

            }