Add HttpUrlConnection backed implementation of CronetEngine.

components/cronet/android/test/javatests/src/org/chromium/net/CronetUrlRequestTest.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.os.ConditionVariable;
+import android.test.MoreAsserts;
 import android.test.suitebuilder.annotation.SmallTest;
+import android.util.Log;
 
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.TestUrlRequestCallback.FailureType;
 import org.chromium.net.TestUrlRequestCallback.ResponseStep;
 import org.chromium.net.test.FailurePhase;
 
+import java.net.ConnectException;
 import java.nio.ByteBuffer;
+import java.util.AbstractMap;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * Test functionality of CronetUrlRequest.
  */
@@ skipping 91 matching lines @@
     @SmallTest
     @Feature({"Cronet"})
     public void testSimpleGet() throws Exception {
         String url = NativeTestServer.getEchoMethodURL();
         TestUrlRequestCallback callback = startAndWaitForComplete(url);
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         // Default method is 'GET'.
         assertEquals("GET", callback.mResponseAsString);
         assertEquals(0, callback.mRedirectCount);
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
-        assertEquals(String.format("UrlResponseInfo[%s]: urlChain = [%s], httpStatus = 200 OK, "
-                                     + "headers = [Connection=close, Content-Length=3, "
-                                     + "Content-Type=text/plain], wasCached = false, "
-                                     + "negotiatedProtocol = unknown, proxyServer= :0, "
-                                     + "receivedBytesCount = 86",
-                             url, url),
-                callback.mResponseInfo.toString());
+        UrlResponseInfo urlResponseInfo = createUrlResponseInfo(new String[] {url}, "OK", 200, 86,
+                "Connection", "close", "Content-Length", "3", "Content-Type", "text/plain");
+        assertResponseEquals(urlResponseInfo, callback.mResponseInfo);
         checkResponseInfo(callback.mResponseInfo, NativeTestServer.getEchoMethodURL(), 200, "OK");
     }
 
