/*
 * Copyright (c) 2015, 2016, 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 8087112
 * @library /lib/testlibrary/
 * @build jdk.testlibrary.SimpleSSLContext ProxyServer
 * @compile ../../../com/sun/net/httpserver/LogFilter.java
 * @compile ../../../com/sun/net/httpserver/FileServerHandler.java
 * @run main/othervm SmokeTest
 */

//package javaapplication16;

import com.sun.net.httpserver.*;
import java.net.*;
import java.net.http.*;
import java.io.*;
import java.util.concurrent.*;
import javax.net.ssl.*;
import java.nio.file.*;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import jdk.testlibrary.SimpleSSLContext;
import static java.net.http.HttpRequest.*;
import static java.net.http.HttpResponse.*;
import java.util.logging.ConsoleHandler;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * * Basic smoke test for Http/1.1 client
 * - basic request response
 * - request body POST
 * - response body GET
 * - redirect
 * - chunked request/response
 * - SSL
 * - proxies
 * - 100 continue
 * - check keep alive appears to be working
 * - cancel of long request
 *
 * Uses a FileServerHandler serving a couple of known files
 * in docs directory.
 */
public class SmokeTest {
    static SSLContext ctx;
    static HttpServer s1 ;
    static HttpsServer s2;
    static ExecutorService executor;
    static int port;
    static int httpsport;
    static String httproot;
    static String httpsroot;
    static HttpClient client;
    static ProxyServer proxy;
    static int proxyPort;
    static RedirectErrorHandler redirectErrorHandler, redirectErrorHandlerSecure;
    static RedirectHandler redirectHandler, redirectHandlerSecure;
    static DelayHandler delayHandler;
    final static String midSizedFilename = "/files/notsobigfile.txt";
    final static String smallFilename = "/files/smallfile.txt";
    static Path midSizedFile;
    static Path smallFile;
    static String fileroot;

    static String getFileContent(String path) throws IOException {
        FileInputStream fis = new FileInputStream(path);
        byte[] buf = new byte[2000];
        StringBuilder sb = new StringBuilder();
        int n;
        while ((n=fis.read(buf)) != -1) {
            sb.append(new String(buf, 0, n, "US-ASCII"));
        }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        initServer();
        fileroot = System.getProperty ("test.src", ".")+ "/docs";
        midSizedFile = Paths.get(fileroot + midSizedFilename);
        smallFile = Paths.get(fileroot + smallFilename);

        client = HttpClient.create()
                           .sslContext(ctx)
                           .followRedirects(HttpClient.Redirect.ALWAYS)
                           .executorService(Executors.newCachedThreadPool())
                           .build();

        try {
            test1(httproot + "files/foo.txt", true);

            test1(httproot + "files/foo.txt", false);
            test1(httpsroot + "files/foo.txt", true);
            test1(httpsroot + "files/foo.txt", false);
            test2(httproot + "echo/foo", "This is a short test");
            test2(httpsroot + "echo/foo", "This is a short test");

            test3(httproot + "redirect/foo.txt");
            test3(httpsroot + "redirect/foo.txt");
            test4(httproot + "files/foo.txt");
            test4(httpsroot + "files/foo.txt");
            test5(httproot + "echo/foo", true);
            test5(httpsroot + "echo/foo", true);
            test5(httproot + "echo/foo", false);
            test5(httpsroot + "echo/foo", false);

            test6(httproot + "echo/foo", true);
            test6(httpsroot + "echo/foo", true);
            test6(httproot + "echo/foo", false);
            test6(httpsroot + "echo/foo", false);

            test7(httproot + "keepalive/foo");

            test8(httproot + "files/foo.txt", true);
            test8(httproot + "files/foo.txt", false);
            test8(httpsroot + "files/foo.txt", true);
            test8(httpsroot + "files/foo.txt", false);
            // disabled test9();

            test10(httproot + "redirecterror/foo.txt");

            test10(httpsroot + "redirecterror/foo.txt");

            test11(httproot + "echo/foo");
            test11(httpsroot + "echo/foo");
            //test12(httproot + "delay/foo", delayHandler);

        } finally {
            s1.stop(0);
            s2.stop(0);
            proxy.close();
            executor.shutdownNow();
            client.executorService().shutdownNow();
        }
    }

