Enable NQE when Cronet Engine is built

components/cronet/android/test/javatests/src/org/chromium/net/CronetUrlRequestContextTest.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.net;
 
 import static org.chromium.base.CollectionUtil.newHashSet;
 
 import android.content.Context;
 import android.content.ContextWrapper;
 import android.os.ConditionVariable;
 import android.os.Handler;
 import android.os.Looper;
+import android.os.StrictMode;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.PathUtils;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.test.util.Feature;
 import org.chromium.base.test.util.FlakyTest;
 import org.chromium.net.CronetEngine.UrlRequestInfo;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
 import org.chromium.net.test.EmbeddedTestServer;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.NoSuchElementException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
 
 /**
  * Test CronetEngine.
  */
 @JNINamespace("cronet")
 public class CronetUrlRequestContextTest extends CronetTestBase {
     // URLs used for tests.
     private static final String MOCK_CRONET_TEST_FAILED_URL =
             "http://mock.failed.request/-2";
     private static final String MOCK_CRONET_TEST_SUCCESS_URL =
             "http://mock.http/success.txt";
 
     private EmbeddedTestServer mTestServer;
     private String mUrl;
     private String mUrl404;
     private String mUrl500;
     CronetTestFramework mTestFramework;
 
+    // Thread on which network quality listeners should be notified.
+    private Thread mNetworkQualityThread;
+
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mTestServer = EmbeddedTestServer.createAndStartDefaultServer(getContext());
         mUrl = mTestServer.getURL("/echo?status=200");
         mUrl404 = mTestServer.getURL("/echo?status=404");
         mUrl500 = mTestServer.getURL("/echo?status=500");
     }
 
     @Override
@@ skipping 57 matching lines @@
         public void runAllTasks() {
             try {
                 while (mTaskQueue.size() > 0) {
                     mTaskQueue.remove().run();
                 }
             } catch (NoSuchElementException e) {
             }
         }
     }
 