+    UrlResponseInfo createUrlResponseInfo(
+            String[] urls, String message, int statusCode, int receivedBytes, String... headers) {
+        ArrayList<Map.Entry<String, String>> headersList = new ArrayList<>();
+        for (int i = 0; i < headers.length; i += 2) {
+            headersList.add(new AbstractMap.SimpleImmutableEntry<String, String>(
+                    headers[i], headers[i + 1]));
+        }
+        UrlResponseInfo unknown = new UrlResponseInfo(
+                Arrays.asList(urls), statusCode, message, headersList, false, "unknown", ":0");
+        unknown.setReceivedBytesCount(receivedBytes);
+        return unknown;
+    }
+
+    void assertResponseEquals(UrlResponseInfo expected, UrlResponseInfo actual) {
+        assertEquals(expected.getAllHeaders(), actual.getAllHeaders());
+        assertEquals(expected.getAllHeadersAsList(), actual.getAllHeadersAsList());
+        assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
+        assertEquals(expected.getHttpStatusText(), actual.getHttpStatusText());
+        assertEquals(expected.getUrlChain(), actual.getUrlChain());
+        assertEquals(expected.getUrl(), actual.getUrl());
+        // Transferred bytes and proxy server are not supported in pure java
+        if (!(mTestFramework.mCronetEngine instanceof JavaCronetEngine)) {
+            assertEquals(expected.getReceivedBytesCount(), actual.getReceivedBytesCount());
+            assertEquals(expected.getProxyServer(), actual.getProxyServer());
+            // This is a place where behavior intentionally differs between native and java
+            assertEquals(expected.getNegotiatedProtocol(), actual.getNegotiatedProtocol());
+        }
+    }
+
     /**
      * Tests a redirect by running it step-by-step. Also tests that delaying a
      * request works as expected. To make sure there are no unexpected pending
      * messages, does a GET between UrlRequest.Callback callbacks.
      */
     @SmallTest
     @Feature({"Cronet"})
     public void testRedirectAsync() throws Exception {
         // Start the request and wait to see the redirect.
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getRedirectURL(),
                 callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.waitForNextStep();
 
         // Check the redirect.
         assertEquals(ResponseStep.ON_RECEIVED_REDIRECT, callback.mResponseStep);
         assertEquals(1, callback.mRedirectResponseInfoList.size());
         checkResponseInfo(callback.mRedirectResponseInfoList.get(0),
                 NativeTestServer.getRedirectURL(), 302, "Found");
         assertEquals(1, callback.mRedirectResponseInfoList.get(0).getUrlChain().size());
         assertEquals(NativeTestServer.getSuccessURL(), callback.mRedirectUrlList.get(0));
         checkResponseInfoHeader(
                 callback.mRedirectResponseInfoList.get(0), "redirect-header", "header-value");
 
-        assertEquals(String.format("UrlResponseInfo[%s]: urlChain = [%s], httpStatus = 302 Found, "
-                                     + "headers = [Location=/success.txt, "
-                                     + "redirect-header=header-value], wasCached = false, "
-                                     + "negotiatedProtocol = unknown, proxyServer= :0, "
-                                     + "receivedBytesCount = 74",
-                             NativeTestServer.getRedirectURL(), NativeTestServer.getRedirectURL()),
-                callback.mRedirectResponseInfoList.get(0).toString());
+        UrlResponseInfo expected =
+                createUrlResponseInfo(new String[] {NativeTestServer.getRedirectURL()}, "Found",
+                        302, 74, "Location", "/success.txt", "redirect-header", "header-value");
+        assertResponseEquals(expected, callback.mRedirectResponseInfoList.get(0));
 
         // Wait for an unrelated request to finish. The request should not
         // advance until followRedirect is invoked.
         testSimpleGet();
         assertEquals(ResponseStep.ON_RECEIVED_REDIRECT, callback.mResponseStep);
         assertEquals(1, callback.mRedirectResponseInfoList.size());
 
         // Follow the redirect and wait for the next set of headers.
         urlRequest.followRedirect();
         callback.waitForNextStep();
@@ skipping 24 matching lines @@
             }
             // Should not receive any messages while waiting for another get,
             // as the next read has not been started.
             testSimpleGet();
             assertEquals(response, callback.mResponseAsString);
             assertEquals(step, callback.mResponseStep);
         }
         assertEquals(ResponseStep.ON_SUCCEEDED, callback.mResponseStep);
         assertEquals(NativeTestServer.SUCCESS_BODY, callback.mResponseAsString);
 
-        assertEquals(String.format("UrlResponseInfo[%s]: urlChain = [%s, %s], httpStatus = 200 OK, "
-                                     + "headers = [Content-Type=text/plain, "
-                                     + "Access-Control-Allow-Origin=*, header-name=header-value, "
-                                     + "multi-header-name=header-value1, "
-                                     + "multi-header-name=header-value2], wasCached = false, "
-                                     + "negotiatedProtocol = unknown, proxyServer= :0, "
-                                     + "receivedBytesCount = 260",
-                             NativeTestServer.getSuccessURL(), NativeTestServer.getRedirectURL(),
-                             NativeTestServer.getSuccessURL()),
-                callback.mResponseInfo.toString());
+        UrlResponseInfo urlResponseInfo = createUrlResponseInfo(
+                new String[] {NativeTestServer.getRedirectURL(), NativeTestServer.getSuccessURL()},
+                "OK", 200, 260, "Content-Type", "text/plain", "Access-Control-Allow-Origin", "*",
+                "header-name", "header-value", "multi-header-name", "header-value1",
+                "multi-header-name", "header-value2");
 