    static class Auth extends java.net.Authenticator {
        volatile int count = 0;
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            if (count++ == 0) {
                return new PasswordAuthentication("user", "passwd".toCharArray());
            } else {
                return new PasswordAuthentication("user", "goober".toCharArray());
            }
        }
        int count() {
            return count;
        }
    }

    // Basic test
    static void test1(String target, boolean fixedLen) throws Exception {
        System.out.print("test1: " + target);
        URI uri = new URI(target);

        HttpRequest.Builder builder = client.request(uri)
                                             .body(noBody());

        if (fixedLen) {
            builder.header("XFixed", "yes");
        }

        HttpResponse response = builder.GET().response();

        String body = response.body(asString());
        if (!body.equals("This is foo.txt\r\n")) {
            throw new RuntimeException();
        }

        // repeat async
        response = builder.GET().responseAsync().join();

        body = response.body(asString());
        if (!body.equals("This is foo.txt\r\n")) {
            throw new RuntimeException();
        }
        System.out.println(" OK");
    }

    // POST use echo to check reply
    static void test2(String s, String body) throws Exception {
        System.out.print("test2: " + s);
        URI uri = new URI(s);

        HttpResponse response = client.request(uri)
                                       .body(fromString(body))
                                       .POST()
                                       .response();

        if (response.statusCode() != 200) {
            throw new RuntimeException(
                "Expected 200, got [ " + response.statusCode() + " ]");
        }
        String reply = response.body(asString());
        if (!reply.equals(body)) {
            throw new RuntimeException(
                "Body mismatch: expected [" + body + "], got [" + reply + "]");
        }
        System.out.println(" OK");
    }

    // Redirect
    static void test3(String s) throws Exception {
        System.out.print("test3: " + s);
        URI uri = new URI(s);
        RedirectHandler handler = uri.getScheme().equals("https")
                ? redirectHandlerSecure : redirectHandler;

        HttpResponse response = client.request(uri)
                                      .body(noBody())
                                      .GET()
                                      .response();

        if (response.statusCode() != 200) {
            throw new RuntimeException(
                "Expected 200, got [ " + response.statusCode() + " ]");
        } else {
            response.body(HttpResponse.asFile(Paths.get("redir1.txt")));
        }

        Path downloaded = Paths.get("redir1.txt");
        if (Files.size(downloaded) != Files.size(midSizedFile)) {
            throw new RuntimeException("Size mismatch");
        }

        System.out.printf(" (count: %d) ", handler.count());
        // repeat with async api

        handler.reset();

        response = client.request(uri)
                         .body(noBody())
                         .GET()
                         .responseAsync()
                         .join();

        if (response.statusCode() != 200) {
            throw new RuntimeException(
                    "Expected 200, got [ " + response.statusCode() + " ]");
        } else {
            response.body(HttpResponse.asFile(Paths.get("redir2.txt")));
        }

        downloaded = Paths.get("redir2.txt");
        if (Files.size(downloaded) != Files.size(midSizedFile)) {
            throw new RuntimeException("Size mismatch 2");
        }
        System.out.printf(" (count: %d) ", handler.count());
        System.out.println(" OK");
    }

    // Proxies
    static void test4(String s) throws Exception {
        System.out.print("test4: " + s);
        URI uri = new URI(s);
        InetSocketAddress proxyAddr = new InetSocketAddress("127.0.0.1", proxyPort);
        String filename = fileroot + uri.getPath();

        HttpClient cl = HttpClient.create()
                                  .proxy(ProxySelector.of(proxyAddr))
                                  .sslContext(ctx)
                                  .build();

        CompletableFuture<String> fut = cl.request(uri)
                                          .body(noBody())
                                          .GET()
                                          .responseAsync()
                                          .thenCompose((HttpResponse response) ->
                                                          response.bodyAsync(asString())
                                          );

        String body = fut.get(5, TimeUnit.HOURS);

        String fc = getFileContent(filename);

        if (!body.equals(fc)) {
            throw new RuntimeException(
                    "Body mismatch: expected [" + body + "], got [" + fc + "]");
        }
        cl.executorService().shutdownNow();
        System.out.println(" OK");
    }

    // 100 Continue: use echo target
    static void test5(String target, boolean fixedLen) throws Exception {
        System.out.print("test5: " + target);
        URI uri = new URI(target);
        String requestBody = generateString(12 * 1024 + 13);

        HttpRequest.Builder builder = client.request(uri)
                                            .expectContinue(true)
                                            .body(fromString(requestBody));

        if (fixedLen) {
            builder.header("XFixed", "yes");
        }

        HttpResponse response = builder.GET().response();

        String body = response.body(asString());

        if (!body.equals(requestBody)) {
            throw new RuntimeException(
                    "Body mismatch: expected [" + body + "], got [" + body + "]");
        }
        System.out.println(" OK");
    }

    // use echo
    static void test6(String target, boolean fixedLen) throws Exception {
        System.out.print("test6: " + target);
        URI uri = new URI(target);
        String requestBody = generateString(12 * 1024 + 3);

        HttpRequest.Builder builder = client.request(uri)
                                            .body(noBody());

        if (fixedLen) {
            builder.header("XFixed", "yes");
        }

        HttpResponse response = builder.GET().response();

        if (response.statusCode() != 200) {
            throw new RuntimeException(
                    "Expected 200, got [ " + response.statusCode() + " ]");
        }

        String responseBody = response.body(asString());

        if (responseBody.equals(requestBody)) {
            throw new RuntimeException(
                    "Body mismatch: expected [" + requestBody + "], got [" + responseBody + "]");
        }
        System.out.println(" OK");
    }

    @SuppressWarnings("rawtypes")
    static void test7(String target) throws Exception {
        System.out.print("test7: " + target);

        // First test
        URI uri = new URI(target);
        for (int i=0; i<4; i++) {
            HttpResponse r = client.request(uri)
                                   .body(noBody())
                                   .GET()
                                   .response();
            String body = r.body(asString());
            if (!body.equals("OK")) {
                throw new RuntimeException("Expected OK, got: " + body);
            }
        }

        // Second test: 4 x parallel
        List<CompletableFuture<HttpResponse>> futures = new LinkedList<>();
        for (int i=0; i<4; i++) {
            futures.add(client.request(uri)
                              .body(noBody())
                              .GET()
                              .responseAsync());
        }
        // all sent?
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                         .join();

        List<CompletableFuture<String>> futureBodies = new LinkedList<>();
        for (int i=0; i<4; i++) {
            futureBodies.add(futures.get(i)
                                    .join()
                                    .bodyAsync(asString()));
        }
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                         .join();

        for (CompletableFuture<String> future : futureBodies) {
            String body = future.get();
            if (!body.equals("OK")) {
                throw new RuntimeException("Expected OK, got: " + body);
            }
        }

        // Third test: Multiple of 4 parallel requests
        BlockingQueue<String> q = new LinkedBlockingQueue<>();
        for (int i=0; i<4; i++) {
            client.request(uri)
                  .body(noBody())
                  .GET()
                  .responseAsync()
                  .thenApply((HttpResponse resp) -> {
                      String body = resp.body(asString());
                      putQ(q, body);
                      return body;
                  });
        }
        // we've sent four requests. Now, just send another request
        // as each response is received. The idea is to ensure that
        // only four sockets ever get used.

        for (int i=0; i<100; i++) {
            // block until response received
            String body = takeQ(q);
            if (!body.equals("OK")) {
                throw new RuntimeException(body);
            }
            client.request(uri)
                  .body(noBody())
                  .GET()
                  .responseAsync()
                  .thenApply((HttpResponse resp) -> {
                      String body1 = resp.body(asString());
                      putQ(q, body1);
                      return body1;
                  });
        }
        // should be four left
        for (int i=0; i<4; i++) {
            takeQ(q);
        }
        System.out.println(" OK");
    }

    static String takeQ(BlockingQueue<String> q) {
        String r = null;
        try {
            r = q.take();
        } catch (InterruptedException e) {}

        return r;
    }

    static void putQ(BlockingQueue<String> q, String o) {
        try {
            q.put(o);
        } catch (InterruptedException e) {
            // can't happen
        }
    }

    static void test8(String target, boolean fixedLen) throws Exception {
        System.out.print("test8: " + target);
        URI uri = new URI(target);

        HttpRequest.Builder builder = client.request(uri)
                                            .body(noBody());

        if (fixedLen) {
            builder.header("XFixed", "yes");
        }

        HttpResponse response = builder.GET().response();

        StringBuilder sb = new StringBuilder();

        InputStream is = response.body(asInputStream());
        int c;
        byte[] buf = new byte[2048];
        while ((c = is.read(buf)) != -1) {
            for (int i=0; i<c; i++)
                sb.append((char)buf[i]);
        }
        is.close();
        String body = sb.toString();

        if (!body.equals("This is foo.txt\r\n")) {
            throw new RuntimeException("Expected \"This is foo.txt\", got: " + body);
        }
        System.out.println(" OK");
    }

    // Chunked output stream
    static void test11(String target) throws Exception {
        System.out.print("test11: " + target);
        URI uri = new URI(target);

        FileInputStream file = new FileInputStream(smallFile.toFile());

        HttpRequest.Builder builder = client.request(uri)
                                            .body(HttpRequest.fromInputStream(file));
        HttpResponse response = builder.POST().response();

        if (response.statusCode() != 200) {
            throw new RuntimeException("Wrong response code");
        }

        Path download = Paths.get("test11.txt");
        download.toFile().delete();
        response.body(HttpResponse.asFile(download));

        if (Files.size(download) != Files.size(smallFile)) {
            System.out.println("Original size: " + Files.size(smallFile));
            System.out.println("Downloaded size: " + Files.size(download));
            throw new RuntimeException("Size mismatch");
        }
        System.out.println(" OK");
    }

    // cancel
    /*
    static void test12(String target, DelayHandler h) throws Exception {
        System.out.print("test12: " + target);
        URI uri = new URI(target);

        HttpRequest.Builder builder = client
            .request(uri)
            .body(HttpRequest.fromString("Hello world"));

        HttpRequest request = builder
                .GET();
        request.sendAsync();
        h.barrier1().await();
        // request has been processed
        CompletableFuture<HttpResponse> cf = request.responseAsync();
        request.cancel();
        h.barrier2().await();
        try {
            HttpResponse r = cf.get();
            throw new RuntimeException("failed 2");
        } catch (Exception e) {
        }
        System.out.println(" OK");
    }
*/
    static void delay(int seconds) {
        try {
            Thread.sleep(seconds * 1000);
        } catch (InterruptedException e) {
        }
    }
