[Cronet] Implement getOutputStream in CronetHttpURLConnection

components/cronet/android/test/javatests/src/org/chromium/net/urlconnection/CronetHttpURLConnectionTest.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.urlconnection;
 
 import android.os.Build;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.CronetTestActivity;
 import org.chromium.net.CronetTestBase;
 import org.chromium.net.MockUrlRequestJobFactory;
 import org.chromium.net.NativeTestServer;
 import org.chromium.net.UrlRequestContextConfig;
 import org.chromium.net.UrlRequestException;
 
 import java.io.ByteArrayOutputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * Basic tests of Cronet's HttpURLConnection implementation.
  * Tests annotated with {@code CompareDefaultWithCronet} will run once with the
  * default HttpURLConnection implementation and then with Cronet's
  * HttpURLConnection implementation. Tests annotated with
  * {@code OnlyRunCronetHttpURLConnection} only run Cronet's implementation.
  * See {@link CronetTestBase#runTest()} for details.
  */
 public class CronetHttpURLConnectionTest extends CronetTestBase {
-    private CronetTestActivity mActivity;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         UrlRequestContextConfig config = new UrlRequestContextConfig();
         config.setStoragePath(prepareTestStorage());
         config.enableHttpCache(UrlRequestContextConfig.HttpCache.DISK,
                 1000 * 1024);
         String[] commandLineArgs = {
                 CronetTestActivity.CONFIG_KEY, config.toString()};
-        mActivity = launchCronetTestAppWithUrlAndCommandLineArgs(null,
+        launchCronetTestAppWithUrlAndCommandLineArgs(null,
                 commandLineArgs);
         assertTrue(NativeTestServer.startNativeTestServer(
                 getInstrumentation().getTargetContext()));
     }
 
     @Override
     protected void tearDown() throws Exception {
         NativeTestServer.shutdownNativeTestServer();
         super.tearDown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @CompareDefaultWithCronet
     public void testBasicGet() throws Exception {
         URL url = new URL(NativeTestServer.getEchoMethodURL());
         HttpURLConnection urlConnection =
                 (HttpURLConnection) url.openConnection();
         assertEquals(200, urlConnection.getResponseCode());
         assertEquals("OK", urlConnection.getResponseMessage());
         assertEquals("GET", getResponseAsString(urlConnection));
         urlConnection.disconnect();
     }
 
+    /**
+     * Tests that using reflection to find {@code fixedContentLengthLong} works.
+     */
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunCronetHttpURLConnection
+    public void testSetFixedLengthStreamingModeLong() throws Exception {
+        URL url = new URL(NativeTestServer.getEchoBodyURL());
+        HttpURLConnection connection =
+                (HttpURLConnection) url.openConnection();
+        connection.setDoOutput(true);
+        connection.setRequestMethod("POST");
+        if (Build.VERSION.SDK_INT >= 19) {
+            String dataString = "some very important data";
+            byte[] data = dataString.getBytes();
+            Class<?> c = connection.getClass();
+            Method method = c.getMethod("setFixedLengthStreamingMode",
+                    new Class[] {long.class});
+            method.invoke(connection, (long) data.length);
+            OutputStream out = connection.getOutputStream();
+            out.write(data);
+            assertEquals(200, connection.getResponseCode());
+            assertEquals("OK", connection.getResponseMessage());
+            assertEquals(dataString, getResponseAsString(connection));
+            connection.disconnect();
+        }
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunCronetHttpURLConnection
+    // TODO(xunjieli): Change the test after chunked support is added.
+    public void testPostChunked() throws Exception {
+        URL url = new URL(NativeTestServer.getEchoBodyURL());
+        HttpURLConnection connection =
+                (HttpURLConnection) url.openConnection();
+        connection.setDoOutput(true);
+        connection.setRequestMethod("POST");
+        try {
+            connection.setChunkedStreamingMode(0);
+        } catch (UnsupportedOperationException e) {
+            assertEquals("Chunked mode not supported yet", e.getMessage());
+        }
+    }
+
     @SmallTest
     @Feature({"Cronet"})
     @CompareDefaultWithCronet
     public void testNotFoundURLRequest() throws Exception {
         URL url = new URL(NativeTestServer.getFileURL("/notfound.html"));
         HttpURLConnection urlConnection =
                 (HttpURLConnection) url.openConnection();
         assertEquals(404, urlConnection.getResponseCode());
         assertEquals("Not Found", urlConnection.getResponseMessage());
         try {
@@ skipping 22 matching lines @@
         URL url = new URL(NativeTestServer.getFileURL("/success.txt"));
         HttpURLConnection urlConnection =
                 (HttpURLConnection) url.openConnection();
         assertEquals("this is a text file\n",
                 getResponseAsString(urlConnection));
         // After shutting down the server, the server should not be handling
         // new requests.
         NativeTestServer.shutdownNativeTestServer();
         HttpURLConnection secondConnection =
                 (HttpURLConnection) url.openConnection();
+        // Default implementation reports this type of error in connect().
+        // However, since Cronet's wrapper only receives the error in its listener
+        // callback when message loop is running, Cronet's wrapper only knows
+        // about the error when it starts to read response.
         try {
-            secondConnection.connect();
+            secondConnection.getResponseCode();
             fail();
         } catch (IOException e) {
             assertTrue(e instanceof java.net.ConnectException
                     || e instanceof UrlRequestException);
             assertTrue((e.getMessage().contains("ECONNREFUSED")
                     || e.getMessage().contains("net::ERR_CONNECTION_REFUSED")));
         }
         checkExceptionsAreThrown(secondConnection);
         // Starts the server to avoid crashing on shutdown in tearDown().
         assertTrue(NativeTestServer.startNativeTestServer(
                 getInstrumentation().getTargetContext()));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @CompareDefaultWithCronet
     public void testBadIP() throws Exception {
         URL url = new URL("http://0.0.0.0/");
         HttpURLConnection urlConnection =
                 (HttpURLConnection) url.openConnection();
+        // Default implementation reports this type of error in connect().
+        // However, since Cronet's wrapper only receives the error in its listener
+        // callback when message loop is running, Cronet's wrapper only knows
+        // about the error when it starts to read response.
         try {
-            urlConnection.connect();
+            urlConnection.getResponseCode();
             fail();
         } catch (IOException e) {
             assertTrue(e instanceof java.net.ConnectException
                     || e instanceof UrlRequestException);
             assertTrue((e.getMessage().contains("ECONNREFUSED")
                     || e.getMessage().contains("net::ERR_CONNECTION_REFUSED")));
         }
         checkExceptionsAreThrown(urlConnection);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @CompareDefaultWithCronet
     public void testBadHostname() throws Exception {
         URL url = new URL("http://this-weird-host-name-does-not-exist/");
         HttpURLConnection urlConnection =
                 (HttpURLConnection) url.openConnection();
+        // Default implementation reports this type of error in connect().
+        // However, since Cronet's wrapper only receives the error in its listener
+        // callback when message loop is running, Cronet's wrapper only knows
+        // about the error when it starts to read response.
         try {
-            urlConnection.connect();
+            urlConnection.getResponseCode();
             fail();
         } catch (java.net.UnknownHostException e) {
             // Expected.
         } catch (UrlRequestException e) {
             // Expected.
         }
         checkExceptionsAreThrown(urlConnection);
     }
 
     @SuppressFBWarnings("DLS_DEAD_LOCAL_STORE")
@@ skipping 46 matching lines @@
             InputStream in = urlConnection.getInputStream();
             fail();
         } catch (Exception e) {
             // Ignored.
         }
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @CompareDefaultWithCronet
+    public void testMultipleDisconnect() throws Exception {
+        URL url = new URL(NativeTestServer.getEchoMethodURL());
+        HttpURLConnection urlConnection =
+                (HttpURLConnection) url.openConnection();
+        assertEquals(200, urlConnection.getResponseCode());
+        assertEquals("OK", urlConnection.getResponseMessage());
+        assertEquals("GET", getResponseAsString(urlConnection));
+        // Disconnect multiple times should be fine.
+        for (int i = 0; i < 10; i++) {
+            urlConnection.disconnect();
+        }
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @CompareDefaultWithCronet
     public void testAddRequestProperty() throws Exception {
         URL url = new URL(NativeTestServer.getEchoAllHeadersURL());
         HttpURLConnection connection = (HttpURLConnection) url.openConnection();
         connection.addRequestProperty("foo-header", "foo");
         connection.addRequestProperty("bar-header", "bar");
 
         // Before connection is made, check request headers are set.
         Map<String, List<String>> requestHeadersMap =
                 connection.getRequestProperties();
         List<String> fooValues = requestHeadersMap.get("foo-header");
@@ skipping 634 matching lines @@
                 CacheSetting.USE_CACHE, ExpectedOutcome.SUCCESS);
         NativeTestServer.shutdownNativeTestServer();
         // Disables caching. No cached response is received.
         checkRequestCaching(url,
                 CacheSetting.DONT_USE_CACHE, ExpectedOutcome.FAILURE);
     }
 
     private void checkExceptionsAreThrown(HttpURLConnection connection)
             throws Exception {
         try {
-            connection.connect();
-            fail();
-        } catch (IOException e) {
-            // Expected.
-        }
-
-        try {
             connection.getInputStream();
             fail();
         } catch (IOException e) {
             // Expected.
         }
 
         try {
             connection.getResponseCode();
             fail();
         } catch (IOException e) {
@@ skipping 47 matching lines @@
             String headerName) {
         Pattern pattern = Pattern.compile(headerName + ":\\s(.*)\\r\\n");
         Matcher matcher = pattern.matcher(allHeaders);
         List<String> headerValues = new ArrayList<String>();
         while (matcher.find()) {
             headerValues.add(matcher.group(1));
         }
         return headerValues;
     }
 }