[Cronet] Clean up tests

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 android.content.Context;
 import android.content.ContextWrapper;
 import android.os.ConditionVariable;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Process;
 import android.support.test.filters.SmallTest;
 
 import org.json.JSONObject;
 
 import static org.chromium.net.CronetEngine.Builder.HTTP_CACHE_IN_MEMORY;
 
 import org.chromium.base.FileUtils;
 import org.chromium.base.PathUtils;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
-import org.chromium.net.impl.CronetEngineBase;
 import org.chromium.net.impl.CronetEngineBuilderImpl;
 import org.chromium.net.impl.CronetLibraryLoader;
 import org.chromium.net.impl.CronetUrlRequestContext;
 import org.chromium.net.test.EmbeddedTestServer;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.net.URL;
 import java.nio.ByteBuffer;
@@ skipping 31 matching lines @@
         mUrl404 = mTestServer.getURL("/echo?status=404");
         mUrl500 = mTestServer.getURL("/echo?status=500");
     }
 
     @Override
     protected void tearDown() throws Exception {
         mTestServer.stopAndDestroyServer();
         super.tearDown();
     }
 
-    static class RequestThread extends Thread {
+    class RequestThread extends Thread {
         public TestUrlRequestCallback mCallback;
 
-        final CronetTestFramework mTestFramework;
         final String mUrl;
         final ConditionVariable mRunBlocker;
 
-        public RequestThread(
-                CronetTestFramework testFramework, String url, ConditionVariable runBlocker) {
-            mTestFramework = testFramework;
+        public RequestThread(String url, ConditionVariable runBlocker) {
             mUrl = url;
             mRunBlocker = runBlocker;
         }
 
         @Override
         public void run() {
             mRunBlocker.block();
-            CronetEngine cronetEngine = mTestFramework.initCronetEngine();
+            CronetEngine cronetEngine = new CronetEngine.Builder(getContext()).build();
             mCallback = new TestUrlRequestCallback();
             UrlRequest.Builder urlRequestBuilder =
                     cronetEngine.newUrlRequestBuilder(mUrl, mCallback, mCallback.getExecutor());
             urlRequestBuilder.build().start();
             mCallback.blockForDone();
         }
     }
 
     /**
      * Callback that shutdowns the request context when request has succeeded
@@ skipping 32 matching lines @@
     @SuppressWarnings("deprecation")
     public void testConfigUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
         ExperimentalCronetEngine.Builder cronetEngineBuilder =
                 new ExperimentalCronetEngine.Builder(getContext());
         if (testingJavaImpl()) {
             cronetEngineBuilder = createJavaEngineBuilder();
         }
         cronetEngineBuilder.setUserAgent(userAgentValue);
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(mUrl, cronetEngineBuilder);
+        final CronetEngine cronetEngine = cronetEngineBuilder.build();
         NativeTestServer.shutdownNativeTestServer(); // startNativeTestServer returns false if it's
         // already running
         assertTrue(NativeTestServer.startNativeTestServer(getContext()));
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+        UrlRequest.Builder urlRequestBuilder = cronetEngine.newUrlRequestBuilder(
                 NativeTestServer.getEchoHeaderURL(userAgentName), callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     // TODO: Remove the annotation after fixing http://crbug.com/637979 & http://crbug.com/637972
     @OnlyRunNativeCronet
@@ skipping 43 matching lines @@
         callback.startNextRead(urlRequest);
         callback.blockForDone();
         callback.blockForCallbackToComplete();
         callback.shutdownExecutor();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testShutdownDuringInit() throws Exception {
-        final CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
         final ConditionVariable block = new ConditionVariable(false);
 
         // Post a task to main thread to block until shutdown is called to test
         // scenario when shutdown is called right after construction before
         // context is fully initialized on the main thread.
         Runnable blockingTask = new Runnable() {
             @Override
             public void run() {
                 try {
                     block.block();
                 } catch (Exception e) {
                     fail("Caught " + e.getMessage());
                 }
             }
         };
         // Ensure that test is not running on the main thread.
         assertTrue(Looper.getMainLooper() != Looper.myLooper());
         new Handler(Looper.getMainLooper()).post(blockingTask);
 
         // Create new request context, but its initialization on the main thread
         // will be stuck behind blockingTask.
         final CronetUrlRequestContext cronetEngine =
-                (CronetUrlRequestContext) testFramework.initCronetEngine();
+                (CronetUrlRequestContext) new CronetEngine.Builder(getContext()).build();
         // Unblock the main thread, so context gets initialized and shutdown on
         // it.
         block.open();
         // Shutdown will wait for init to complete on main thread.
         cronetEngine.shutdown();
         // Verify that context is shutdown.
         try {
             cronetEngine.getUrlRequestContextAdapter();
             fail("Should throw an exception.");
         } catch (Exception e) {
             assertEquals("Engine is shut down.", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testInitAndShutdownOnMainThread() throws Exception {
-        final CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
         final ConditionVariable block = new ConditionVariable(false);
 
         // Post a task to main thread to init and shutdown on the main thread.
         Runnable blockingTask = new Runnable() {
             @Override
             public void run() {
                 // Create new request context, loading the library.
                 final CronetUrlRequestContext cronetEngine =
-                        (CronetUrlRequestContext) testFramework.initCronetEngine();
+                        (CronetUrlRequestContext) new CronetEngine.Builder(getContext()).build();
                 // Shutdown right after init.
                 cronetEngine.shutdown();
                 // Verify that context is shutdown.
                 try {
                     cronetEngine.getUrlRequestContextAdapter();
                     fail("Should throw an exception.");
                 } catch (Exception e) {
                     assertEquals("Engine is shut down.", e.getMessage());
                 }
                 block.open();
@@ skipping 269 matching lines @@
         assertFalse(netLogDir1.exists());
         FileUtils.recursivelyDeleteFile(netLogDir2);
         assertFalse(netLogDir2.exists());
     }
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     // Tests that if CronetEngine is shut down on the network thread, an appropriate exception
     // is thrown.
     public void testShutDownEngineOnNetworkThread() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
+        final CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
         // Make a request to a cacheable resource.
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
 
         final AtomicReference<Throwable> thrown = new AtomicReference<>();
         // Shut down the server.
         NativeTestServer.shutdownNativeTestServer();
         class CancelUrlRequestCallback extends TestUrlRequestCallback {
             @Override
             public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
                 super.onResponseStarted(request, info);
                 request.cancel();
                 // Shut down CronetEngine immediately after request is destroyed.
                 try {
-                    testFramework.mCronetEngine.shutdown();
+                    cronetEngine.shutdown();
                 } catch (Exception e) {
                     thrown.set(e);
                 }
             }
 
             @Override
             public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
                 // onSucceeded will not happen, because the request is canceled
                 // after sending first read and the executor is single threaded.
                 throw new RuntimeException("Unexpected");
             }
 
             @Override
             public void onFailed(UrlRequest request, UrlResponseInfo info, CronetException error) {
                 throw new RuntimeException("Unexpected");
             }
         }
         Executor directExecutor = new Executor() {
             @Override
             public void execute(Runnable command) {
                 command.run();
             }
         };
         CancelUrlRequestCallback callback = new CancelUrlRequestCallback();
         callback.setAllowDirectExecutor(true);
         UrlRequest.Builder urlRequestBuilder =
-                testFramework.mCronetEngine.newUrlRequestBuilder(url, callback, directExecutor);
+                cronetEngine.newUrlRequestBuilder(url, callback, directExecutor);
         urlRequestBuilder.allowDirectExecutor();
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertTrue(thrown.get() instanceof RuntimeException);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     // Tests that if CronetEngine is shut down when reading from disk cache,
     // there isn't a crash. See crbug.com/486120.
     public void testShutDownEngineWhenReadingFromDiskCache() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
+        final CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
         // Make a request to a cacheable resource.
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
 
         // Shut down the server.
         NativeTestServer.shutdownNativeTestServer();
         class CancelUrlRequestCallback extends TestUrlRequestCallback {
             @Override
             public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
                 super.onResponseStarted(request, info);
                 request.cancel();
                 // Shut down CronetEngine immediately after request is destroyed.
-                testFramework.mCronetEngine.shutdown();
+                cronetEngine.shutdown();
             }
 
             @Override
             public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
                 // onSucceeded will not happen, because the request is canceled
                 // after sending first read and the executor is single threaded.
                 throw new RuntimeException("Unexpected");
             }
 
             @Override
             public void onFailed(UrlRequest request, UrlResponseInfo info, CronetException error) {
                 throw new RuntimeException("Unexpected");
             }
         }
         CancelUrlRequestCallback callback = new CancelUrlRequestCallback();
-        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
-                url, callback, callback.getExecutor());
+        UrlRequest.Builder urlRequestBuilder =
+                cronetEngine.newUrlRequestBuilder(url, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertTrue(callback.mResponseInfo.wasCached());
         assertTrue(callback.mOnCanceledCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
@@ skipping 237 matching lines @@
     private void makeRequestAndCheckStatus(
             CronetEngine engine, String url, int expectedStatusCode) {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest request =
                 engine.newUrlRequestBuilder(url, callback, callback.getExecutor()).build();
         request.start();
         callback.blockForDone();
         assertEquals(expectedStatusCode, callback.mResponseInfo.getHttpStatusCode());
     }
 
-    private CronetTestFramework startCronetTestFrameworkWithCacheEnabled(int cacheType)
-            throws Exception {
-        String cacheTypeString = "";
+    private CronetEngine createCronetEngine(int cacheType) {

[mgersh, 2017/05/23 18:12:13]

Since this is now used in a test earlier in the file too, it would make more
sense near the beginning of the file, and might want a more descriptive name
like createCronetEngineWithCache or something so it's clear why it's used only
in a few tests.

[pauljensen, 2017/05/25 15:15:15]

Done.

+        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
         if (cacheType == CronetEngine.Builder.HTTP_CACHE_DISK) {
-            cacheTypeString = CronetTestFramework.CACHE_DISK;
-        } else if (cacheType == CronetEngine.Builder.HTTP_CACHE_DISK_NO_HTTP) {
-            cacheTypeString = CronetTestFramework.CACHE_DISK_NO_HTTP;
-        } else if (cacheType == HTTP_CACHE_IN_MEMORY) {
-            cacheTypeString = CronetTestFramework.CACHE_IN_MEMORY;
+            enableDiskCache(builder);

[mgersh, 2017/05/23 18:12:13]

This way of separating things is a little strange. Instead of having an
enableDiskCache() that sets the storage path and then does the same thing as the
else case, I'd prefer doing just the setStoragePath() in the if.

[pauljensen, 2017/05/25 15:15:15]

Done.

+        } else {
+            builder.enableHttpCache(cacheType, 100 * 1024);
         }
-        String[] commandLineArgs = {CronetTestFramework.CACHE_KEY, cacheTypeString};
-        CronetTestFramework testFramework =
-                startCronetTestFrameworkWithUrlAndCommandLineArgs(null, commandLineArgs);
         assertTrue(NativeTestServer.startNativeTestServer(getContext()));
-        return testFramework;
+        return builder.build();
     }
 
     private void checkRequestCaching(CronetEngine engine, String url, boolean expectCached) {
         checkRequestCaching(engine, url, expectCached, false);
     }
 
     private void checkRequestCaching(
             CronetEngine engine, String url, boolean expectCached, boolean disableCache) {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
                 engine.newUrlRequestBuilder(url, callback, callback.getExecutor());
         if (disableCache) {
             urlRequestBuilder.disableCache();
         }
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(expectCached, callback.mResponseInfo.wasCached());
         assertEquals("this is a cacheable file\n", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEnableHttpCacheDisabled() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISABLED);
+        CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_DISABLED);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheInMemory() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(HTTP_CACHE_IN_MEMORY);
+        CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_IN_MEMORY);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheDisk() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
+        CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEnableHttpCacheDiskNoHttp() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISABLED);
+        // TODO(pauljensen): This should be testing HTTP_CACHE_DISK_NO_HTTP.
+        CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_DISABLED);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testDisableCache() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
+        CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
 
         // When cache is disabled, making a request does not write to the cache.
-        checkRequestCaching(testFramework.mCronetEngine, url, false, true /** disable cache */);
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, false, true /** disable cache */);
+        checkRequestCaching(cronetEngine, url, false);
 
         // When cache is enabled, the second request is cached.