+        assertResponseEquals(urlResponseInfo, callback.mResponseInfo);
         // Make sure there are no other pending messages, which would trigger
         // asserts in TestUrlRequestCallback.
         testSimpleGet();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testNotFound() throws Exception {
         String url = NativeTestServer.getFileURL("/notfound.html");
         TestUrlRequestCallback callback = startAndWaitForComplete(url);
         checkResponseInfo(callback.mResponseInfo, url, 404, "Not Found");
         assertEquals("<!DOCTYPE html>\n<html>\n<head>\n<title>Not found</title>\n"
                         + "<p>Test page loaded.</p>\n</head>\n</html>\n",
                 callback.mResponseAsString);
         assertEquals(0, callback.mRedirectCount);
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
     }
 
     // Checks that UrlRequest.Callback.onFailed is only called once in the case
     // of ERR_CONTENT_LENGTH_MISMATCH, which has an unusual failure path.
     // See http://crbug.com/468803.
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet // No canonical exception to assert on
     public void testContentLengthMismatchFailsOnce() throws Exception {
         String url = NativeTestServer.getFileURL(
                 "/content_length_mismatch.html");
         TestUrlRequestCallback callback = startAndWaitForComplete(url);
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         // The entire response body will be read before the error is returned.
         // This is because the network stack returns data as it's read from the
-        // socket, and the socket close message which tiggers the error will
+        // socket, and the socket close message which triggers the error will
         // only be passed along after all data has been read.
         assertEquals("Response that lies about content length.", callback.mResponseAsString);
         assertNotNull(callback.mError);
         assertEquals("Exception in CronetUrlRequest: net::ERR_CONTENT_LENGTH_MISMATCH",
                 callback.mError.getMessage());
         // Wait for a couple round trips to make sure there are no pending
         // onFailed messages. This test relies on checks in
         // TestUrlRequestCallback catching a second onFailed call.
         testSimpleGet();
     }
