/*

 * Copyright (c) 2005, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/**

 * @test

 * @bug 6725892

 * @library /test/lib

 * @run main/othervm -Dsun.net.httpserver.maxReqTime=2 Test

 * @summary

 */

import com.sun.net.httpserver.*;

import java.util.concurrent.*;

import java.util.logging.*;

import java.io.*;

import java.net.*;

import javax.net.ssl.*;

import jdk.test.lib.net.URIBuilder;

public class Test {

    static HttpServer s1;

    static int port;

    static URL url;

    static final String RESPONSE_BODY = "response";

    static boolean failed = false;

    static class Handler implements HttpHandler {

            throws IOException

        {

            InputStream is = t.getRequestBody();

            InetSocketAddress rem = t.getRemoteAddress();

            while (is.read () != -1) ;

            is.close();

            String requrl = t.getRequestURI().toString();

            OutputStream os = t.getResponseBody();

            t.close();

        }

    }

        ExecutorService exec = Executors.newCachedThreadPool();

        try {

            s1.setExecutor(exec);

            s1.start();

            port = s1.getAddress().getPort();

            url = URIBuilder.newBuilder()

                .scheme("http")

                .loopback()

                .port(port)

                .path("/foo")

                .toURLUnchecked();

            System.out.println("URL: " + url);

            test1();

            test2();

            test3();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            s1.stop(0);

            exec.shutdown();

        }

    }

    // open TCP connection without sending anything. Check server closes it.

    static void test1() throws IOException {

        failed = false;

        InputStream is = s.getInputStream();

        // server should close connection after 2 seconds. We wait up to 10

        try {

            is.read();

        } catch (SocketTimeoutException e) {

            failed = true;

        }

        s.close();

        if (failed) {

        } else {

        }

    }

    // send request and don't read response. Check server closes connection

    static void test2() throws IOException {

        InputStream is = urlc.getInputStream();

        // we won't read response and check if it times out

        // on server. If it timesout at client then there is a problem

        try {

            while (is.read() != -1) ;

        } catch (InterruptedException e) {

        } catch (SocketTimeoutException e1) {

        } finally {

            is.close();

        }

    }

    // same as test2, but repeated with multiple connections

    // including a number of valid request/responses

    // Worker: a thread opens a connection to the server in one of three modes.

    // NORMAL - sends a request, waits for response, and checks valid response

    // REQUEST - sends a partial request, and blocks, to see if

    //                  server closes the connection.

    // RESPONSE - sends a request, partially reads response and blocks,

    //                  to see if server closes the connection.

    static class Worker extends Thread {

        CountDownLatch latch;

        Mode mode;

        enum Mode {

            REQUEST,    // block during sending of request

            RESPONSE,   // block during reading of response

            NORMAL      // don't block

        };

        Worker (CountDownLatch latch, Mode mode) {

            this.latch = latch;

            this.mode = mode;

        }

        void fail(String msg) {

            failed = true;

        }

            HttpURLConnection urlc;

            InputStream is = null;

            try {

                urlc.setDoOutput(true);

            } catch (IOException e) {

                fail("Worker: failed to connect to server");

                latch.countDown();

                return;

            }

            try {

                OutputStream os = urlc.getOutputStream();

                if (mode == Mode.REQUEST) {

                }

                os.close();

                is = urlc.getInputStream();

                if (mode == Mode.RESPONSE) {

                }

                }

                is.close();

                return;

            } catch (InterruptedException e0) {

                fail("Worker: timedout");

            } catch (SocketTimeoutException e1) {

                fail("Worker: timedout");

            } catch (IOException e2) {

                switch (mode) {

                  case NORMAL:

                    break;

                  case RESPONSE:

                    if (is == null) {

                        break;

                    }

                  // default: is ok

                }

            } finally {

                latch.countDown();

            }

        }

    }

    static final int NUM = 20;

    static void test3() throws Exception {

        failed = false;

        Worker[] workers = new Worker[NUM*3];

        for (int i=0; i<NUM; i++) {

            workers[i*3].start();

            workers[i*3+1].start();

            workers[i*3+2].start();

        }

        l.await();

        for (int i=0; i<NUM*3; i++) {

            workers[i].join();

        }

        if (failed) {

        }

    }

        try {

            ByteArrayOutputStream bos = new ByteArrayOutputStream();

            int c;

            while ((c=is.read(buf)) != -1) {

            }

            bos.close();

            if (!bos.toString().equals(resp)) {

                return false;

            }

        } catch (IOException e) {

            return false;

        }

        return true;

    }

}