-    static class TestNetworkQualityListener
-            implements NetworkQualityRttListener, NetworkQualityThroughputListener {
-        // Lock to ensure that observation counts can be updated and read by different threads.
-        private final Object mLock = new Object();
-        private final ConditionVariable mWaitForThroughput;
-        private int mRttObservationCount;
-        private int mThroughputObservationCount;
-
-        TestNetworkQualityListener(ConditionVariable waitForThroughput) {
-            mWaitForThroughput = waitForThroughput;
-        }
-
-        @Override
-        public void onRttObservation(int rttMs, long when, int source) {
-            synchronized (mLock) {
-                mRttObservationCount++;
-            }
-        }
-
-        @Override
-        public void onThroughputObservation(int throughputKbps, long when, int source) {
-            synchronized (mLock) {
-                if (mWaitForThroughput != null) {
-                    mWaitForThroughput.open();
+    private class ExecutorThreadFactory implements ThreadFactory {
+        public Thread newThread(final Runnable r) {
+            mNetworkQualityThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    StrictMode.ThreadPolicy threadPolicy = StrictMode.getThreadPolicy();
+                    try {
+                        StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
+                                                           .detectNetwork()
+                                                           .penaltyLog()
+                                                           .penaltyDeath()
+                                                           .build());
+                        r.run();
+                    } finally {
+                        StrictMode.setThreadPolicy(threadPolicy);
+                    }
                 }
-                mThroughputObservationCount++;
-            }
-        }
-
-        public int rttObservationCount() {
-            synchronized (mLock) {
-                return mRttObservationCount;
-            }
-        }
-
-        public int throughputObservationCount() {
-            synchronized (mLock) {
-                return mThroughputObservationCount;
-            }
+            });
+            return mNetworkQualityThread;
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testConfigUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
         CronetEngine.Builder cronetEngineBuilder = new CronetEngine.Builder(getContext());
         if (testingJavaImpl()) {
@@ skipping 56 matching lines @@
         // Proxy logic configured to use the test server as its proxy.
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(serverHostPort, callback.mResponseInfo.getProxyServer());
         assertEquals("http://DomainThatDoesnt.Resolve/datareductionproxysuccess.txt",
                 callback.mResponseInfo.getUrl());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsNotEnabled() throws Exception {
-        mTestFramework = startCronetTestFramework();
-        TestNetworkQualityListener networkQualityListener = new TestNetworkQualityListener(null);
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        Executor networkQualityExecutor = Executors.newSingleThreadExecutor();
+        TestNetworkQualityRttListener rttListener =
+                new TestNetworkQualityRttListener(networkQualityExecutor);
+        TestNetworkQualityThroughputListener throughputListener =
+                new TestNetworkQualityThroughputListener(networkQualityExecutor, null);
         try {
-            mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
+            mTestFramework.mCronetEngine.addRttListener(rttListener);
             fail("Should throw an exception.");
         } catch (IllegalStateException e) {
         }
         try {
-            mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
+            mTestFramework.mCronetEngine.addThroughputListener(throughputListener);
             fail("Should throw an exception.");
         } catch (IllegalStateException e) {
         }
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest urlRequest =
                 mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
         urlRequest.start();
         callback.blockForDone();
-        assertEquals(0, networkQualityListener.rttObservationCount());
-        assertEquals(0, networkQualityListener.throughputObservationCount());
+        assertEquals(0, rttListener.rttObservationCount());
+        assertEquals(0, throughputListener.throughputObservationCount());
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testRealTimeNetworkQualityObservationsNotEnabled_LegacyAPI() throws Exception {
+        mTestFramework = startCronetTestFramework();
+        TestNetworkQualityRttListener rttListener = new TestNetworkQualityRttListener();
+        try {
+            mTestFramework.mCronetEngine.addRttListener(rttListener);
+            fail("Should throw an exception.");
+        } catch (IllegalStateException e) {
+        }
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest urlRequest =
+                mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
+        urlRequest.start();
+        callback.blockForDone();
+        assertEquals(0, rttListener.rttObservationCount());
         mTestFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testRealTimeNetworkQualityObservationsListenerRemoved() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        TestExecutor networkQualityExecutor = new TestExecutor();
+        TestNetworkQualityRttListener rttListener =
+                new TestNetworkQualityRttListener(networkQualityExecutor);
+        mCronetEngineBuilder.enableNetworkQualityEstimator(true);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+
+        mTestFramework.mCronetEngine.addRttListener(rttListener);
+        mTestFramework.mCronetEngine.removeRttListener(rttListener);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest urlRequest =
+                mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
+        urlRequest.start();
+        callback.blockForDone();
+        networkQualityExecutor.runAllTasks();
+        assertEquals(0, rttListener.rttObservationCount());
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testRealTimeNetworkQualityObservationsListenerRemoved_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
-        TestNetworkQualityListener networkQualityListener = new TestNetworkQualityListener(null);
-        mTestFramework.mCronetEngine.enableNetworkQualityEstimatorForTesting(
-                true, true, testExecutor);
-        mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
-        mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
-        mTestFramework.mCronetEngine.removeRttListener(networkQualityListener);
-        mTestFramework.mCronetEngine.removeThroughputListener(networkQualityListener);
+        TestNetworkQualityRttListener rttListener = new TestNetworkQualityRttListener();
+        mTestFramework.mCronetEngine.enableNetworkQualityEstimator(testExecutor);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+        mTestFramework.mCronetEngine.addRttListener(rttListener);
+        mTestFramework.mCronetEngine.removeRttListener(rttListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest urlRequest =
                 mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
         urlRequest.start();
         callback.blockForDone();
         testExecutor.runAllTasks();
-        assertEquals(0, networkQualityListener.rttObservationCount());
-        assertEquals(0, networkQualityListener.throughputObservationCount());
+        assertEquals(0, rttListener.rttObservationCount());
         mTestFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
-    public void testRealTimeNetworkQualityObservations() throws Exception {
+    public void testRealTimeNetworkQualityObservationsQuicDisabled() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        Executor requestFinishedListenerExecutor =
+                Executors.newSingleThreadExecutor(new ExecutorThreadFactory());
+        Executor listenersExecutor = Executors.newSingleThreadExecutor(new ExecutorThreadFactory());
+        ConditionVariable waitForThroughput = new ConditionVariable();
+        TestNetworkQualityRttListener rttListener =
+                new TestNetworkQualityRttListener(listenersExecutor);
+        TestNetworkQualityThroughputListener throughputListener =
+                new TestNetworkQualityThroughputListener(listenersExecutor, waitForThroughput);
+        mCronetEngineBuilder.enableHTTP2(true).enableQUIC(false).enableNetworkQualityEstimator(
+                true);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+        // requestFinishedListenerExecutor should not be used for notifying the RTT and
+        // throughput listeners.
+        mTestFramework.mCronetEngine.setRequestFinishedListenerExecutor(
+                requestFinishedListenerExecutor);
+
+        mTestFramework.mCronetEngine.addRttListener(rttListener);
+        mTestFramework.mCronetEngine.addThroughputListener(throughputListener);
+
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest urlRequest =
+                mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
+        urlRequest.start();
+        callback.blockForDone();
+
+        // Throughput observation is posted to the network quality estimator on the network thread
+        // after the UrlRequest is completed. The observations are then eventually posted to
+        // throughput listeners on the executor provided to network quality.
+        waitForThroughput.block();
+        assertTrue(throughputListener.throughputObservationCount() > 0);
+
+        // Check RTT observation count after throughput observation has been received. This ensures
+        // that executor has finished posting the RTT observation to the RTT listeners.
+        assertTrue(rttListener.rttObservationCount() > 0);
+
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST
+        assertTrue(rttListener.rttObservationCount(0) > 0);
+
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_TCP
+        assertTrue(rttListener.rttObservationCount(1) > 0);
+
+        // NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC
+        assertEquals(0, rttListener.rttObservationCount(2));
+
+        // Verify that the listeners were notified on the expected thread.
+        assertEquals(mNetworkQualityThread, rttListener.getThread());
+        assertEquals(mNetworkQualityThread, throughputListener.getThread());
+
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testRealTimeNetworkQualityObservations_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         Executor executor = Executors.newSingleThreadExecutor();
         ConditionVariable waitForThroughput = new ConditionVariable();
-        TestNetworkQualityListener networkQualityListener =
-                new TestNetworkQualityListener(waitForThroughput);
-        mTestFramework.mCronetEngine.enableNetworkQualityEstimatorForTesting(true, true, executor);
-        mTestFramework.mCronetEngine.addRttListener(networkQualityListener);
-        mTestFramework.mCronetEngine.addThroughputListener(networkQualityListener);
+        TestNetworkQualityRttListener rttListener = new TestNetworkQualityRttListener();
+        TestNetworkQualityThroughputListener throughputListener =
+                new TestNetworkQualityThroughputListener(executor, waitForThroughput);
+        mTestFramework.mCronetEngine.enableNetworkQualityEstimator(executor);
+        mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true);
+        mTestFramework.mCronetEngine.addRttListener(rttListener);
+        mTestFramework.mCronetEngine.addThroughputListener(throughputListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest urlRequest =
                 mTestFramework.mCronetEngine.createRequest(mUrl, callback, callback.getExecutor());
         urlRequest.start();
         callback.blockForDone();
 
         // Throughput observation is posted to the network quality estimator on the network thread
         // after the UrlRequest is completed. The observations are then eventually posted to
         // throughput listeners on the executor provided to network quality.
         waitForThroughput.block();
-        assertTrue(networkQualityListener.throughputObservationCount() > 0);
+        assertTrue(throughputListener.throughputObservationCount() > 0);
 
         // Check RTT observation count after throughput observation has been received. This ensures
         // that executor has finished posting the RTT observation to the RTT listeners.
-        assertTrue(networkQualityListener.rttObservationCount() > 0);
+        assertTrue(rttListener.rttObservationCount() > 0);
 
         mTestFramework.mCronetEngine.shutdown();
     }
 
+    // TODO(tbansal):  http://crbug.com/618034 Remove this.
     private static class TestRequestFinishedListener
             implements CronetEngine.RequestFinishedListener {
         private UrlRequestInfo mRequestInfo = null;
 
         @Override
         public void onRequestFinished(UrlRequestInfo requestInfo) {
             assertNull("onRequestFinished called repeatedly", mRequestInfo);
             assertNotNull(requestInfo);
             mRequestInfo = requestInfo;
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
-    public void testRequestFinishedListener() throws Exception {
+    public void testRequestFinishedListener_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
         mTestFramework.mCronetEngine.enableNetworkQualityEstimator(testExecutor);
         mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
                 mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         urlRequestBuilder.addRequestAnnotation("request annotation")
                 .addRequestAnnotation(this)
                 .build()
                 .start();
         callback.blockForDone();
         testExecutor.runAllTasks();
 
         CronetEngine.UrlRequestInfo requestInfo = requestFinishedListener.mRequestInfo;
         assertNotNull("RequestFinishedListener must be called", requestInfo);
         assertEquals(mUrl, requestInfo.getUrl());
         assertNotNull(requestInfo.getResponseInfo());
         assertEquals(newHashSet("request annotation", this), // Use sets for unordered comparison.
                 new HashSet<Object>(requestInfo.getAnnotations()));
         CronetEngine.UrlRequestMetrics metrics = requestInfo.getMetrics();
         assertNotNull("UrlRequestInfo.getMetrics() must not be null", metrics);
         assertTrue(metrics.getTotalTimeMs() > 0);
         assertTrue(metrics.getTotalTimeMs() >= metrics.getTtfbMs());
         assertTrue(metrics.getReceivedBytesCount() > 0);
         mTestFramework.mCronetEngine.shutdown();
     }
 
+    @SmallTest
+    @Feature({"Cronet"})
+    @SuppressWarnings("deprecation")
+    public void testRequestFinishedListenerWithExecutorSetLater_LegacyAPI() throws Exception {
+        CronetEngine.Builder mCronetEngineBuilder = new CronetEngine.Builder(getContext());
+        TestExecutor testExecutor = new TestExecutor();
+        mCronetEngineBuilder.enableHTTP2(true).enableQUIC(false).enableNetworkQualityEstimator(
+                true);
+        mTestFramework =
+                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mCronetEngineBuilder);
+        TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
+        mTestFramework.mCronetEngine.setRequestFinishedListenerExecutor(testExecutor);
+        mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
+                mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        urlRequestBuilder.addRequestAnnotation("request annotation")
+                .addRequestAnnotation(this)
+                .build()
+                .start();
+        callback.blockForDone();
+        testExecutor.runAllTasks();
+
+        CronetEngine.UrlRequestInfo requestInfo = requestFinishedListener.mRequestInfo;
+        assertNotNull("RequestFinishedListener must be called", requestInfo);
+        assertEquals(mUrl, requestInfo.getUrl());
+        assertNotNull(requestInfo.getResponseInfo());
+        assertEquals(newHashSet("request annotation", this), // Use sets for unordered comparison.
+                new HashSet<Object>(requestInfo.getAnnotations()));
+        CronetEngine.UrlRequestMetrics metrics = requestInfo.getMetrics();
+        assertNotNull("UrlRequestInfo.getMetrics() must not be null", metrics);
+        assertTrue(metrics.getTotalTimeMs() > 0);
+        assertTrue(metrics.getTotalTimeMs() >= metrics.getTtfbMs());
+        assertTrue(metrics.getReceivedBytesCount() > 0);
+        mTestFramework.mCronetEngine.shutdown();
+    }
+
     /*
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
     */
     @FlakyTest(message = "https://crbug.com/592444")
-    public void testRequestFinishedListenerFailedRequest() throws Exception {
+    public void testRequestFinishedListenerFailedRequest_LegacyAPI() throws Exception {
         String connectionRefusedUrl = "http://127.0.0.1:3";
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
         mTestFramework.mCronetEngine.enableNetworkQualityEstimator(testExecutor);
         mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(connectionRefusedUrl,
                 callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertTrue(callback.mOnErrorCalled);
         testExecutor.runAllTasks();
 
         CronetEngine.UrlRequestInfo requestInfo = requestFinishedListener.mRequestInfo;
         assertNotNull("RequestFinishedListener must be called", requestInfo);
         assertEquals(connectionRefusedUrl, requestInfo.getUrl());
         assertTrue(requestInfo.getAnnotations().isEmpty());
         CronetEngine.UrlRequestMetrics metrics = requestInfo.getMetrics();
         assertNotNull("UrlRequestInfo.getMetrics() must not be null", metrics);
         assertTrue(metrics.getTotalTimeMs() > 0);
         assertNull(metrics.getTtfbMs());
         assertTrue(metrics.getReceivedBytesCount() == null || metrics.getReceivedBytesCount() == 0);
         mTestFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
-    public void testRequestFinishedListenerRemoved() throws Exception {
+    public void testRequestFinishedListenerRemoved_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
         mTestFramework.mCronetEngine.enableNetworkQualityEstimator(testExecutor);
         mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         mTestFramework.mCronetEngine.removeRequestFinishedListener(requestFinishedListener);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder = new UrlRequest.Builder(
                 mUrl, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         urlRequestBuilder.build().start();
         callback.blockForDone();
         testExecutor.runAllTasks();
 
         assertNull(
                 "RequestFinishedListener must not be called", requestFinishedListener.mRequestInfo);
         mTestFramework.mCronetEngine.shutdown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @SuppressWarnings("deprecation")
-    public void testRequestFinishedListenerDisabled() throws Exception {
+    public void testRequestFinishedListenerDisabled_LegacyAPI() throws Exception {
         mTestFramework = startCronetTestFramework();
         TestExecutor testExecutor = new TestExecutor();
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
         try {
             mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
             fail("addRequestFinishedListener unexpectedly succeeded "
                     + "without a call to enableNetworkQualityEstimator()");
         } catch (RuntimeException e) {
             // Expected.
         }
@@ skipping 736 matching lines @@
                     }
                 }.start();
                 otherThreadDone.block();
                 builder.build().shutdown();
                 uiThreadDone.open();
             }
         });
         assertTrue(uiThreadDone.block(1000));
     }
 }