/*

 * Copyright (c) 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.

 */

import org.testng.annotations.Test;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.URI;

import java.net.http.HttpClient;

import java.net.http.WebSocket;

import java.net.http.WebSocket.CloseCode;

import java.nio.ByteBuffer;

import java.nio.channels.SocketChannel;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.TimeUnit;

import java.util.function.Consumer;

import java.util.stream.Stream;

/*

 * @test

 * @bug 8087113

 * @build TestKit

 * @run testng/othervm BasicWebSocketAPITest

 */

public class BasicWebSocketAPITest {

    @Test

    public void webSocket() throws Exception {

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(IllegalArgumentException.class,

                                "(?i).*\\bnegative\\b.*",

                                () -> ws.request(-1))

        );

        checkAndClose((ws) ->

                TestKit.assertNotThrows(() -> ws.request(0))

        );

        checkAndClose((ws) ->

                TestKit.assertNotThrows(() -> ws.request(1))

        );

        checkAndClose((ws) ->

                TestKit.assertNotThrows(() -> ws.request(Long.MAX_VALUE))

        );

        checkAndClose((ws) ->

                TestKit.assertNotThrows(ws::isClosed)

        );

        checkAndClose((ws) ->

                TestKit.assertNotThrows(ws::getSubprotocol)

        );

        checkAndClose(

                (ws) -> {

                    try {

                        ws.abort();

                    } catch (IOException ignored) { }

                    // No matter what happens during the first abort invocation,

                    // other invocations must return normally

                    TestKit.assertNotThrows(ws::abort);

                    TestKit.assertNotThrows(ws::abort);

                }

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "message",

                                () -> ws.sendBinary((byte[]) null, true))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "message",

