[Cronet] Clean up tests

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

 // Copyright 2015 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.os.ConditionVariable;
 import android.support.test.filters.SmallTest;
@@ skipping 14 matching lines @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * Test functionality of BidirectionalStream interface.
  */
 public class BidirectionalStreamTest extends CronetTestBase {
-    private CronetTestFramework mTestFramework;
-
+    private ExperimentalCronetEngine mCronetEngine;
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         // Load library first to create MockCertVerifier.
         System.loadLibrary("cronet_tests");
         ExperimentalCronetEngine.Builder builder =
                 new ExperimentalCronetEngine.Builder(getContext());
         CronetTestUtil.setMockCertVerifierForTesting(
                 builder, QuicTestServer.createMockCertVerifier());
 
-        mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, builder);
+        mCronetEngine = builder.build();
         assertTrue(Http2TestServer.startHttp2TestServer(
                 getContext(), SERVER_CERT_PEM, SERVER_KEY_PKCS8_PEM));
     }
 
     @Override
     protected void tearDown() throws Exception {
         assertTrue(Http2TestServer.shutdownHttp2TestServer());
-        if (mTestFramework.mCronetEngine != null) {
-            mTestFramework.mCronetEngine.shutdown();
+        if (mCronetEngine != null) {
+            mCronetEngine.shutdown();
         }
         super.tearDown();
     }
 
     private static void checkResponseInfo(UrlResponseInfo responseInfo, String expectedUrl,
             int expectedHttpStatusCode, String expectedHttpStatusText) {
         assertEquals(expectedUrl, responseInfo.getUrl());
         assertEquals(
                 expectedUrl, responseInfo.getUrlChain().get(responseInfo.getUrlChain().size() - 1));
         assertEquals(expectedHttpStatusCode, responseInfo.getHttpStatusCode());
@@ skipping 22 matching lines @@
                 Arrays.asList(urls), statusCode, message, headersList, false, "h2", null);
         urlResponseInfo.setReceivedByteCount(receivedBytes);
         return urlResponseInfo;
     }
 
     private void runSimpleGetWithExpectedReceivedByteCount(int expectedReceivedBytes)
             throws Exception {
         String url = Http2TestServer.getEchoMethodUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
-        mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
+        mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .setHttpMethod("GET")
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         requestFinishedListener.blockUntilDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         // Default method is 'GET'.
         assertEquals("GET", callback.mResponseAsString);
         UrlResponseInfo urlResponseInfo = createUrlResponseInfo(
@@ skipping 10 matching lines @@
         if (testingJavaImpl()) {
             runBuilderCheckJavaImpl();
         } else {
             runBuilderCheckNativeImpl();
         }
     }
 
     private void runBuilderCheckNativeImpl() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         try {
-            mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                    null, callback, callback.getExecutor());
+            mCronetEngine.newBidirectionalStreamBuilder(null, callback, callback.getExecutor());
             fail("URL not null-checked");
         } catch (NullPointerException e) {
             assertEquals("URL is required.", e.getMessage());
         }
         try {
-            mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+            mCronetEngine.newBidirectionalStreamBuilder(
                     Http2TestServer.getServerUrl(), null, callback.getExecutor());
             fail("Callback not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Callback is required.", e.getMessage());
         }
         try {
-            mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+            mCronetEngine.newBidirectionalStreamBuilder(
                     Http2TestServer.getServerUrl(), callback, null);
             fail("Executor not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Executor is required.", e.getMessage());
         }
         // Verify successful creation doesn't throw.
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         try {
             builder.addHeader(null, "value");
             fail("Header name is not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Invalid header name.", e.getMessage());
         }
         try {
             builder.addHeader("name", null);
             fail("Header value is not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Invalid header value.", e.getMessage());
         }
         try {
             builder.setHttpMethod(null);
             fail("Method name is not null-checked");
         } catch (NullPointerException e) {
             assertEquals("Method is required.", e.getMessage());
         }
     }
 
     private void runBuilderCheckJavaImpl() {
         try {
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-            mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
+            createJavaEngineBuilder().build().newBidirectionalStreamBuilder(

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

It looks like the point of this method is that it's called after the
CronetEngine is already created, so using mCronetEngine here should work, and if
it doesn't that's a bug.

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

Previously startCronetTestFrameworkWithUrlAndCronetEngineBuilder() was setting
mCronetTestFramework to mTestFramework, and CronetTestBase.runTest() was
swapping mTestFramework.mCronetEngine for a JavaCronetEngine.  I removed the
call to startCronetTestFrameworkWithUrlAndCronetEngineBuilder() so this swap is
no longer happening, so mCronetEngine will be a CronetUrlRequestContext not a
JavaCronetEngine instance.  To keep this test testing what it was designed to
test I manually create a JavaCronetEngine here.

[mgersh, 2017/05/25 18:11:16]

Acknowledged.

                     Http2TestServer.getServerUrl(), callback, callback.getExecutor());
             fail("JavaCronetEngine doesn't support BidirectionalStream."
                     + " Expected UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {
             // Expected.
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testFailPlainHttp() throws Exception {
         String url = "http://example.com";
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertContains("Exception in BidirectionalStream: net::ERR_DISALLOWED_URL_SCHEME",
                 callback.mError.getMessage());
         assertEquals(-301, ((NetworkException) callback.mError).getCronetInternalErrorCode());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimpleGet() throws Exception {
         // Since this is the first request on the connection, the expected received bytes count
         // must account for an HPACK dynamic table size update.
         runSimpleGetWithExpectedReceivedByteCount(31);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimpleHead() throws Exception {
         String url = Http2TestServer.getEchoMethodUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .setHttpMethod("HEAD")
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("HEAD", callback.mResponseAsString);
         UrlResponseInfo urlResponseInfo =
                 createUrlResponseInfo(new String[] {url}, "", 200, 32, ":status", "200");
         assertResponseEquals(urlResponseInfo, callback.mResponseInfo);
         checkResponseInfo(callback.mResponseInfo, Http2TestServer.getEchoMethodUrl(), 200, "");
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePost() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData("Test String".getBytes());
         callback.addWriteData("1234567890".getBytes());
         callback.addWriteData("woot!".getBytes());
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
-        mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
+        mCronetEngine.addRequestFinishedListener(requestFinishedListener);
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .addHeader("foo", "bar")
                         .addHeader("empty", "")
                         .addHeader("Content-Type", "zebra")
                         .addRequestAnnotation(this)
                         .addRequestAnnotation("request annotation")
                         .build();
         Date startTime = new Date();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
@@ skipping 16 matching lines @@
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePostWithFlush() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData("Test String".getBytes(), false);
         callback.addWriteData("1234567890".getBytes(), false);
         callback.addWriteData("woot!".getBytes(), true);
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .addHeader("foo", "bar")
                         .addHeader("empty", "")
                         .addHeader("Content-Type", "zebra")
                         .build();
         // Flush before stream is started should not crash.
         stream.flush();
 
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
@@ skipping 56 matching lines @@
                 }
             }
         };
         callback.addWriteData("1".getBytes(), false);
         callback.addWriteData("2".getBytes(), false);
         callback.addWriteData("3".getBytes(), true);
         callback.addWriteData("4".getBytes(), false);
         callback.addWriteData("5".getBytes(), true);
         callback.addWriteData("6".getBytes(), false);
         CronetBidirectionalStream stream =
-                (CronetBidirectionalStream) mTestFramework.mCronetEngine
+                (CronetBidirectionalStream) mCronetEngine
                         .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .addHeader("foo", "bar")
                         .addHeader("empty", "")
                         .addHeader("Content-Type", "zebra")
                         .build();
         callback.setAutoAdvance(false);
         stream.start();
         callback.waitForNextWriteStep(); // onStreamReady
 
         assertEquals(0, stream.getPendingDataForTesting().size());
@@ skipping 53 matching lines @@
                 for (int i = 0; i < data.length; i++) {
                     data[i] = 'x';
                 }
                 ByteBuffer dummyData = ByteBuffer.allocateDirect(data.length);
                 dummyData.put(data);
                 dummyData.flip();
                 return dummyData;
             }
         };
         CronetBidirectionalStream stream =
-                (CronetBidirectionalStream) mTestFramework.mCronetEngine
+                (CronetBidirectionalStream) mCronetEngine
                         .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(callback.mOnCanceledCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
@@ skipping 16 matching lines @@
                     super.onStreamReady(stream);
                     try {
                         // Attempt to write data for GET request.
                         stream.write(ByteBuffer.wrap("dummy".getBytes()), true);
                     } catch (IllegalArgumentException e) {
                         // Expected.
                     }
                 }
             };
             BidirectionalStream stream =
