/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.apache.harmony.luni.tests.internal.net.www.protocol.http;

import java.io.IOException;
import java.io.InputStream;
import java.net.Authenticator;
import java.net.ConnectException;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.PasswordAuthentication;
import java.net.Proxy;
import java.net.ProxySelector;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketTimeoutException;
import java.net.URI;
import java.net.URL;
import java.security.Permission;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

// TODO: rewrite these tests to use MockWebServer, assuming we don't already have better equivalent tests.
/*
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.mortbay.jetty.HttpConnection;
import org.mortbay.jetty.Request;
import org.mortbay.jetty.Server;
import org.mortbay.jetty.handler.DefaultHandler;

import tests.support.Support_Jetty;
*/

import junit.framework.TestCase;

/**
 * Tests for <code>HttpURLConnection</code> class constructors and methods.
 */
public class HttpURLConnectionTest extends TestCase {

/*
    private static final boolean DEBUG = false;

    private final static Object bound = new Object();

    static class MockServer extends Thread {
        ServerSocket serverSocket;
        boolean accepted = false;
        boolean started = false;

        public MockServer(String name) throws IOException {
            super(name);
            serverSocket = new ServerSocket(0);
            serverSocket.setSoTimeout(5000);
        }

        public int port() {
            return serverSocket.getLocalPort();
        }

        @Override
        public void run() {
            try {
                synchronized (bound) {
                    started = true;
                    bound.notify();
                }
                try {
                    serverSocket.accept().close();
                    accepted = true;
                } catch (SocketTimeoutException ignore) {
                }
                serverSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    static class MockHTTPServer extends MockServer {
        // HTTP response codes
        static final int OK_CODE = 200;
        static final int NOT_FOUND_CODE = 404;
        // how many times persistent connection will be used
        // by server
        int persUses;
        // result code to be sent to client
        int responseCode;
        // response content to be sent to client
        String response = "<html></html>";
        // client's POST message
        String clientPost = "Hello from client!";

        public MockHTTPServer(String name, int persUses) throws IOException {
            this(name, persUses, OK_CODE);
        }

        public MockHTTPServer(String name, int persUses, int responseCode)
                throws IOException {
            super(name);
            this.persUses = persUses;
            this.responseCode = responseCode;
        }

        public int port() {
            return serverSocket.getLocalPort();
        }

        @Override
        public void run() {
            try {
                synchronized (bound) {
                    started = true;
                    bound.notify();
                }
                InputStream is = null;
                Socket client = null;
                try {
                    client = serverSocket.accept();
                    accepted = true;
                    for (int i = 0; i < persUses; i++) {
                        if (DEBUG) {
                            System.out.println("*** Using connection for "
                                    + (i + 1) + " time ***");
                        }
                        byte[] buff = new byte[1024];
                        is = client.getInputStream();
                        int num = 0; // number of read bytes
                        int bytik; // read byte value
                        boolean wasEOL = false;
                        // read header (until empty string)
                        while (((bytik = is.read()) > 0)) {
                            if (bytik == '\r') {
                                bytik = is.read();
                            }
                            if (wasEOL && (bytik == '\n')) {
                                break;
                            }
                            wasEOL = (bytik == '\n');
                            buff[num++] = (byte) bytik;
                        }
                        // int num = is.read(buff);
                        String message = new String(buff, 0, num, "UTF-8");
                        if (DEBUG) {
                            System.out
                                    .println("---- Server got request: ----\n"
                                            + message
                                            + "-----------------------------");
                        }

                        // Act as Server (not Proxy) side
                        if (message.startsWith("POST")) {
                            // client connection sent some data
                            // if the data was not read with header
                            if (DEBUG) {
                                System.out
                                        .println("---- Server read client's data: ----");
                            }
                            num = is.read(buff);
                            message = new String(buff, 0, num, "UTF-8");
                            if (DEBUG) {
                                System.out.println("'" + message + "'");
                                System.out
                                        .println("------------------------------------");
                            }
                            // check the received data
                            assertEquals(clientPost, message);
                        }

                        client
                                .getOutputStream()
                                .write(
                                        ("HTTP/1.1 " + responseCode + " OK\n"
                                                + "Content-type: text/html\n"
                                                + "Content-length: "
                                                + response.length() + "\n\n" + response)
                                                .getBytes("UTF-8"));

                        if (responseCode != OK_CODE) {
                            // wait while test case check closed connection
                            // and interrupt this thread
                            try {
                                while (!isInterrupted()) {
                                    Thread.sleep(1000);
                                }
                            } catch (Exception ignore) {
                            }
                        }
                    }
                } catch (SocketTimeoutException ignore) {
                    ignore.printStackTrace();
                } finally {
                    if (is != null) {
                        is.close();
                    }
                    if (client != null) {
                        client.close();
                    }
                    serverSocket.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    static class MockProxyServer extends MockServer {

        boolean acceptedAuthorizedRequest;

        public MockProxyServer(String name) throws Exception {
            super(name);
        }

        @Override
        public void run() {
            try {
                Socket socket = serverSocket.accept();
                socket.setSoTimeout(5000);
                byte[] buff = new byte[1024];
                int num = socket.getInputStream().read(buff);
                socket
                        .getOutputStream()
                        .write(
                                ("HTTP/1.0 407 Proxy authentication required\n"
                                        + "Proxy-authenticate: Basic realm=\"remotehost\"\n\n")
                                        .getBytes("UTF-8"));
                num = socket.getInputStream().read(buff);
                if (num == -1) {
                    // this connection was closed, create new one:
                    socket = serverSocket.accept();
                    socket.setSoTimeout(5000);
                    num = socket.getInputStream().read(buff);
                }
                String request = new String(buff, 0, num, "UTF-8");
                acceptedAuthorizedRequest = request.toLowerCase().indexOf(
                        "proxy-authorization:") > 0;
                if (acceptedAuthorizedRequest) {
                    socket.getOutputStream().write(
                            ("HTTP/1.1 200 OK\n\n").getBytes("UTF-8"));
                }
            } catch (IOException e) {
            }
        }
    }

    private int jettyPort = 0;

    private String jettyURL;

    public void setUp() throws Exception {
        jettyPort = Support_Jetty.startDefaultHttpServer();
        jettyURL = "http://localhost:" + jettyPort + "/servlet";
        if (DEBUG) {
            System.out.println("\n==============================");
            System.out.println("===== Execution: " + getName());
            System.out.println("==============================");
        }
    }

    public static class ResponseServer {
        private Server server = null;

        private int port = -1;

        public class MyRealmHandler extends DefaultHandler {
            public void handle(String target, HttpServletRequest request,
                    HttpServletResponse response, int dispatch)
                    throws IOException, ServletException {
                boolean auth = request.getHeader("Authorization") != null;
                String resLoc = request.getPathInfo();
                boolean noRealm = "/norealm".equals(resLoc);

                Request base_request = (request instanceof Request) ? (Request) request
                        : HttpConnection.getCurrentConnection().getRequest();
                base_request.setHandled(true);
                response.setContentType("text/html");
                response.addDateHeader("Date", System.currentTimeMillis());
                if (noRealm) {
                    response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                    response.getWriter().print("<h1>No WWW-Authenticate</h1>");
                } else {
                    if (auth) {
                        response.setStatus(HttpServletResponse.SC_OK);
                    } else {
                        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                        response.addHeader("WWW-Authenticate",
                                "Basic realm=\"HelloWorld\"");
                    }
                }
            }
        }

        public void startServer(DefaultHandler handler) throws Exception {
            server = new Server(0);
            server.setHandler(handler);
            server.start();
            port = server.getConnectors()[0].getLocalPort();
        }

        public void stopServer() throws Exception {
            if (server != null) {
                server.stop();
                server = null;
            }
        }

        public int getPort() {
            return port;
        }
    }

    // Test response code which need authenticate
    public void testGetResponseCode() throws Exception {
        ResponseServer server = new ResponseServer();
        HttpURLConnection conn = null;
        try {
            server.startServer(server.new MyRealmHandler());
            int port = server.getPort();
            try {
                conn = (HttpURLConnection) new URL("http://localhost:" + port
                        + "/norealm").openConnection();
                assertEquals(401, conn.getResponseCode());
            } finally {
                if (conn != null) {
                    try {
                        conn.disconnect();
                    } catch (Exception e) {
                    }
                }
            }

            try {
                conn = (HttpURLConnection) new URL("http://localhost:" + port
                        + "/realm").openConnection();
                assertEquals(401, conn.getResponseCode());
                assertEquals("Basic realm=\"HelloWorld\"", conn
                        .getHeaderField("WWW-Authenticate"));
            } finally {
                if (conn != null) {
                    try {
                        conn.disconnect();
                    } catch (Exception e) {
                    }
                }
            }

            try {
                Authenticator.setDefault(new Authenticator() {
                    public PasswordAuthentication getPasswordAuthentication() {
                        return new PasswordAuthentication("test", "password"
                                .toCharArray());
                    }
                });
                server.startServer(server.new MyRealmHandler());
                conn = (HttpURLConnection) new URL("http://localhost:" + port
                        + "/realm").openConnection();
                assertEquals(200, conn.getResponseCode());
                assertNull(conn.getHeaderField("WWW-Authenticate"));
            } finally {
                if (conn != null) {
                    try {
                        conn.disconnect();
                    } catch (Exception e) {
                    }
                }
            }
        } finally {
            server.stopServer();
        }
    }

    // ProxySelector implementation used in the test.
    static class TestProxySelector extends ProxySelector {
        // proxy port
        private int proxy_port;
        // server port
        private int server_port;

        // Creates proxy selector instance. Selector will return the proxy, only
        // if the connection is made to localhost:server_port. Otherwise it will
        // return NO_PROXY. Address of the returned proxy will be
        // localhost:proxy_port.
        public TestProxySelector(int server_port, int proxy_port) {
            this.server_port = server_port;
            this.proxy_port = proxy_port;
        }

        @Override
        public java.util.List<Proxy> select(URI uri) {
            Proxy proxy = Proxy.NO_PROXY;
            if (("localhost".equals(uri.getHost()))
                    && (server_port == uri.getPort())) {
                proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(
                        "localhost", proxy_port));
            }
            ArrayList<Proxy> result = new ArrayList<Proxy>();
            result.add(proxy);
            return result;
        }

        @Override
        public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {
            // do nothing
        }
    }

    public void test_getHeaderFields() throws Exception {
        URL url = new URL(jettyURL);
        HttpURLConnection httpURLConnect = (HttpURLConnection) url
                .openConnection();
        assertEquals(200, httpURLConnect.getResponseCode());
        assertEquals("OK", httpURLConnect.getResponseMessage());
        Map headers = httpURLConnect.getHeaderFields();
        // there should be at least 2 headers
        assertTrue(headers.size() > 1);
        List list = (List) headers.get("Content-Length");
        if (list == null) {
            list = (List) headers.get("content-length");
        }
        assertNotNull(list);
        try {
            headers.put("key", "value");
            fail("should throw UnsupportedOperationException");
        } catch (UnsupportedOperationException e) {
            // Expected
        }
        try {
            list.set(0, "value");
            fail("should throw UnsupportedOperationException");
        } catch (UnsupportedOperationException e) {
            // Expected
        }

        try {
            httpURLConnect.setRequestProperty("key", "value");
            fail("should throw IlegalStateException");
        } catch (IllegalStateException e) {
            // Expected
        }
    }

    // @tests the url with space
    public void testConnectWithSpaceinURL() throws Exception {
        String jettyURLwithSpace = "http://localhost:" + jettyPort
                + "/servlet with space";
        HttpURLConnection httpURLConnect = (HttpURLConnection) new URL(
                jettyURLwithSpace).openConnection();
        httpURLConnect.setDoOutput(true);
        httpURLConnect.connect();
        assertEquals(200, httpURLConnect.getResponseCode());
        assertEquals("OK", httpURLConnect.getResponseMessage());
    }

    // @tests the url with space
    public void testConnectWithSpaceinURL1() throws Exception {
        String jettyURLwithSpace = "http://localhost:" + jettyPort
                + "/servlet with space?arg1=value>1&arg2=%aval%1Aue&arg3=#";
        HttpURLConnection httpURLConnect = (HttpURLConnection) new URL(
                jettyURLwithSpace).openConnection();
        httpURLConnect.setDoOutput(true);
        httpURLConnect.connect();
        assertEquals(200, httpURLConnect.getResponseCode());
        assertEquals("OK", httpURLConnect.getResponseMessage());
    }

    public void testGetOutputStream() throws Exception {
        // Regression for HARMONY-482
        MockServer httpServer = new MockServer(
                "ServerSocket for HttpURLConnectionTest");
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }
        HttpURLConnection c = (HttpURLConnection) new URL("http://127.0.0.1:"
                + httpServer.port()).openConnection();
        c.setDoOutput(true);
        // use new String("POST") instead of simple "POST" to obtain other
        // object instances then those that are in HttpURLConnection classes
        c.setRequestMethod(new String("POST"));
        c.getOutputStream();
        httpServer.join();
    }

    // Test whether getOutputStream can work after connection
    public void test_getOutputStream_AfterConnect() throws Exception {
        URL url = new URL(jettyURL);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setDoOutput(true);
        connection.connect();
        String str_get = connection.getRequestMethod();
        assertTrue(str_get.equalsIgnoreCase("GET"));

        // call to getOutputStream should implicitly set req. method to POST
        connection.getOutputStream();
        String str_post = connection.getRequestMethod();
        assertTrue(str_post.equalsIgnoreCase("POST"));
    }

    // Test checks if the proxy specified in openConnection method will be used
    // for connection to the server
    public void testUsingProxy() throws Exception {
        // Regression for HARMONY-570
        MockServer server = new MockServer("server");
        MockServer proxy = new MockServer("proxy");

        URL url = new URL("http://localhost:" + server.port());

        HttpURLConnection connection = (HttpURLConnection) url
                .openConnection(new Proxy(Proxy.Type.HTTP,
                        new InetSocketAddress("localhost", proxy.port())));
        connection.setConnectTimeout(2000);
        connection.setReadTimeout(2000);

        server.start();
        synchronized (bound) {
            if (!server.started)
                bound.wait(5000);
        }
        proxy.start();
        synchronized (bound) {
            if (!proxy.started)
                bound.wait(5000);
        }

        connection.connect();

        // wait while server and proxy run
        server.join();
        proxy.join();

        assertTrue("Connection does not use proxy", connection.usingProxy());
        assertTrue("Proxy server was not used", proxy.accepted);

        HttpURLConnection huc = (HttpURLConnection) url
                .openConnection(Proxy.NO_PROXY);
        assertFalse(huc.usingProxy());
    }

    public void testUsingProxy2() throws Exception {
        try {
            System.setProperty("http.proxyHost", "localhost");
            System.setProperty("http.proxyPort", jettyPort + "");
            URL url = new URL(jettyURL);
            HttpURLConnection urlConnect = (HttpURLConnection) url
                    .openConnection();
            urlConnect.getInputStream();
            assertTrue(urlConnect.usingProxy());

            // find a free port
            ServerSocket serverSocket = new ServerSocket(0);
            int port = serverSocket.getLocalPort();
            serverSocket.close();

            System.setProperty("http.proxyPort", port + "");
            url = new URL(jettyURL);
            urlConnect = (HttpURLConnection) url.openConnection();
            urlConnect.getInputStream();
            assertFalse(urlConnect.usingProxy());

            url = new URL("http://localhost:" + port);
            urlConnect = (HttpURLConnection) url.openConnection();
            try {
                urlConnect.getInputStream();
                fail("should throw ConnectException");
            } catch (ConnectException e) {
                // Expected
            }
            assertFalse(urlConnect.usingProxy());
        } finally {
            System.setProperties(null);
        }
    }

    // Test checks if the proxy provided by proxy selector will be used for
    // connection to the server
    public void testUsingProxySelector() throws Exception {
        // Regression for HARMONY-570
        MockServer server = new MockServer("server");
        MockServer proxy = new MockServer("proxy");

        URL url = new URL("http://localhost:" + server.port());

        // keep default proxy selector
        ProxySelector defPS = ProxySelector.getDefault();
        // replace selector
        ProxySelector.setDefault(new TestProxySelector(server.port(), proxy
                .port()));

        try {
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            connection.setConnectTimeout(2000);
            connection.setReadTimeout(2000);

            server.start();
            synchronized (bound) {
                if (!server.started)
                    bound.wait(5000);
            }
            proxy.start();
            synchronized (bound) {
                if (!proxy.started)
                    bound.wait(5000);
            }
            connection.connect();

            // wait while server and proxy run
            server.join();
            proxy.join();

            assertTrue("Connection does not use proxy", connection.usingProxy());
            assertTrue("Proxy server was not used", proxy.accepted);
        } finally {
            // restore default proxy selector
            ProxySelector.setDefault(defPS);
        }
    }

    public void testProxyAuthorization() throws Exception {
        // Set up test Authenticator
        Authenticator.setDefault(new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("user", "password"
                        .toCharArray());
            }
        });

        try {
            MockProxyServer proxy = new MockProxyServer("ProxyServer");

            URL url = new URL("http://remotehost:55555/requested.data");
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection(new Proxy(Proxy.Type.HTTP,
                            new InetSocketAddress("localhost", proxy.port())));
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);

            proxy.start();

            connection.connect();
            assertEquals("unexpected response code", 200, connection
                    .getResponseCode());
            proxy.join();
            assertTrue("Connection did not send proxy authorization request",
                    proxy.acceptedAuthorizedRequest);
        } finally {
            // remove previously set authenticator
            Authenticator.setDefault(null);
        }
    }

    // Test that a connection is not closed if the client reads all the data but
    // not closes input stream. read until -1.
    public void testConnectionPersistence() throws Exception {
        MockHTTPServer httpServer = new MockHTTPServer(
                "HTTP Server for persistence checking", 2);
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }

        HttpURLConnection c = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        if (DEBUG) {
            System.out.println("Actual connection class: " + c.getClass());
        }

        c.setDoInput(true);
        c.setConnectTimeout(5000);
        c.setReadTimeout(5000);
        InputStream is = c.getInputStream();
        byte[] buffer = new byte[128];
        int totalBytes = 0;
        int bytesRead = 0;
        while ((bytesRead = is.read(buffer)) > 0) {
            if (DEBUG) {
                System.out.println("Client got response: '"
                        + new String(buffer, 0, bytesRead, "UTF-8") + "'");
            }
            totalBytes += bytesRead;
        }

        HttpURLConnection c2 = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        c2.setDoInput(true);
        c2.setConnectTimeout(5000);
        c2.setReadTimeout(5000);
        is = c2.getInputStream();
        buffer = new byte[128];
        totalBytes = 0;
        bytesRead = 0;
        while ((bytesRead = is.read(buffer)) > 0) {
            if (DEBUG) {
                System.out.println("Client got response: '"
                        + new String(buffer, 0, bytesRead, "UTF-8") + "'");
                totalBytes += bytesRead;
            }
        }
    }

    // Test that a connection is not closed if the client reads all the data but
    // not closes input stream. read() not receives -1.
    public void testConnectionPersistence2() throws Exception {
        MockHTTPServer httpServer = new MockHTTPServer(
                "HTTP Server for persistence checking", 2);
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }

        HttpURLConnection c = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        if (DEBUG) {
            System.out.println("Actual connection class: " + c.getClass());
        }

        c.setDoInput(true);
        c.setConnectTimeout(5000);
        c.setReadTimeout(5000);
        InputStream is = c.getInputStream();
        int bytes2Read = httpServer.response.length();
        byte[] buffer = new byte[httpServer.response.length()];
        while ((bytes2Read -= is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }

        HttpURLConnection c2 = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        c2.setDoInput(true);
        c2.setConnectTimeout(5000);
        c2.setReadTimeout(5000);
        is = c2.getInputStream();
        buffer = new byte[httpServer.response.length()];
        bytes2Read = httpServer.response.length();
        while ((bytes2Read -= is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }
    }

    // Test that a connection is not closed if it firstly does POST, and then
    // does GET requests.
    public void testConnectionPersistence3() throws Exception {
        MockHTTPServer httpServer = new MockHTTPServer(
                "HTTP Server for persistence checking", 2);
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }

        HttpURLConnection c = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        if (DEBUG) {
            System.out.println("Actual connection class: " + c.getClass());
        }

        c.setDoInput(true);
        c.setDoOutput(true);
        c.setConnectTimeout(5000);
        c.setReadTimeout(5000);
        c.getOutputStream().write(httpServer.clientPost.getBytes("UTF-8"));

        InputStream is = c.getInputStream();
        int bytes2Read = httpServer.response.length();
        byte[] buffer = new byte[httpServer.response.length()];
        while ((bytes2Read -= is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }

        HttpURLConnection c2 = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        c2.setDoInput(true);
        c2.setConnectTimeout(5000);
        c2.setReadTimeout(5000);
        is = c2.getInputStream();
        buffer = new byte[httpServer.response.length()];
        bytes2Read = httpServer.response.length();
        while ((bytes2Read -= is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }
    }

    // Test that a connection is not closed if it firstly does GET, and then
    // does POST requests.
    public void testConnectionPersistence4() throws Exception {
        MockHTTPServer httpServer = new MockHTTPServer(
                "HTTP Server for persistence checking", 2);
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }

        HttpURLConnection c = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        if (DEBUG) {
            System.out.println("Actual connection class: " + c.getClass());
        }

        c.setDoInput(true);
        c.setConnectTimeout(5000);
        c.setReadTimeout(5000);

        InputStream is = c.getInputStream();
        int bytes2Read = httpServer.response.length();
        byte[] buffer = new byte[httpServer.response.length()];
        while ((bytes2Read = is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }

        HttpURLConnection c2 = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        c2.setDoOutput(true);
        c2.setDoInput(true);
        c2.setConnectTimeout(5000);
        c2.setReadTimeout(5000);
        c2.getOutputStream().write(httpServer.clientPost.getBytes("UTF-8"));
        is = c2.getInputStream();
        buffer = new byte[httpServer.response.length()];
        bytes2Read = httpServer.response.length();
        while ((bytes2Read = is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }
    }

    // Test that a connection is not closed if it does POST for 2 times.
    public void testConnectionPersistence5() throws Exception {
        MockHTTPServer httpServer = new MockHTTPServer(
                "HTTP Server for persistence checking", 2);
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }

        HttpURLConnection c = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        if (DEBUG) {
            System.out.println("Actual connection class: " + c.getClass());
        }
        c.setDoOutput(true);
        c.setDoInput(true);
        c.setConnectTimeout(5000);
        c.setReadTimeout(5000);
        c.getOutputStream().write(httpServer.clientPost.getBytes("UTF-8"));
        InputStream is = c.getInputStream();
        int bytes2Read = httpServer.response.length();
        byte[] buffer = new byte[httpServer.response.length()];
        while ((bytes2Read = is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }

        HttpURLConnection c2 = (HttpURLConnection) new URL("http://localhost:"
                + httpServer.port()).openConnection();
        c2.setDoOutput(true);
        c2.setDoInput(true);
        c2.setConnectTimeout(5000);
        c2.setReadTimeout(5000);
        c2.getOutputStream().write(httpServer.clientPost.getBytes("UTF-8"));
        is = c2.getInputStream();
        buffer = new byte[httpServer.response.length()];
        bytes2Read = httpServer.response.length();
        while ((bytes2Read = is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }
    }

    // Test that a connection made through proxy will be reused for connection
    // establishing without proxy.
    public void testProxiedConnectionPersistence() throws Exception {
        MockHTTPServer httpServer = new MockHTTPServer(
                "HTTP Server for persistence checking", 2);
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }

        HttpURLConnection c = (HttpURLConnection) new URL(
                "http://some.host:1234").openConnection(new Proxy(
                Proxy.Type.HTTP, new InetSocketAddress("localhost", httpServer
                        .port())));
        if (DEBUG) {
            System.out.println("Actual connection class: " + c.getClass());
        }
        c.setDoOutput(true);
        c.setDoInput(true);
        c.setConnectTimeout(5000);
        c.setReadTimeout(5000);
        c.getOutputStream().write(httpServer.clientPost.getBytes("UTF-8"));
        InputStream is = c.getInputStream();
        int bytes2Read = httpServer.response.length();
        byte[] buffer = new byte[httpServer.response.length()];
        while ((bytes2Read = is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }

        HttpURLConnection c2 = (HttpURLConnection) new URL(
                "http://some.host:1234").openConnection();
        c2.setDoOutput(true);
        c2.setDoInput(true);
        c2.setConnectTimeout(5000);
        c2.setReadTimeout(5000);
        c2.getOutputStream().write(httpServer.clientPost.getBytes("UTF-8"));
        is = c2.getInputStream();
        buffer = new byte[httpServer.response.length()];
        bytes2Read = httpServer.response.length();
        while ((bytes2Read = is.read(buffer)) > 0) {
        }
        if (DEBUG) {
            System.out.println("Client got response: '" + new String(buffer)
                    + "'");
        }
    }

    public void testSetRequestProperty() throws Exception {
        MockHTTPServer httpServer = new MockHTTPServer(
                "HTTP Server for User-Specified Request Property", 2);
        httpServer.start();
        synchronized (bound) {
            if (!httpServer.started) {
                bound.wait(5000);
            }
        }

        HttpURLConnection urlConnection = (HttpURLConnection) new URL(
                "http://localhost:" + httpServer.port()).openConnection();
        assertEquals(0, urlConnection.getRequestProperties().size());

        final String PROPERTY1 = "Accept";
        final String PROPERTY2 = "Connection";
        urlConnection.setRequestProperty(PROPERTY1, null);
        urlConnection.setRequestProperty(PROPERTY1, null);
        urlConnection.setRequestProperty(PROPERTY2, "keep-alive");
        assertEquals(2, urlConnection.getRequestProperties().size());
        assertNull(urlConnection.getRequestProperty(PROPERTY1));
        assertEquals("keep-alive", urlConnection.getRequestProperty(PROPERTY2));

        urlConnection.setRequestProperty(PROPERTY1, "/");
        urlConnection.setRequestProperty(PROPERTY2, null);
        assertEquals("/", urlConnection.getRequestProperty(PROPERTY1));
        assertNull(urlConnection.getRequestProperty(PROPERTY2));
    }
*/
}