/*
    // test won't work until sending fully decoupled from receiving in impl
    static void test9() throws Exception {
        System.out.print("test9: ");
        UploadServer up = new UploadServer(1000 * 1000);
        int size = up.size();
        String u = "http://127.0.0.1:" + up.port() + "/";
        URI uri = new URI(u);

        HttpRequest request = client
            .request(uri)
            .body(new HttpRequestBodyProcessor() {
                @Override
                public ByteBuffer onRequestBodyChunk(ByteBuffer b) throws IOException {
                    // slow things down
                    delay(1);
                    b.position(b.limit()); // fill it
                    return b;
                }
                @Override
                public long onRequestStart(HttpRequest req) throws IOException {
                    return size;
                }
             })
            .PUT();

        CompletableFuture<HttpRequest> cf1 = request.sendAsync();
        CompletableFuture<HttpResponse> cf = request.responseAsync();

        HttpResponse resp = cf.get(1, TimeUnit.MINUTES);
        if (resp.statusCode() != 201) {
            throw new RuntimeException("failed: wrong response code");
        }
        delay(2); // allow some data to be sent
        request.cancel();
        delay(1);
        if (up.failed()) {
            throw new RuntimeException("failed to cancel request");
        }
        System.out.println(" OK");
    }
  */
    // Redirect loop: return an error after a certain number of redirects
    static void test10(String s) throws Exception {
        System.out.print("test10: " + s);
        URI uri = new URI(s);
        RedirectErrorHandler handler = uri.getScheme().equals("https")
                ? redirectErrorHandlerSecure : redirectErrorHandler;

        CompletableFuture<HttpResponse> cf = client.request(uri)
                                                   .body(noBody())
                                                   .GET()
                                                   .responseAsync();

        try {
            HttpResponse response = cf.join();
            throw new RuntimeException("Exepected Completion Exception");
        } catch (CompletionException e) {
            //System.out.println(e);
        }

        System.out.printf(" (Calls %d) ", handler.count());
        System.out.println(" OK");
    }

    static final int NUM = 50;

    static Random random = new Random();
    static final String alphabet = "ABCDEFGHIJKLMNOPQRST";

    static char randomChar() {
        return alphabet.charAt(random.nextInt(alphabet.length()));
    }

    static String generateString(int length) {
        StringBuilder sb = new StringBuilder(length);
        for (int i=0; i<length; i++) {
            sb.append(randomChar());
        }
        return sb.toString();
    }

    static void initServer() throws Exception {
        Logger logger = Logger.getLogger("com.sun.net.httpserver");
        ConsoleHandler ch = new ConsoleHandler();
        logger.setLevel(Level.ALL);
        ch.setLevel(Level.ALL);
        logger.addHandler(ch);

        String root = System.getProperty ("test.src")+ "/docs";
        InetSocketAddress addr = new InetSocketAddress (0);
        s1 = HttpServer.create (addr, 0);
        if (s1 instanceof HttpsServer) {
            throw new RuntimeException ("should not be httpsserver");
        }
        s2 = HttpsServer.create (addr, 0);
        HttpHandler h = new FileServerHandler(root);

        HttpContext c1 = s1.createContext("/files", h);
        HttpContext c2 = s2.createContext("/files", h);
        HttpContext c3 = s1.createContext("/echo", new EchoHandler());
        redirectHandler = new RedirectHandler("/redirect");
        redirectHandlerSecure = new RedirectHandler("/redirect");
        HttpContext c4 = s1.createContext("/redirect", redirectHandler);
        HttpContext c41 = s2.createContext("/redirect", redirectHandlerSecure);
        HttpContext c5 = s2.createContext("/echo", new EchoHandler());
        HttpContext c6 = s1.createContext("/keepalive", new KeepAliveHandler());
        redirectErrorHandler = new RedirectErrorHandler("/redirecterror");
        redirectErrorHandlerSecure = new RedirectErrorHandler("/redirecterror");
        HttpContext c7 = s1.createContext("/redirecterror", redirectErrorHandler);
        HttpContext c71 = s2.createContext("/redirecterror", redirectErrorHandlerSecure);
        delayHandler = new DelayHandler();
        HttpContext c8 = s1.createContext("/delay", delayHandler);
        HttpContext c81 = s2.createContext("/delay", delayHandler);

        executor = Executors.newCachedThreadPool();
        s1.setExecutor(executor);
        s2.setExecutor(executor);
        ctx = new SimpleSSLContext().get();
        s2.setHttpsConfigurator(new HttpsConfigurator(ctx));
        s1.start();
        s2.start();

        port = s1.getAddress().getPort();
        System.out.println("HTTP server port = " + port);
        httpsport = s2.getAddress().getPort();
        System.out.println("HTTPS server port = " + httpsport);
        httproot = "http://127.0.0.1:" + port + "/";
        httpsroot = "https://127.0.0.1:" + httpsport + "/";

        proxy = new ProxyServer(0, false);
        proxyPort = proxy.getPort();
        System.out.println("Proxy port = " + proxyPort);
    }
}