-        checkRequestCaching(testFramework.mCronetEngine, url, false, true /** disable cache */);
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, false, true /** disable cache */);
+        checkRequestCaching(cronetEngine, url, true);
 
         // Shut down the server, next request should have a cached response.
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, true);
 
         // Cache is disabled after server is shut down, request should fail.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
-                url, callback, callback.getExecutor());
+        UrlRequest.Builder urlRequestBuilder =
+                cronetEngine.newUrlRequestBuilder(url, callback, callback.getExecutor());
         urlRequestBuilder.disableCache();
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertNotNull(callback.mError);
         assertContains("Exception in CronetUrlRequest: net::ERR_CONNECTION_REFUSED",
                 callback.mError.getMessage());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEnableHttpCacheDiskNewEngine() throws Exception {
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithCacheEnabled(CronetEngine.Builder.HTTP_CACHE_DISK);
+        CronetEngine cronetEngine = createCronetEngine(CronetEngine.Builder.HTTP_CACHE_DISK);
         String url = NativeTestServer.getFileURL("/cacheable.txt");
-        checkRequestCaching(testFramework.mCronetEngine, url, false);
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, false);
+        checkRequestCaching(cronetEngine, url, true);
         NativeTestServer.shutdownNativeTestServer();
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        checkRequestCaching(cronetEngine, url, true);
 
         // Shutdown original context and create another that uses the same cache.