                                () -> ws.sendBinary((ByteBuffer) null, true))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "message",

                                () -> ws.sendPing(null))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "message",

                                () -> ws.sendPong(null))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "message",

                                () -> ws.sendText((CharSequence) null, true))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "message",

                                () -> ws.sendText((CharSequence) null))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "message",

                                () -> ws.sendText((Stream<? extends CharSequence>) null))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "code",

                                () -> ws.sendClose(null, ""))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertNotThrows(

                                () -> ws.sendClose(CloseCode.NORMAL_CLOSURE, ""))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "reason",

                                () -> ws.sendClose(CloseCode.NORMAL_CLOSURE, null))

        );

        checkAndClose(

                (ws) ->

                        TestKit.assertThrows(NullPointerException.class,

                                "code|reason",

                                () -> ws.sendClose(null, null))

        );

    }

    @Test

    public void builder() {

        URI ws = URI.create("ws://localhost:9001");

        // FIXME: check all 24 cases:

        // {null, ws, wss, incorrect} x {null, HttpClient.getDefault(), custom} x {null, listener}

        //

        // if (any null) or (any incorrect)

        //     NPE or IAE is thrown

        // else

        //     builder is created

        TestKit.assertThrows(NullPointerException.class,

                "uri",

                () -> WebSocket.newBuilder(null, defaultListener())

        );

        TestKit.assertThrows(NullPointerException.class,

                "listener",

                () -> WebSocket.newBuilder(ws, null)

        );

        URI uri = URI.create("ftp://localhost:9001");

        TestKit.assertThrows(IllegalArgumentException.class,

                "(?i).*\\buri\\b\\s+\\bscheme\\b.*",

                () -> WebSocket.newBuilder(uri, defaultListener())

        );

        TestKit.assertNotThrows(

                () -> WebSocket.newBuilder(ws, defaultListener())

        );

        URI uri1 = URI.create("wss://localhost:9001");

        TestKit.assertNotThrows(

                () -> WebSocket.newBuilder(uri1, defaultListener())

        );

        URI uri2 = URI.create("wss://localhost:9001#a");

        TestKit.assertThrows(IllegalArgumentException.class,

                "(?i).*\\bfragment\\b.*",

                () -> WebSocket.newBuilder(uri2, HttpClient.getDefault(), defaultListener())

        );

        TestKit.assertThrows(NullPointerException.class,

                "uri",

                () -> WebSocket.newBuilder(null, HttpClient.getDefault(), defaultListener())

        );

        TestKit.assertThrows(NullPointerException.class,

                "client",

                () -> WebSocket.newBuilder(ws, null, defaultListener())

        );

        TestKit.assertThrows(NullPointerException.class,

                "listener",

                () -> WebSocket.newBuilder(ws, HttpClient.getDefault(), null)

        );

        // FIXME: check timeout works

        // (i.e. it directly influences the time WebSocket waits for connection + opening handshake)

        TestKit.assertNotThrows(

                () -> WebSocket.newBuilder(ws, defaultListener()).connectTimeout(1, TimeUnit.SECONDS)

        );

        WebSocket.Builder builder = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                "(?i).*\\bnegative\\b.*",

                () -> builder.connectTimeout(-1, TimeUnit.SECONDS)

        );

        WebSocket.Builder builder1 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(NullPointerException.class,

                "unit",

                () -> builder1.connectTimeout(1, null)

        );

        // FIXME: check these headers are actually received by the server

        TestKit.assertNotThrows(

                () -> WebSocket.newBuilder(ws, defaultListener()).header("a", "b")

        );

        TestKit.assertNotThrows(

                () -> WebSocket.newBuilder(ws, defaultListener()).header("a", "b").header("a", "b")

        );

        // FIXME: check all 18 cases:

        // {null, websocket(7), custom} x {null, custom}

        WebSocket.Builder builder2 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(NullPointerException.class,

                "name",

                () -> builder2.header(null, "b")

        );

        WebSocket.Builder builder3 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(NullPointerException.class,

                "value",

                () -> builder3.header("a", null)

        );

        WebSocket.Builder builder4 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder4.header("Sec-WebSocket-Accept", "")

        );

        WebSocket.Builder builder5 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder5.header("Sec-WebSocket-Extensions", "")

        );

        WebSocket.Builder builder6 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder6.header("Sec-WebSocket-Key", "")

        );

        WebSocket.Builder builder7 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder7.header("Sec-WebSocket-Protocol", "")

        );

        WebSocket.Builder builder8 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder8.header("Sec-WebSocket-Version", "")

        );

        WebSocket.Builder builder9 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder9.header("Connection", "")

        );

        WebSocket.Builder builder10 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder10.header("Upgrade", "")

        );

        // FIXME: check 3 cases (1 arg):

        // {null, incorrect, custom}

        // FIXME: check 12 cases (2 args):

        // {null, incorrect, custom} x {(String) null, (String[]) null, incorrect, custom}

        // FIXME: check 27 cases (3 args) (the interesting part in null inside var-arg):

        // {null, incorrect, custom}^3

        // FIXME: check the server receives them in the order listed

        TestKit.assertThrows(NullPointerException.class,

                "mostPreferred",

                () -> WebSocket.newBuilder(ws, defaultListener()).subprotocols(null)

        );

        TestKit.assertThrows(NullPointerException.class,

                "lesserPreferred",

                () -> WebSocket.newBuilder(ws, defaultListener()).subprotocols("a", null)

        );

        TestKit.assertThrows(NullPointerException.class,

                "lesserPreferred\\[0\\]",

                () -> WebSocket.newBuilder(ws, defaultListener()).subprotocols("a", null, "b")

        );

        TestKit.assertThrows(NullPointerException.class,

                "lesserPreferred\\[1\\]",

                () -> WebSocket.newBuilder(ws, defaultListener()).subprotocols("a", "b", null)

        );

        TestKit.assertNotThrows(

                () -> WebSocket.newBuilder(ws, defaultListener()).subprotocols("a")

        );

        TestKit.assertNotThrows(

                () -> WebSocket.newBuilder(ws, defaultListener()).subprotocols("a", "b", "c")

        );

        WebSocket.Builder builder11 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder11.subprotocols("")

        );

        WebSocket.Builder builder12 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder12.subprotocols("a", "a")

        );

        WebSocket.Builder builder13 = WebSocket.newBuilder(ws, defaultListener());

        TestKit.assertThrows(IllegalArgumentException.class,

                () -> builder13.subprotocols("a" + ((char) 0x7f))

        );

    }

    private static WebSocket.Listener defaultListener() {

        return new WebSocket.Listener() { };

    }

    //

    // Automatically closes everything after the check has been performed

    //

    private static void checkAndClose(Consumer<? super WebSocket> c) {

        HandshakePhase HandshakePhase

                = new HandshakePhase(new InetSocketAddress("127.0.0.1", 0));

        URI serverURI = HandshakePhase.getURI();

        CompletableFuture<SocketChannel> cfc = HandshakePhase.afterHandshake();

        WebSocket.Builder b = WebSocket.newBuilder(serverURI, defaultListener());

        CompletableFuture<WebSocket> cfw = b.buildAsync();

        try {

            WebSocket ws;

            try {

                ws = cfw.get();

            } catch (Exception e) {

                throw new RuntimeException(e);

            }

            c.accept(ws);

        } finally {

            try {

                SocketChannel now = cfc.getNow(null);

                if (now != null) {

                    now.close();

                }

            } catch (Throwable ignored) { }

        }

    }

}