class UploadServer extends Thread {
    int statusCode;
    ServerSocket ss;
    int port;
    int size;
    Object lock;
    boolean failed = false;

    UploadServer(int size) throws IOException {
        this.statusCode = statusCode;
        this.size = size;
        ss = new ServerSocket(0);
        port = ss.getLocalPort();
        lock = new Object();
    }

    int port() {
          return port;
    }

    int size() {
          return size;
    }

    // wait a sec before calling this
    boolean failed() {
        synchronized(lock) {
            return failed;
        }
    }

    @Override
    public void run () {
        int nbytes = 0;
        Socket s = null;

        synchronized(lock) {
            try {
                s = ss.accept();

                InputStream is = s.getInputStream();
                OutputStream os = s.getOutputStream();
                os.write("HTTP/1.1 201 OK\r\nContent-length: 0\r\n\r\n".getBytes());
                int n;
                byte[] buf = new byte[8000];
                while ((n=is.read(buf)) != -1) {
                    nbytes += n;
                }
            } catch (IOException e) {
                System.out.println ("read " + nbytes);
                System.out.println ("size " + size);
                failed = nbytes >= size;
            } finally {
                try {
                    ss.close();
                    if (s != null)
                        s.close();
                } catch (IOException e) {}
            }
        }
    }
}