@@ skipping 159 matching lines @@
         assertEquals("header-value2", multiHeader.get(1));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testResponseHeadersList() throws Exception {
         TestUrlRequestCallback callback = startAndWaitForComplete(NativeTestServer.getSuccessURL());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         List<Map.Entry<String, String>> responseHeaders =
                 callback.mResponseInfo.getAllHeadersAsList();
-        assertEquals(5, responseHeaders.size());
-        assertEquals("Content-Type", responseHeaders.get(0).getKey());
-        assertEquals("text/plain", responseHeaders.get(0).getValue());
-        assertEquals("Access-Control-Allow-Origin", responseHeaders.get(1).getKey());
-        assertEquals("*", responseHeaders.get(1).getValue());
-        assertEquals("header-name", responseHeaders.get(2).getKey());
-        assertEquals("header-value", responseHeaders.get(2).getValue());
-        assertEquals("multi-header-name", responseHeaders.get(3).getKey());
-        assertEquals("header-value1", responseHeaders.get(3).getValue());
-        assertEquals("multi-header-name", responseHeaders.get(4).getKey());
-        assertEquals("header-value2", responseHeaders.get(4).getValue());
+
+        MoreAsserts.assertContentsInOrder(responseHeaders,
+                new AbstractMap.SimpleEntry<>("Content-Type", "text/plain"),
+                new AbstractMap.SimpleEntry<>("Access-Control-Allow-Origin", "*"),
+                new AbstractMap.SimpleEntry<>("header-name", "header-value"),
+                new AbstractMap.SimpleEntry<>("multi-header-name", "header-value1"),
+                new AbstractMap.SimpleEntry<>("multi-header-name", "header-value2"));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testMockMultiRedirect() throws Exception {
         TestUrlRequestCallback callback =
                 startAndWaitForComplete(NativeTestServer.getMultiRedirectURL());
         UrlResponseInfo mResponseInfo = callback.mResponseInfo;
         assertEquals(2, callback.mRedirectCount);
         assertEquals(200, mResponseInfo.getHttpStatusCode());
         assertEquals(2, callback.mRedirectResponseInfoList.size());
 
         // Check first redirect (multiredirect.html -> redirect.html)
+        UrlResponseInfo firstExpectedResponseInfo = createUrlResponseInfo(
+                new String[] {NativeTestServer.getMultiRedirectURL()}, "Found", 302, 77, "Location",
+                "/redirect.html", "redirect-header0", "header-value");
         UrlResponseInfo firstRedirectResponseInfo = callback.mRedirectResponseInfoList.get(0);
-        assertEquals(1, firstRedirectResponseInfo.getUrlChain().size());
-        assertEquals(NativeTestServer.getMultiRedirectURL(),
-                firstRedirectResponseInfo.getUrlChain().get(0));
-        checkResponseInfo(
-                firstRedirectResponseInfo, NativeTestServer.getMultiRedirectURL(), 302, "Found");
-        checkResponseInfoHeader(firstRedirectResponseInfo,
-                "redirect-header0", "header-value");
-        assertEquals(77, firstRedirectResponseInfo.getReceivedBytesCount());
+        assertResponseEquals(firstExpectedResponseInfo, firstRedirectResponseInfo);
 
         // Check second redirect (redirect.html -> success.txt)
-        UrlResponseInfo secondRedirectResponseInfo = callback.mRedirectResponseInfoList.get(1);
-        assertEquals(2, secondRedirectResponseInfo.getUrlChain().size());
-        assertEquals(NativeTestServer.getMultiRedirectURL(),
-                secondRedirectResponseInfo.getUrlChain().get(0));
-        assertEquals(
-                NativeTestServer.getRedirectURL(), secondRedirectResponseInfo.getUrlChain().get(1));
-        checkResponseInfo(
-                secondRedirectResponseInfo, NativeTestServer.getRedirectURL(), 302, "Found");
-        checkResponseInfoHeader(secondRedirectResponseInfo,
-                "redirect-header", "header-value");
-        assertEquals(151, secondRedirectResponseInfo.getReceivedBytesCount());
+        UrlResponseInfo secondExpectedResponseInfo = createUrlResponseInfo(
+                new String[] {NativeTestServer.getMultiRedirectURL(),
+                        NativeTestServer.getRedirectURL(), NativeTestServer.getSuccessURL()},
+                "OK", 200, 337, "Content-Type", "text/plain", "Access-Control-Allow-Origin", "*",
+                "header-name", "header-value", "multi-header-name", "header-value1",
+                "multi-header-name", "header-value2");
 
-        // Check final response (success.txt).
-        assertEquals(NativeTestServer.getSuccessURL(), mResponseInfo.getUrl());
-        assertEquals(3, mResponseInfo.getUrlChain().size());
-        assertEquals(NativeTestServer.getMultiRedirectURL(), mResponseInfo.getUrlChain().get(0));
-        assertEquals(NativeTestServer.getRedirectURL(), mResponseInfo.getUrlChain().get(1));
-        assertEquals(NativeTestServer.getSuccessURL(), mResponseInfo.getUrlChain().get(2));
+        assertResponseEquals(secondExpectedResponseInfo, mResponseInfo);
         assertTrue(callback.mHttpResponseDataLength != 0);
         assertEquals(2, callback.mRedirectCount);
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
-        assertEquals(337, mResponseInfo.getReceivedBytesCount());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testMockNotFound() throws Exception {
         TestUrlRequestCallback callback =
                 startAndWaitForComplete(NativeTestServer.getNotFoundURL());
-        assertEquals(404, callback.mResponseInfo.getHttpStatusCode());
-        assertEquals(121, callback.mResponseInfo.getReceivedBytesCount());
+        UrlResponseInfo expected = createUrlResponseInfo(
+                new String[] {NativeTestServer.getNotFoundURL()}, "Not Found", 404, 121);
+        assertResponseEquals(expected, callback.mResponseInfo);
         assertTrue(callback.mHttpResponseDataLength != 0);
         assertEquals(0, callback.mRedirectCount);
         assertFalse(callback.mOnErrorCalled);
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
     }
 
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet // Java impl doesn't support MockUrlRequestJobFactory
     public void testMockStartAsyncError() throws Exception {
         final int arbitraryNetError = -3;
         TestUrlRequestCallback callback =
                 startAndWaitForComplete(MockUrlRequestJobFactory.getMockUrlWithFailure(
                         FailurePhase.START, arbitraryNetError));
         assertNull(callback.mResponseInfo);
         assertNotNull(callback.mError);
         assertEquals(arbitraryNetError, callback.mError.netError());
         assertEquals(0, callback.mRedirectCount);
         assertTrue(callback.mOnErrorCalled);
         assertEquals(callback.mResponseStep, ResponseStep.NOTHING);
     }
 
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet // Java impl doesn't support MockUrlRequestJobFactory
     public void testMockReadDataSyncError() throws Exception {
         final int arbitraryNetError = -4;
         TestUrlRequestCallback callback =
                 startAndWaitForComplete(MockUrlRequestJobFactory.getMockUrlWithFailure(
                         FailurePhase.READ_SYNC, arbitraryNetError));
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(0, callback.mResponseInfo.getReceivedBytesCount());
         assertNotNull(callback.mError);
         assertEquals(arbitraryNetError, callback.mError.netError());
         assertEquals(0, callback.mRedirectCount);
         assertTrue(callback.mOnErrorCalled);
         assertEquals(callback.mResponseStep, ResponseStep.ON_RESPONSE_STARTED);
     }
 
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet // Java impl doesn't support MockUrlRequestJobFactory
     public void testMockReadDataAsyncError() throws Exception {
         final int arbitraryNetError = -5;
         TestUrlRequestCallback callback =
                 startAndWaitForComplete(MockUrlRequestJobFactory.getMockUrlWithFailure(
                         FailurePhase.READ_ASYNC, arbitraryNetError));
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(0, callback.mResponseInfo.getReceivedBytesCount());
         assertNotNull(callback.mError);
         assertEquals(arbitraryNetError, callback.mError.netError());
         assertEquals(0, callback.mRedirectCount);
         assertTrue(callback.mOnErrorCalled);
         assertEquals(callback.mResponseStep, ResponseStep.ON_RESPONSE_STARTED);
     }
 
     /**
      * Tests that request continues when client certificate is requested.
      */
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet
     public void testMockClientCertificateRequested() throws Exception {
         TestUrlRequestCallback callback = startAndWaitForComplete(
                 MockUrlRequestJobFactory.getMockUrlForClientCertificateRequest());
         assertNotNull(callback.mResponseInfo);
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("data", callback.mResponseAsString);
         assertEquals(0, callback.mRedirectCount);
         assertNull(callback.mError);
         assertFalse(callback.mOnErrorCalled);
     }
 
     /**
      * Tests that an SSL cert error will be reported via {@link UrlRequest#onFailed}.
      */
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet // Java impl doesn't support MockUrlRequestJobFactory
     public void testMockSSLCertificateError() throws Exception {
         TestUrlRequestCallback callback = startAndWaitForComplete(
                 MockUrlRequestJobFactory.getMockUrlForSSLCertificateError());
         assertNull(callback.mResponseInfo);
         assertNotNull(callback.mError);
         assertTrue(callback.mOnErrorCalled);
         assertEquals(-201, callback.mError.netError());
         assertEquals("Exception in CronetUrlRequest: net::ERR_CERT_DATE_INVALID",
                 callback.mError.getMessage());
         assertEquals(callback.mResponseStep, ResponseStep.NOTHING);
@@ skipping 224 matching lines @@
         final UrlRequest urlRequest =
                 new UrlRequest.Builder(NativeTestServer.getRedirectURL(), callback,
                                       callback.getExecutor(), mTestFramework.mCronetEngine)
                         .build();
 
         // Try to read before starting request.
         try {
             callback.startNextRead(urlRequest);
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
-            assertEquals("Unexpected read attempt.",
-                    e.getMessage());
         }
 
         // Verify reading right after start throws an assertion. Both must be
         // invoked on the Executor thread, to prevent receiving data until after
         // startNextRead has been invoked.
         Runnable startAndRead = new Runnable() {
             @Override
             public void run() {
                 urlRequest.start();
                 try {
                     callback.startNextRead(urlRequest);
                     fail("Exception not thrown");
                 } catch (IllegalStateException e) {
-                    assertEquals("Unexpected read attempt.",
-                            e.getMessage());
                 }
             }
         };
         callback.getExecutor().execute(startAndRead);
         callback.waitForNextStep();
 
         assertEquals(callback.mResponseStep, ResponseStep.ON_RECEIVED_REDIRECT);
         // Try to read after the redirect.
         try {
             callback.startNextRead(urlRequest);
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
-            assertEquals("Unexpected read attempt.",
-                    e.getMessage());
         }
         urlRequest.followRedirect();
         callback.waitForNextStep();
 
         assertEquals(callback.mResponseStep, ResponseStep.ON_RESPONSE_STARTED);
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
 
         while (!callback.isDone()) {
             Runnable readTwice = new Runnable() {
                 @Override
                 public void run() {
                     callback.startNextRead(urlRequest);
                     // Try to read again before the last read completes.
                     try {
                         callback.startNextRead(urlRequest);
                         fail("Exception not thrown");
                     } catch (IllegalStateException e) {
-                        assertEquals("Unexpected read attempt.",
-                                e.getMessage());
                     }
                 }
             };
             callback.getExecutor().execute(readTwice);
             callback.waitForNextStep();
         }
 
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
         assertEquals(NativeTestServer.SUCCESS_BODY, callback.mResponseAsString);
 
         // Try to read after request is complete.
         try {
             callback.startNextRead(urlRequest);
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
-            assertEquals("Unexpected read attempt.",
-                    e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUnexpectedFollowRedirects() throws Exception {
         final TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setAutoAdvance(false);
         final UrlRequest urlRequest =
                 new UrlRequest.Builder(NativeTestServer.getRedirectURL(), callback,
                                       callback.getExecutor(), mTestFramework.mCronetEngine)
                         .build();
 
         // Try to follow a redirect before starting the request.
         try {
             urlRequest.followRedirect();
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
-            assertEquals("No redirect to follow.",
-                    e.getMessage());
         }
 
         // Try to follow a redirect just after starting the request. Has to be
         // done on the executor thread to avoid a race.
         Runnable startAndRead = new Runnable() {
             @Override
             public void run() {
                 urlRequest.start();
                 try {
                     urlRequest.followRedirect();
                     fail("Exception not thrown");
                 } catch (IllegalStateException e) {
-                    assertEquals("No redirect to follow.",
-                            e.getMessage());
                 }
             }
         };
         callback.getExecutor().execute(startAndRead);
         callback.waitForNextStep();
 
         assertEquals(callback.mResponseStep, ResponseStep.ON_RECEIVED_REDIRECT);
         // Try to follow the redirect twice. Second attempt should fail.
         Runnable followRedirectTwice = new Runnable() {
             @Override
             public void run() {
                 urlRequest.followRedirect();
                 try {
                     urlRequest.followRedirect();
                     fail("Exception not thrown");
                 } catch (IllegalStateException e) {
-                    assertEquals("No redirect to follow.",
-                            e.getMessage());
                 }
             }
         };
         callback.getExecutor().execute(followRedirectTwice);
         callback.waitForNextStep();
 
         assertEquals(callback.mResponseStep, ResponseStep.ON_RESPONSE_STARTED);
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
 
         while (!callback.isDone()) {
             try {
                 urlRequest.followRedirect();
                 fail("Exception not thrown");
             } catch (IllegalStateException e) {
-                assertEquals("No redirect to follow.",
-                        e.getMessage());
             }
             callback.startNextRead(urlRequest);
             callback.waitForNextStep();
         }
 
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
         assertEquals(NativeTestServer.SUCCESS_BODY, callback.mResponseAsString);
 
         // Try to follow redirect after request is complete.
         try {
             urlRequest.followRedirect();
             fail("Exception not thrown");
         } catch (IllegalStateException e) {
-            assertEquals("No redirect to follow.",
-                    e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadSetDataProvider() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
                 callback, callback.getExecutor(), mTestFramework.mCronetEngine);
 
         try {
             builder.setUploadDataProvider(null, callback.getExecutor());
             fail("Exception not thrown");
         } catch (NullPointerException e) {
             assertEquals("Invalid UploadDataProvider.", e.getMessage());
         }
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         try {
             builder.build().start();
             fail("Exception not thrown");
         } catch (IllegalArgumentException e) {
-            assertEquals("Requests with upload data must have a Content-Type.", e.getMessage());
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadEmptyBodySync() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
                 callback, callback.getExecutor(), mTestFramework.mCronetEngine);
 
@@ skipping 381 matching lines @@
         assertEquals(3, dataProvider.getNumReadCalls());
         assertEquals("hello there!", callback.mResponseAsString);
     }
 
     // Test where an upload fails without ever initializing the
     // UploadDataStream, because it can't connect to the server.
     @SmallTest
     @Feature({"Cronet"})
     public void testUploadFailsWithoutInitializingStream() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
-        UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
-                callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest.Builder builder = new UrlRequest.Builder("http://127.0.0.1:12345", callback,

[pauljensen, 2016/01/07 04:33:38]

why did you change this and line 1391?  I admit the previous code wasn't safe
(NativeTestServer probably bound to some random port, and once shutdown another
server was probably free to bind to that port, thus breaking the test
potentially).  But picking port 12345 and assuming it's unused is also a bit
unsafe.  If you really think using port 12345 is better, please remove lines
1389-1391.

[Charles, 2016/01/07 16:10:02]

Shutting down the native test server causes getEchoBodyUrl to abort with a CHECK
failure the next time this test is called, because the server isn't running.
I've now chosen a reserved port that only accepts UDP, so we should be in good
shape.

+                callback.getExecutor(), mTestFramework.mCronetEngine);
         // Shut down the test server, so connecting to it fails. Note that
         // calling shutdown again during teardown is safe.
-        NativeTestServer.shutdownNativeTestServer();
+        // NativeTestServer.shutdownNativeTestServer();
 
         TestUploadDataProvider dataProvider = new TestUploadDataProvider(
                 TestUploadDataProvider.SuccessCallbackMode.SYNC, callback.getExecutor());
         dataProvider.addRead("test".getBytes());
         builder.setUploadDataProvider(dataProvider, callback.getExecutor());
         builder.addHeader("Content-Type", "useless/string");
         builder.build().start();
         callback.blockForDone();
 
         assertNull(callback.mResponseInfo);
-        assertEquals("Exception in CronetUrlRequest: net::ERR_CONNECTION_REFUSED",
-                callback.mError.getMessage());
+        if (testingJavaImpl()) {
+            assertTrue(callback.mError.getCause() instanceof ConnectException);
+        } else {
+            assertEquals("Exception in CronetUrlRequest: net::ERR_CONNECTION_REFUSED",
+                    callback.mError.getMessage());
+        }
     }
 
     private void throwOrCancel(FailureType failureType, ResponseStep failureStep,
             boolean expectResponseInfo, boolean expectError) {
+        if (Log.isLoggable("TESTING", Log.VERBOSE)) {
+            Log.v("TESTING", "Testing " + failureType + " during " + failureStep);
+        }
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         callback.setFailure(failureType, failureStep);
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getRedirectURL(),
                 callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         callback.blockForDone();
         assertEquals(1, callback.mRedirectCount);
         assertEquals(callback.mResponseStep, failureStep);
         assertTrue(urlRequest.isDone());
@@ skipping 50 matching lines @@
         assertEquals(1, callback.mRedirectCount);
         assertEquals(callback.mResponseStep, ResponseStep.ON_SUCCEEDED);
         assertTrue(urlRequest.isDone());
         assertNotNull(callback.mResponseInfo);
         assertNull(callback.mError);
         assertFalse(callback.mOnErrorCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet // No destroyed callback for tests
     public void testExecutorShutdown() {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
 
         callback.setAutoAdvance(false);
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
                 callback, callback.getExecutor(), mTestFramework.mCronetEngine);
         CronetUrlRequest urlRequest = (CronetUrlRequest) builder.build();
         urlRequest.start();
         callback.waitForNextStep();
         assertFalse(callback.isDone());
@@ skipping 118 matching lines @@
     private 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);
     }
 }