-        testFramework.mCronetEngine.shutdown();
-        testFramework.mCronetEngine =
-                (CronetEngineBase) testFramework.getCronetEngineBuilder().build();
-        checkRequestCaching(testFramework.mCronetEngine, url, true);
+        cronetEngine.shutdown();
+        cronetEngine = enableDiskCache(new CronetEngine.Builder(getContext())).build();
+        checkRequestCaching(cronetEngine, url, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testInitEngineAndStartRequest() {
-        CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
-
         // Immediately make a request after initializing the engine.
-        CronetEngine cronetEngine = testFramework.initCronetEngine();
+        CronetEngine cronetEngine = new CronetEngine.Builder(getContext()).build();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
                 cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testEmptyGetCertVerifierData() {
-        CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
-
         // Immediately make a request after initializing the engine.
-        ExperimentalCronetEngine cronetEngine = testFramework.initCronetEngine();
+        ExperimentalCronetEngine cronetEngine =
+                new ExperimentalCronetEngine.Builder(getContext()).build();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder urlRequestBuilder =
                 cronetEngine.newUrlRequestBuilder(mUrl, callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
 
         try {
             cronetEngine.getCertVerifierData(-1);
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("timeout must be a positive value", e.getMessage());
         }
         // Because mUrl is http, getCertVerifierData() will return empty data.
         String data = cronetEngine.getCertVerifierData(100);
         assertTrue(data.isEmpty());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testInitEngineStartTwoRequests() throws Exception {
-        CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
-
         // Make two requests after initializing the context.
-        CronetEngine cronetEngine = testFramework.initCronetEngine();
+        CronetEngine cronetEngine = new CronetEngine.Builder(getContext()).build();
         int[] statusCodes = {0, 0};
         String[] urls = {mUrl, mUrl404};
         for (int i = 0; i < 2; i++) {
             TestUrlRequestCallback callback = new TestUrlRequestCallback();
             UrlRequest.Builder urlRequestBuilder =
                     cronetEngine.newUrlRequestBuilder(urls[i], callback, callback.getExecutor());
             urlRequestBuilder.build().start();
             callback.blockForDone();
             statusCodes[i] = callback.mResponseInfo.getHttpStatusCode();
         }
         assertEquals(200, statusCodes[0]);
         assertEquals(404, statusCodes[1]);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testInitTwoEnginesSimultaneously() throws Exception {
-        final CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
-
         // Threads will block on runBlocker to ensure simultaneous execution.
         ConditionVariable runBlocker = new ConditionVariable(false);
-        RequestThread thread1 = new RequestThread(testFramework, mUrl, runBlocker);
-        RequestThread thread2 = new RequestThread(testFramework, mUrl404, runBlocker);
+        RequestThread thread1 = new RequestThread(mUrl, runBlocker);
+        RequestThread thread2 = new RequestThread(mUrl404, runBlocker);
 
         thread1.start();
         thread2.start();
         runBlocker.open();
         thread1.join();
         thread2.join();
         assertEquals(200, thread1.mCallback.mResponseInfo.getHttpStatusCode());
         assertEquals(404, thread2.mCallback.mResponseInfo.getHttpStatusCode());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testInitTwoEnginesInSequence() throws Exception {
-        final CronetTestFramework testFramework = startCronetTestFrameworkAndSkipLibraryInit();
-
         ConditionVariable runBlocker = new ConditionVariable(true);
-        RequestThread thread1 = new RequestThread(testFramework, mUrl, runBlocker);
-        RequestThread thread2 = new RequestThread(testFramework, mUrl404, runBlocker);
+        RequestThread thread1 = new RequestThread(mUrl, runBlocker);
+        RequestThread thread2 = new RequestThread(mUrl404, runBlocker);
 
         thread1.start();
         thread1.join();
         thread2.start();
         thread2.join();
         assertEquals(200, thread1.mCallback.mResponseInfo.getHttpStatusCode());
         assertEquals(404, thread2.mCallback.mResponseInfo.getHttpStatusCode());
     }
 
     @SmallTest
@@ skipping 128 matching lines @@
         String resolverTestHostname = "some-weird-hostname";
         URL testUrl = new URL(mUrl);
         ExperimentalCronetEngine.Builder cronetEngineBuilder =
                 new ExperimentalCronetEngine.Builder(getContext());
         JSONObject hostResolverRules = new JSONObject().put(
                 "host_resolver_rules", "MAP " + resolverTestHostname + " " + testUrl.getHost());
         JSONObject experimentalOptions =
                 new JSONObject().put("HostResolverRules", hostResolverRules);
         cronetEngineBuilder.setExperimentalOptions(experimentalOptions.toString());
 
-        final CronetTestFramework testFramework =
-                startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, cronetEngineBuilder);
+        final CronetEngine cronetEngine = cronetEngineBuilder.build();
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         URL requestUrl =
                 new URL("http", resolverTestHostname, testUrl.getPort(), testUrl.getFile());
-        UrlRequest.Builder urlRequestBuilder = testFramework.mCronetEngine.newUrlRequestBuilder(
+        UrlRequest.Builder urlRequestBuilder = cronetEngine.newUrlRequestBuilder(
                 requestUrl.toString(), callback, callback.getExecutor());
         urlRequestBuilder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
     }
 
     /**
      * Runs {@code r} on {@code engine}'s network thread.
      */
     private static void postToNetworkThread(final CronetEngine engine, final Runnable r) {
@@ skipping 59 matching lines @@
         }
         // Test that valid thread priority range (-20..19) is working.
         for (int threadPriority = -20; threadPriority < 20; threadPriority++) {
             builder.setThreadPriority(threadPriority);
             CronetEngine engine = builder.build();
             assertEquals(threadPriority, getThreadPriority(engine));
             engine.shutdown();
         }
     }
 }