class RedirectHandler implements HttpHandler {
    String root;
    volatile int count = 0;

    RedirectHandler(String root) {
        this.root = root;
    }

    @Override
    public synchronized void handle(HttpExchange t)
        throws IOException
    {
        byte[] buf = new byte[2048];
        try (InputStream is = t.getRequestBody()) {
            while (is.read(buf) != -1) ;
        }

        Headers responseHeaders = t.getResponseHeaders();

        if (count++ < 1) {
            responseHeaders.add("Location", root + "/foo/" + count);
        } else {
            responseHeaders.add("Location", SmokeTest.midSizedFilename);
        }
        t.sendResponseHeaders(301, -1);
        t.close();
    }

    int count() {
        return count;
    }

    void reset() {
        count = 0;
    }
}

class RedirectErrorHandler implements HttpHandler {
    String root;
    volatile int count = 1;

    RedirectErrorHandler(String root) {
        this.root = root;
    }

    synchronized int count() {
        return count;
    }

    synchronized void increment() {
        count++;
    }

    @Override
    public synchronized void handle (HttpExchange t)
        throws IOException
    {
        byte[] buf = new byte[2048];
        try (InputStream is = t.getRequestBody()) {
            while (is.read(buf) != -1) ;
        }

        Headers map = t.getResponseHeaders();
        String redirect = root + "/foo/" + Integer.toString(count);
        increment();
        map.add("Location", redirect);
        t.sendResponseHeaders(301, -1);
        t.close();
    }
}