-                    mTestFramework.mCronetEngine
+                    mCronetEngine
                             .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                             .setHttpMethod("GET")
                             .delayRequestHeadersUntilFirstFlush(i == 0)
                             .addHeader("foo", "bar")
                             .addHeader("empty", "")
                             .build();
             // Flush before stream is started should not crash.
             stream.flush();
 
             stream.start();
@@ skipping 14 matching lines @@
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePostWithFlushAfterOneWrite() throws Exception {
         // TODO(xunjieli): Use ParameterizedTest instead of the loop.
         for (int i = 0; i < 2; i++) {
             String url = Http2TestServer.getEchoStreamUrl();
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
             callback.addWriteData("Test String".getBytes(), true);
             BidirectionalStream stream =
-                    mTestFramework.mCronetEngine
+                    mCronetEngine
                             .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                             .delayRequestHeadersUntilFirstFlush(i == 0)
                             .addHeader("foo", "bar")
                             .addHeader("empty", "")
                             .addHeader("Content-Type", "zebra")
                             .build();
             stream.start();
             callback.blockForDone();
             assertTrue(stream.isDone());
 
@@ skipping 14 matching lines @@
         for (int i = 0; i < 2; i++) {
             String url = Http2TestServer.getEchoStreamUrl();
             TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
             callback.addWriteData("Test String".getBytes(), false);
             callback.addWriteData("1234567890".getBytes(), false);
             callback.addWriteData("woot!".getBytes(), true);
             callback.addWriteData("Test String".getBytes(), false);
             callback.addWriteData("1234567890".getBytes(), false);
             callback.addWriteData("woot!".getBytes(), true);
             BidirectionalStream stream =
-                    mTestFramework.mCronetEngine
+                    mCronetEngine
                             .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                             .delayRequestHeadersUntilFirstFlush(i == 0)
                             .addHeader("foo", "bar")
                             .addHeader("empty", "")
                             .addHeader("Content-Type", "zebra")
                             .build();
             stream.start();
             callback.blockForDone();
             assertTrue(stream.isDone());
             assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
@@ skipping 21 matching lines @@
             @Override
             public void onResponseHeadersReceived(
                     BidirectionalStream stream, UrlResponseInfo info) {
                 // Do nothing. Skip readng.
             }
         };
         callback.addWriteData("Test String".getBytes());
         callback.addWriteData("1234567890".getBytes());
         callback.addWriteData("woot!".getBytes());
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .addHeader("foo", "bar")
                         .addHeader("empty", "")
                         .addHeader("Content-Type", "zebra")
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("Test String1234567890woot!", callback.mResponseAsString);
         assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
@@ skipping 18 matching lines @@
                 assertEquals(0, numPendingWrites());
             }
         };
         callback.addWriteData("Test String".getBytes(), false);
         callback.addWriteData("1234567890".getBytes(), false);
         callback.addWriteData("woot!".getBytes(), true);
         callback.addWriteData("Test String".getBytes(), false);
         callback.addWriteData("1234567890".getBytes(), false);
         callback.addWriteData("woot!".getBytes(), true);
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .addHeader("foo", "bar")
                         .addHeader("empty", "")
                         .addHeader("Content-Type", "zebra")
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(
                 "Test String1234567890woot!Test String1234567890woot!", callback.mResponseAsString);
         assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
         assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
         assertEquals(
                 "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimplePut() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData("Put This Data!".getBytes());
         String methodName = "PUT";
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         builder.setHttpMethod(methodName);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("Put This Data!", callback.mResponseAsString);
         assertEquals(methodName, callback.mResponseInfo.getAllHeaders().get("echo-method").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBadMethod() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         try {
             builder.setHttpMethod("bad:method!");
             builder.build().start();
             fail("IllegalArgumentException not thrown.");
         } catch (IllegalArgumentException e) {
             assertEquals("Invalid http method bad:method!", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBadHeaderName() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         try {
             builder.addHeader("goodheader1", "headervalue");
             builder.addHeader("header:name", "headervalue");
             builder.addHeader("goodheader2", "headervalue");
             builder.build().start();
             fail("IllegalArgumentException not thrown.");
         } catch (IllegalArgumentException e) {
             assertEquals("Invalid header header:name=headervalue", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBadHeaderValue() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getServerUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getServerUrl(), callback, callback.getExecutor());
         try {
             builder.addHeader("headername", "bad header\r\nvalue");
             builder.build().start();
             fail("IllegalArgumentException not thrown.");
         } catch (IllegalArgumentException e) {
             assertEquals("Invalid header headername=bad header\r\nvalue", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testAddHeader() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String headerName = "header-name";
         String headerValue = "header-value";
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoHeaderUrl(headerName), callback,
-                        callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoHeaderUrl(headerName), callback, callback.getExecutor());
         builder.addHeader(headerName, headerValue);
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(headerValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testMultiRequestHeaders() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String headerName = "header-name";
         String headerValue1 = "header-value1";
         String headerValue2 = "header-value2";
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoAllHeadersUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoAllHeadersUrl(), callback, callback.getExecutor());
         builder.addHeader(headerName, headerValue1);
         builder.addHeader(headerName, headerValue2);
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         String headers = callback.mResponseAsString;
         Pattern pattern = Pattern.compile(headerName + ":\\s(.*)\\r\\n");
         Matcher matcher = pattern.matcher(headers);
         List<String> actualValues = new ArrayList<String>();
         while (matcher.find()) {
             actualValues.add(matcher.group(1));
         }
         assertEquals(1, actualValues.size());
         assertEquals("header-value2", actualValues.get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEchoTrailers() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String headerName = "header-name";
         String headerValue = "header-value";
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoTrailersUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoTrailersUrl(), callback, callback.getExecutor());
         builder.addHeader(headerName, headerValue);
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertNotNull(callback.mTrailers);
         // Verify that header value is properly echoed in trailers.
         assertEquals(headerValue, callback.mTrailers.getAsMap().get("echo-" + headerName).get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCustomUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         String userAgentValue = "User-Agent-Value";
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoHeaderUrl(userAgentName), callback,
-                        callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoHeaderUrl(userAgentName), callback, callback.getExecutor());
         builder.setHttpMethod("GET");
         builder.addHeader(userAgentName, userAgentValue);
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
@@ skipping 16 matching lines @@
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(userAgentValue, callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testDefaultUserAgent() throws Exception {
         String userAgentName = "User-Agent";
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoHeaderUrl(userAgentName), callback,
-                        callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoHeaderUrl(userAgentName), callback, callback.getExecutor());
         builder.setHttpMethod("GET");
         builder.build().start();
         callback.blockForDone();
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(new CronetEngine.Builder(getContext()).getDefaultUserAgent(),
                 callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEchoStream() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         String[] testData = {"Test String", createLongString("1234567890", 50000), "woot!"};
         StringBuilder stringData = new StringBuilder();
         for (String writeData : testData) {
             callback.addWriteData(writeData.getBytes());
             stringData.append(writeData);
         }
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .addHeader("foo", "Value with Spaces")
                         .addHeader("Content-Type", "zebra")
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(stringData.toString(), callback.mResponseAsString);
         assertEquals(
                 "Value with Spaces", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
         assertEquals(
                 "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEchoStreamEmptyWrite() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData(new byte[0]);
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testDoubleWrite() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
             @Override
             public void onStreamReady(BidirectionalStream stream) {
                 // super class will call Write() once.
                 super.onStreamReady(stream);
                 // Call Write() again.
                 startNextWrite(stream);
                 // Make sure there is no pending write.
                 assertEquals(0, numPendingWrites());
             }
         };
         callback.addWriteData("1".getBytes());
         callback.addWriteData("2".getBytes());
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("12", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
@@ skipping 13 matching lines @@
                     fail("Exception is not thrown.");
                 } catch (Exception e) {
                     assertEquals("Unexpected read attempt.", e.getMessage());
                 }
             }
         };
         callback.addWriteData("1".getBytes());
         callback.addWriteData("2".getBytes());
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("12", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     @DisabledTest(message = "Disabled due to timeout. See crbug.com/591112")
     public void testReadAndWrite() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
             @Override
             public void onResponseHeadersReceived(
                     BidirectionalStream stream, UrlResponseInfo info) {
                 // Start the write, that will not complete until callback completion.
                 startNextWrite(stream);
                 // Start the read. It is allowed with write in flight.
                 super.onResponseHeadersReceived(stream, info);
             }
         };
         callback.setAutoAdvance(false);
         callback.addWriteData("1".getBytes());
         callback.addWriteData("2".getBytes());
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         callback.waitForNextWriteStep();
         callback.waitForNextReadStep();
         callback.startNextRead(stream);
         callback.setAutoAdvance(true);
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("12", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testEchoStreamWriteFirst() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         String[] testData = {"a", "bb", "ccc", "Test String", "1234567890", "woot!"};
         StringBuilder stringData = new StringBuilder();
         for (String writeData : testData) {
             callback.addWriteData(writeData.getBytes());
             stringData.append(writeData);
         }
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         // Write first.
         callback.waitForNextWriteStep(); // onStreamReady
         for (String expected : testData) {
             // Write next chunk of test data.
             callback.startNextWrite(stream);
             callback.waitForNextWriteStep(); // onWriteCompleted
         }
 
@@ skipping 23 matching lines @@
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         String[] testData = {"a", "bb", "ccc", "Test String", "1234567890", "woot!"};
         StringBuilder stringData = new StringBuilder();
         for (String writeData : testData) {
             callback.addWriteData(writeData.getBytes());
             stringData.append(writeData);
         }
         // Create stream.
         BidirectionalStream stream =
-                mTestFramework.mCronetEngine
-                        .newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
+                mCronetEngine.newBidirectionalStreamBuilder(url, callback, callback.getExecutor())
                         .build();
         stream.start();
         callback.waitForNextWriteStep();
         callback.waitForNextReadStep();
 
         for (String expected : testData) {
             // Write next chunk of test data.
             callback.startNextWrite(stream);
             callback.waitForNextWriteStep();
 
@@ skipping 16 matching lines @@
     /**
      * Checks that the buffer is updated correctly, when starting at an offset.
      */
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testSimpleGetBufferUpdates() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
         // Since the method is "GET", the expected response body is also "GET".
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.waitForNextReadStep();
 
         assertEquals(null, callback.mError);
         assertFalse(callback.isDone());
         assertEquals(TestBidirectionalStreamCallback.ResponseStep.ON_RESPONSE_STARTED,
                 callback.mResponseStep);
 
         ByteBuffer readBuffer = ByteBuffer.allocateDirect(5);
@@ skipping 70 matching lines @@
         // first response HEADERS frame.
         runSimpleGetWithExpectedReceivedByteCount(27);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testBadBuffers() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.waitForNextReadStep();
 
         assertEquals(null, callback.mError);
         assertFalse(callback.isDone());
         assertEquals(TestBidirectionalStreamCallback.ResponseStep.ON_RESPONSE_STARTED,
                 callback.mResponseStep);
 
         // Try to read using a full buffer.
@@ skipping 24 matching lines @@
         assertEquals("GET", callback.mResponseAsString);
     }
 
     private void throwOrCancel(
             FailureType failureType, ResponseStep failureStep, boolean expectError) {
         // Use a fresh CronetEngine each time so Http2 session is not reused.
         ExperimentalCronetEngine.Builder builder =
                 new ExperimentalCronetEngine.Builder(getContext());
         CronetTestUtil.setMockCertVerifierForTesting(
                 builder, QuicTestServer.createMockCertVerifier());
-        mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, builder);
+        mCronetEngine = builder.build();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setFailure(failureType, failureStep);
         TestRequestFinishedListener requestFinishedListener = new TestRequestFinishedListener();
-        mTestFramework.mCronetEngine.addRequestFinishedListener(requestFinishedListener);
-        BidirectionalStream.Builder streamBuilder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        mCronetEngine.addRequestFinishedListener(requestFinishedListener);
+        BidirectionalStream.Builder streamBuilder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = streamBuilder.setHttpMethod("GET").build();
         Date startTime = new Date();
         stream.start();
         callback.blockForDone();
         assertTrue(stream.isDone());
         requestFinishedListener.blockUntilDone();
         Date endTime = new Date();
         RequestFinishedInfo finishedInfo = requestFinishedListener.getRequestInfo();
         RequestFinishedInfo.Metrics metrics = finishedInfo.getMetrics();
         assertNotNull(metrics);
@@ skipping 28 matching lines @@
             assertNotNull(finishedInfo.getException());
             assertEquals(RequestFinishedInfo.FAILED, finishedInfo.getFinishedReason());
         } else {
             assertNull(finishedInfo.getException());
             assertEquals(RequestFinishedInfo.CANCELED, finishedInfo.getFinishedReason());
         }
         assertEquals(failureType == FailureType.CANCEL_SYNC
                         || failureType == FailureType.CANCEL_ASYNC
                         || failureType == FailureType.CANCEL_ASYNC_WITHOUT_PAUSE,
                 callback.mOnCanceledCalled);
-        mTestFramework.mCronetEngine.removeRequestFinishedListener(requestFinishedListener);
+        mCronetEngine.removeRequestFinishedListener(requestFinishedListener);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testFailures() throws Exception {
         throwOrCancel(FailureType.CANCEL_SYNC, ResponseStep.ON_STREAM_READY, false);
         throwOrCancel(FailureType.CANCEL_ASYNC, ResponseStep.ON_STREAM_READY, false);
         throwOrCancel(FailureType.CANCEL_ASYNC_WITHOUT_PAUSE, ResponseStep.ON_STREAM_READY, false);
         throwOrCancel(FailureType.THROW_SYNC, ResponseStep.ON_STREAM_READY, true);
@@ skipping 10 matching lines @@
                 FailureType.CANCEL_ASYNC_WITHOUT_PAUSE, ResponseStep.ON_READ_COMPLETED, false);
         throwOrCancel(FailureType.THROW_SYNC, ResponseStep.ON_READ_COMPLETED, true);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testThrowOnSucceeded() {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setFailure(FailureType.THROW_SYNC, ResponseStep.ON_SUCCEEDED);
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.blockForDone();
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
         assertTrue(stream.isDone());
         assertNotNull(callback.mResponseInfo);
         // Check that error thrown from 'onSucceeded' callback is not reported.
         assertNull(callback.mError);
         assertFalse(callback.mOnErrorCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testExecutorShutdownBeforeStreamIsDone() {
         // Test that stream is destroyed even if executor is shut down and rejects posting tasks.
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setAutoAdvance(false);
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
         stream.start();
         callback.waitForNextReadStep();
         assertFalse(callback.isDone());
         assertFalse(stream.isDone());
 
         final ConditionVariable streamDestroyed = new ConditionVariable(false);
         stream.setOnDestroyedCallbackForTesting(new Runnable() {
             @Override
@@ skipping 14 matching lines @@
         assertTrue(stream.isDone());
     }
 
     /**
      * Callback that shuts down the engine when the stream has succeeded
      * or failed.
      */
     private class ShutdownTestBidirectionalStreamCallback extends TestBidirectionalStreamCallback {
         @Override
         public void onSucceeded(BidirectionalStream stream, UrlResponseInfo info) {
-            mTestFramework.mCronetEngine.shutdown();
+            mCronetEngine.shutdown();
             // Clear mCronetEngine so it doesn't get shut down second time in tearDown().
-            mTestFramework.mCronetEngine = null;
+            mCronetEngine = null;
             super.onSucceeded(stream, info);
         }
 
         @Override
         public void onFailed(
                 BidirectionalStream stream, UrlResponseInfo info, CronetException error) {
-            mTestFramework.mCronetEngine.shutdown();
+            mCronetEngine.shutdown();
             // Clear mCronetEngine so it doesn't get shut down second time in tearDown().
-            mTestFramework.mCronetEngine = null;
+            mCronetEngine = null;
             super.onFailed(stream, info, error);
         }
 
         @Override
         public void onCanceled(BidirectionalStream stream, UrlResponseInfo info) {
-            mTestFramework.mCronetEngine.shutdown();
+            mCronetEngine.shutdown();
             // Clear mCronetEngine so it doesn't get shut down second time in tearDown().
-            mTestFramework.mCronetEngine = null;
+            mCronetEngine = null;
             super.onCanceled(stream, info);
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCronetEngineShutdown() throws Exception {
         // Test that CronetEngine cannot be shut down if there are any active streams.
         TestBidirectionalStreamCallback callback = new ShutdownTestBidirectionalStreamCallback();
         // Block callback when response starts to verify that shutdown fails
         // if there are active streams.
         callback.setAutoAdvance(false);
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
         stream.start();
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.", e.getMessage());
         }
 
         callback.waitForNextReadStep();
         assertEquals(ResponseStep.ON_RESPONSE_STARTED, callback.mResponseStep);
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.", e.getMessage());
         }
         callback.startNextRead(stream);
 
         callback.waitForNextReadStep();
         assertEquals(ResponseStep.ON_READ_COMPLETED, callback.mResponseStep);
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.", e.getMessage());
         }
 
         // May not have read all the data, in theory. Just enable auto-advance
         // and finish the request.
         callback.setAutoAdvance(true);
         callback.startNextRead(stream);
         callback.blockForDone();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCronetEngineShutdownAfterStreamFailure() throws Exception {
         // Test that CronetEngine can be shut down after stream reports a failure.
         TestBidirectionalStreamCallback callback = new ShutdownTestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
         stream.start();
         callback.setFailure(FailureType.THROW_SYNC, ResponseStep.ON_READ_COMPLETED);
         callback.blockForDone();
         assertTrue(callback.mOnErrorCalled);
-        assertNull(mTestFramework.mCronetEngine);
+        assertNull(mCronetEngine);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testCronetEngineShutdownAfterStreamCancel() throws Exception {
         // Test that CronetEngine can be shut down after stream is canceled.
         TestBidirectionalStreamCallback callback = new ShutdownTestBidirectionalStreamCallback();
-        BidirectionalStream.Builder builder =
-                mTestFramework.mCronetEngine.newBidirectionalStreamBuilder(
-                        Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
+        BidirectionalStream.Builder builder = mCronetEngine.newBidirectionalStreamBuilder(
+                Http2TestServer.getEchoMethodUrl(), callback, callback.getExecutor());
         CronetBidirectionalStream stream =
                 (CronetBidirectionalStream) builder.setHttpMethod("GET").build();
 
         // Block callback when response starts to verify that shutdown fails
         // if there are active requests.
         callback.setAutoAdvance(false);
         stream.start();
         try {
-            mTestFramework.mCronetEngine.shutdown();
+            mCronetEngine.shutdown();
             fail("Should throw an exception");
         } catch (Exception e) {
             assertEquals("Cannot shutdown with active requests.", e.getMessage());
         }
         callback.waitForNextReadStep();
         assertEquals(ResponseStep.ON_RESPONSE_STARTED, callback.mResponseStep);
         stream.cancel();
         callback.blockForDone();
         assertTrue(callback.mOnCanceledCalled);
-        assertNull(mTestFramework.mCronetEngine);
+        assertNull(mCronetEngine);
     }
 
     // Returns the contents of byteBuffer, from its position() to its limit(),
     // as a String. Does not modify byteBuffer's position().
     private static String bufferContentsToString(ByteBuffer byteBuffer, int start, int end) {
         // Use a duplicate to avoid modifying byteBuffer.
         ByteBuffer duplicate = byteBuffer.duplicate();
         duplicate.position(start);
         duplicate.limit(end);
         byte[] contents = new byte[duplicate.remaining()];
         duplicate.get(contents);
         return new String(contents);
     }
 }