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 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.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 // No canonical exception to assert on
     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 // No canonical exception to assert on
     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 // No canonical exception to assert on
     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 an SSL cert error will be reported via {@link UrlRequest#onFailed}.
      */
     @SmallTest
     @Feature({"Cronet"})
+    @OnlyRunNativeCronet // No canonical exception to use yet
     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 379 matching lines @@
 
         // 2 read call for the first two data chunks, and 1 for final chunk.
         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"})
+    @OnlyRunNativeCronet // No canonical exception to assert on
     public void testUploadFailsWithoutInitializingStream() throws Exception {
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getEchoBodyURL(),
                 callback, 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();
 
         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());
     }
 
     private void throwOrCancel(FailureType failureType, ResponseStep failureStep,
             boolean expectResponseInfo, boolean expectError) {
+        System.out.println("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());
         assertEquals(expectResponseInfo, callback.mResponseInfo != null);
         assertEquals(expectError, callback.mError != null);
         assertEquals(expectError, callback.mOnErrorCalled);
         assertEquals(failureType == FailureType.CANCEL_SYNC
                         || failureType == FailureType.CANCEL_ASYNC
                         || failureType == FailureType.CANCEL_ASYNC_WITHOUT_PAUSE,
                 callback.mOnCanceledCalled);
     }
 
@@ skipping 41 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 77 matching lines @@
             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);
     }
 }