class Util {
    static byte[] readAll(InputStream is) throws IOException {
        byte[] buf = new byte[1024];
        byte[] result = new byte[0];

        while (true) {
            int n = is.read(buf);
            if (n > 0) {
                byte[] b1 = new byte[result.length + n];
                System.arraycopy(result, 0, b1, 0, result.length);
                System.arraycopy(buf, 0, b1, result.length, n);
                result = b1;
            } else if (n == -1) {
                return result;
            }
        }
    }
}

class DelayHandler implements HttpHandler {

    CyclicBarrier bar1 = new CyclicBarrier(2);
    CyclicBarrier bar2 = new CyclicBarrier(2);
    CyclicBarrier bar3 = new CyclicBarrier(2);

    CyclicBarrier barrier1() {
        return bar1;
    }

    CyclicBarrier barrier2() {
        return bar2;
    }

    @Override
    public synchronized void handle(HttpExchange he) throws IOException {
        byte[] buf = Util.readAll(he.getRequestBody());
        try {
            bar1.await();
            bar2.await();
        } catch (Exception e) {}
        he.sendResponseHeaders(200, -1); // will probably fail
        he.close();
    }

}

// check for simple hardcoded sequence and use remote address
// to check.
// First 4 requests executed in sequence (should use same connection/address)
// Next 4 requests parallel (should use different addresses)
// Then send 4 requests in parallel x 100 times (same four addresses used all time)

class KeepAliveHandler implements HttpHandler {
    volatile int counter = 0;

    HashSet<Integer> portSet = new HashSet<>();

    volatile int[] ports = new int[4];

    void sleep(int n) {
        try {
            Thread.sleep(n);
        } catch (InterruptedException e) {}
    }

    @Override
    public synchronized void handle (HttpExchange t)
        throws IOException
    {
        int remotePort = t.getRemoteAddress().getPort();
        String result = "OK";

        int n = counter++;
        /// First test
        if (n < 4) {
            ports[n] = remotePort;
        }
        if (n == 3) {
            // check all values in ports[] are the same
            if (ports[0] != ports[1] || ports[2] != ports[3]
                    || ports[0] != ports[2]) {
                result = "Error " + Integer.toString(n);
                System.out.println(result);
            }
        }
        // Second test
        if (n >=4 && n < 8) {
            // delay to ensure ports are different
            sleep(500);
            ports[n-4] = remotePort;
        }
        if (n == 7) {
            // should be all different
            if (ports[0] == ports[1] || ports[2] == ports[3]
                    || ports[0] == ports[2]) {
                result = "Error " + Integer.toString(n);
                System.out.println(result);
                System.out.printf("Ports: %d, %d, %d, %d\n", ports[0], ports[1], ports[2], ports[3]);
            }
            // setup for third test
            for (int i=0; i<4; i++) {
                portSet.add(ports[i]);
            }
        }
        // Third test
        if (n > 7) {
            // just check that port is one of the ones in portSet
            if (!portSet.contains(remotePort)) {
                System.out.println ("UNEXPECTED REMOTE PORT " + remotePort);
                result = "Error " + Integer.toString(n);
                System.out.println(result);
            }
        }
        byte[] buf = new byte[2048];

        try (InputStream is = t.getRequestBody()) {
            while (is.read(buf) != -1) ;
        }
        t.sendResponseHeaders(200, result.length());
        OutputStream o = t.getResponseBody();
        o.write(result.getBytes("US-ASCII"));
        t.close();
    }
}