/*

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

 * @requires os.family != "solaris"

 * @summary Tests for Basic tests for REPL tool

 * @library /tools/lib

 * @ignore 8139873

 * @build KullaTesting TestingInputStream ToolBox Compiler

 * @run testng/timeout=600 ToolBasicTest

 */

import java.io.FileInputStream;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Scanner;

import java.util.function.BiFunction;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.prefs.BackingStoreException;

import java.util.prefs.Preferences;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import org.testng.annotations.Test;

import static org.testng.Assert.assertEquals;

import static org.testng.Assert.assertTrue;

import static org.testng.Assert.fail;

@Test

public class ToolBasicTest extends ReplToolTesting {

    public void defineVar() {

        test(

                (a) -> assertCommand(a, "int x = 72", "|  Added variable x of type int with initial value 72\n"),

                (a) -> assertCommand(a, "x", "|  Variable x of type int has value 72\n"),

                (a) -> assertCommand(a, "/vars", "|    int x = 72\n")

        );

    }

    public void defineUnresolvedVar() {

        test(

                (a) -> assertCommand(a, "undefined x",

                        "|  Added variable x, however, it cannot be referenced until class undefined is declared\n"),

                (a) -> assertCommand(a, "/vars", "|    undefined x = (not-active)\n")

        );

    }

    public void testUnresolved() {

        test(

                (a) -> assertCommand(a, "int f() { return g() + x + new A().a; }",

                        "|  Added method f(), however, it cannot be invoked until method g(), variable x, and class A are declared\n"),

                (a) -> assertCommand(a, "f()",

                        "|  Attempted to call f which cannot be invoked until method g(), variable x, and class A are declared\n"),

                (a) -> assertCommand(a, "int g() { return x; }",

                        "|  Added method g(), however, it cannot be invoked until variable x is declared\n"),

                (a) -> assertCommand(a, "g()", "|  Attempted to call g which cannot be invoked until variable x is declared\n")

        );

    }

    public void elideStartUpFromList() {

        test(

                (a) -> assertCommandCheckOutput(a, "123", (s) ->

                        assertTrue(s.contains("type int"), s)),

                (a) -> assertCommandCheckOutput(a, "/list", (s) -> {

                    int cnt;

                    try (Scanner scanner = new Scanner(s)) {

                        cnt = 0;

                        while (scanner.hasNextLine()) {

                            String line = scanner.nextLine();

                            if (!line.trim().isEmpty()) {

                                ++cnt;

                            }

                        }

                    }

                    assertEquals(cnt, 1, "Expected only one listed line");

                })

        );

    }

    public void elideStartUpFromSave() throws IOException {

        Compiler compiler = new Compiler();

        Path path = compiler.getPath("myfile");

        test(

                (a) -> assertCommandCheckOutput(a, "123",

                        (s) -> assertTrue(s.contains("type int"), s)),

                (a) -> assertCommand(a, "/save " + path.toString(), "")

        );

        try (Stream<String> lines = Files.lines(path)) {

            assertEquals(lines.count(), 1, "Expected only one saved line");

        }

    }

    public void testInterrupt() {

        ReplTest interrupt = (a) -> assertCommand(a, "\u0003", "");

        for (String s : new String[] { "", "\u0003" }) {

            test(false, new String[]{"-nostartup"},

                    (a) -> assertCommand(a, "int a = 2 +" + s, ""),

                    interrupt,

                    (a) -> assertCommand(a, "int a\u0003", ""),

                    (a) -> assertCommand(a, "int a = 2 + 2\u0003", ""),

                    (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),

                    (a) -> evaluateExpression(a, "int", "2", "2"),

                    (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),

                    (a) -> assertCommand(a, "void f() {", ""),

                    (a) -> assertCommand(a, "int q = 10;" + s, ""),

                    interrupt,

                    (a) -> assertCommand(a, "void f() {}\u0003", ""),

                    (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                    (a) -> assertMethod(a, "int f() { return 0; }", "()int", "f"),

                    (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                    (a) -> assertCommand(a, "class A {" + s, ""),

                    interrupt,

                    (a) -> assertCommand(a, "class A {}\u0003", ""),

                    (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                    (a) -> assertClass(a, "interface A {}", "interface", "A"),

                    (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                    (a) -> assertCommand(a, "import java.util.stream." + s, ""),

                    interrupt,

                    (a) -> assertCommand(a, "import java.util.stream.\u0003", ""),

                    (a) -> assertCommandCheckOutput(a, "/imports", assertImports()),

                    (a) -> assertImport(a, "import java.util.stream.Stream", "", "java.util.stream.Stream"),

                    (a) -> assertCommandCheckOutput(a, "/imports", assertImports())

            );

        }

    }

    private final Object lock = new Object();

    private PrintWriter out;

    private boolean isStopped;

    private Thread t;

    private void assertStop(boolean after, String cmd, String output) {

        if (!after) {

            isStopped = false;

            StringWriter writer = new StringWriter();

            out = new PrintWriter(writer);

            setCommandInput(cmd + "\n");

            t = new Thread(() -> {

                try {

                    // no chance to know whether cmd is being evaluated

                    Thread.sleep(5000);

                } catch (InterruptedException ignored) {

                }

                int i = 1;

                int n = 30;

                synchronized (lock) {

                    do {

                        setCommandInput("\u0003");

                        if (!isStopped) {

                            out.println("Not stopped. Try again: " + i);

                            try {

                                lock.wait(1000);

                            } catch (InterruptedException ignored) {

                            }

                        }

                    } while (i++ < n && !isStopped);

                    if (!isStopped) {

                        System.err.println(writer.toString());

                        fail("Evaluation was not stopped: '" + cmd + "'");

                    }

                }

            });

            t.start();

        } else {

            synchronized (lock)  {

                out.println("Evaluation was stopped successfully: '" + cmd + "'");

                isStopped = true;

                lock.notify();

            }

            try {

                t.join();

                t = null;

            } catch (InterruptedException ignored) {

            }

            assertOutput(getCommandOutput(), "", "command");

            assertOutput(getCommandErrorOutput(), "", "command error");

            assertOutput(getUserOutput(), output, "user");

            assertOutput(getUserErrorOutput(), "", "user error");

        }

    }

    public void testStop() {

        test(

                (a) -> assertStop(a, "while (true) {}", "Killed.\n"),

                (a) -> assertStop(a, "while (true) { try { Thread.sleep(100); } catch (InterruptedException ex) { } }", "Killed.\n")

        );

    }

    @Test(enabled = false) // TODO 8130450

    public void testRerun() {

        test(false, new String[] {"-nostartup"},

                (a) -> assertCommand(a, "/0", "|  No such command or snippet id: /0\n|  Type /help for help.\n"),

                (a) -> assertCommand(a, "/5", "|  No such command or snippet id: /5\n|  Type /help for help.\n")

        );

        String[] codes = new String[] {

                "int a = 0;", // var

                "class A {}", // class

                "void f() {}", // method

                "bool b;", // active failed

                "void g() { h(); }", // active corralled

        };

        List<ReplTest> tests = new ArrayList<>();

        for (String s : codes) {

            tests.add((a) -> assertCommand(a, s, null));

        }

        for (int i = 0; i < codes.length; ++i) {

            final int finalI = i;

            Consumer<String> check = (s) -> {

                String[] ss = s.split("\n");

                assertEquals(ss[0], codes[finalI]);

                assertTrue(ss.length > 1, s);

            };

            tests.add((a) -> assertCommandCheckOutput(a, "/" + (finalI + 1), check));

        }

        for (int i = 0; i < codes.length; ++i) {

            final int finalI = i;

            Consumer<String> check = (s) -> {

                String[] ss = s.split("\n");

                assertEquals(ss[0], codes[codes.length - finalI - 1]);

                assertTrue(ss.length > 1, s);

            };

            tests.add((a) -> assertCommandCheckOutput(a, "/-" + (finalI + 1), check));

        }

        tests.add((a) -> assertCommandCheckOutput(a, "/!", assertStartsWith("void g() { h(); }")));

        test(false, new String[]{"-nostartup"},

                tests.toArray(new ReplTest[tests.size()]));

    }

    public void test8142447() {

        Function<String, BiFunction<String, Integer, ReplTest>> assertRerun = cmd -> (code, assertionCount) ->

                (a) -> assertCommandCheckOutput(a, cmd, s -> {

                            String[] ss = s.split("\n");

                            assertEquals(ss[0], code);

                            loadVariable(a, "int", "assertionCount", Integer.toString(assertionCount), Integer.toString(assertionCount));

                        });

        ReplTest assertVariables = (a) -> assertCommandCheckOutput(a, "/v", assertVariables());

        Compiler compiler = new Compiler();

        Path startup = compiler.getPath("StartupFileOption/startup.txt");

        compiler.writeToFile(startup, "int assertionCount = 0;\n" + // id: s1

                "void add(int n) { assertionCount += n; }");

        test(new String[]{"-startup", startup.toString()},

                (a) -> assertCommand(a, "add(1)", ""), // id: 1

                (a) -> assertCommandCheckOutput(a, "add(ONE)", s -> assertEquals(s.split("\n")[0], "|  Error:")), // id: e1

                (a) -> assertVariable(a, "int", "ONE", "1", "1"),

                assertRerun.apply("/1").apply("add(1)", 2), assertVariables,

                assertRerun.apply("/e1").apply("add(ONE)", 3), assertVariables,

                assertRerun.apply("/s1").apply("int assertionCount = 0;", 0), assertVariables

        );

        test(false, new String[] {"-nostartup"},

                (a) -> assertCommand(a, "/s1", "|  No such command or snippet id: /s1\n|  Type /help for help.\n"),

                (a) -> assertCommand(a, "/1", "|  No such command or snippet id: /1\n|  Type /help for help.\n"),

                (a) -> assertCommand(a, "/e1", "|  No such command or snippet id: /e1\n|  Type /help for help.\n")

        );

    }

    public void testRemaining() {

        test(

                (a) -> assertCommand(a, "int z; z =", "|  Added variable z of type int\n"),

                (a) -> assertCommand(a, "5", "|  Variable z has been assigned the value 5\n"),

                (a) -> assertCommand(a, "/*nada*/; int q =", ""),

                (a) -> assertCommand(a, "77", "|  Added variable q of type int with initial value 77\n"),

                (a) -> assertCommand(a, "//comment;", ""),

                (a) -> assertCommand(a, "int v;", "|  Added variable v of type int\n"),

                (a) -> assertCommand(a, "int v; int c", "|  Added variable c of type int\n")

        );

    }

    public void testDebug() {

        test(

                (a) -> assertCommand(a, "/deb", "|  Debugging on\n"),

                (a) -> assertCommand(a, "/debug", "|  Debugging off\n"),

                (a) -> assertCommand(a, "/debug", "|  Debugging on\n"),

                (a) -> assertCommand(a, "/deb", "|  Debugging off\n")

        );

    }

        Consumer<String> testOutput = (s) -> {

            List<String> ss = Stream.of(s.split("\n"))

                    .filter(l -> !l.isEmpty())

                    .collect(Collectors.toList());

        };

        test(

                (a) -> assertCommandCheckOutput(a, "/?", testOutput),

        );

    }

    public void oneLineOfError() {

        test(

                (a) -> assertCommand(a, "12+", null),

                (a) -> assertCommandCheckOutput(a, "  true", (s) ->

                        assertTrue(s.contains("12+") && !s.contains("true"), "Output: '" + s + "'"))

        );

    }

    public void defineVariables() {

        test(

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),

                (a) -> assertVariable(a, "int", "a"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),

                (a) -> assertVariable(a, "double", "a", "1", "1.0"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),

                (a) -> evaluateExpression(a, "double", "2 * a", "2.0"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/vars", assertVariables())

        );

    }

    public void defineMethods() {

        test(

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                (a) -> assertMethod(a, "int f() { return 0; }", "()int", "f"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                (a) -> assertMethod(a, "void f(int a) { g(); }", "(int)void", "f"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                (a) -> assertMethod(a, "void g() {}", "()void", "g"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/methods", assertMethods())

        );

    }

    public void defineClasses() {

        test(

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                (a) -> assertClass(a, "class A { }", "class", "A"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                (a) -> assertClass(a, "interface A { }", "interface", "A"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                (a) -> assertClass(a, "enum A { }", "enum", "A"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                (a) -> assertClass(a, "@interface A { }", "@interface", "A"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/classes", assertClasses())

        );

    }

    public void defineImports() {

        test(

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/imports", assertImports()),

                (a) -> assertImport(a, "import java.util.stream.Stream;", "", "java.util.stream.Stream"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/imports", assertImports()),

                (a) -> assertImport(a, "import java.util.stream.*;", "", "java.util.stream.*"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/imports", assertImports()),

                (a) -> assertImport(a, "import static java.lang.Math.PI;", "static", "java.lang.Math.PI"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/imports", assertImports()),

                (a) -> assertImport(a, "import static java.lang.Math.*;", "static", "java.lang.Math.*"),

                (a) -> assertCommandCheckOutput(a, "/list", assertList()),

                (a) -> assertCommandCheckOutput(a, "/imports", assertImports())

        );

    }

    public void testClasspathDirectory() {

        Compiler compiler = new Compiler();

        Path outDir = Paths.get("testClasspathDirectory");

        compiler.compile(outDir, "package pkg; public class A { public String toString() { return \"A\"; } }");

        Path classpath = compiler.getPath(outDir);

        test(

                (a) -> assertCommand(a, "/classpath " + classpath, String.format("|  Path %s added to classpath\n", classpath)),

                (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "\"A\"")

        );

        test(new String[] { "-cp", classpath.toString() },

                (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "\"A\"")

        );

        test(new String[] { "-classpath", classpath.toString() },

                (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "\"A\"")

        );

    }

    public void testClasspathJar() {

        Compiler compiler = new Compiler();

        Path outDir = Paths.get("testClasspathJar");

        compiler.compile(outDir, "package pkg; public class A { public String toString() { return \"A\"; } }");

        String jarName = "test.jar";

        compiler.jar(outDir, jarName, "pkg/A.class");

        Path jarPath = compiler.getPath(outDir).resolve(jarName);

        test(

                (a) -> assertCommand(a, "/classpath " + jarPath, String.format("|  Path %s added to classpath\n", jarPath)),

                (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "\"A\"")

        );

        test(new String[] { "-cp", jarPath.toString() },

                (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "\"A\"")

        );

        test(new String[] { "-classpath", jarPath.toString() },

                (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "\"A\"")

        );

    }

    public void testStartupFileOption() {

        try {

            Compiler compiler = new Compiler();

            Path startup = compiler.getPath("StartupFileOption/startup.txt");

            compiler.writeToFile(startup, "class A { public String toString() { return \"A\"; } }");

            test(new String[]{"-startup", startup.toString()},

                    (a) -> evaluateExpression(a, "A", "new A()", "\"A\"\n")

            );

            test(new String[]{"-nostartup"},

                    (a) -> assertCommandCheckOutput(a, "printf(\"\")", assertStartsWith("|  Error:\n|  cannot find symbol"))

            );

            test((a) -> assertCommand(a, "printf(\"A\")", "", "", null, "A", ""));

            test(false, new String[]{"-startup", "UNKNOWN"}, "|  File 'UNKNOWN' for start-up is not found.");

        } finally {

            removeStartup();

        }

    }

    public void testLoadingFromArgs() {

        Compiler compiler = new Compiler();

        Path path = compiler.getPath("loading.repl");

        compiler.writeToFile(path, "int a = 10; double x = 20; double a = 10;");

        test(new String[] { path.toString() },

                (a) -> assertCommand(a, "x", "|  Variable x of type double has value 20.0\n"),

                (a) -> assertCommand(a, "a", "|  Variable a of type double has value 10.0\n")

        );

        Path unknown = compiler.getPath("UNKNOWN.jar");

        test(true, new String[]{unknown.toString()},

                "|  File '" + unknown

                + "' is not found: " + unresolvableMessage(unknown) + "\n");

    }

    public void testReset() {

        test(

                (a) -> assertReset(a, "/r"),

                (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                (a) -> assertVariable(a, "int", "x"),

                (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),

                (a) -> assertMethod(a, "void f() { }", "()void", "f"),

                (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                (a) -> assertClass(a, "class A { }", "class", "A"),

                (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                (a) -> assertImport(a, "import java.util.stream.*;", "", "java.util.stream.*"),

                (a) -> assertCommandCheckOutput(a, "/imports", assertImports()),

                (a) -> assertReset(a, "/reset"),

                (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),

                (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),

                (a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),

                (a) -> assertCommandCheckOutput(a, "/imports", assertImports())

        );

    }

    public void testOpen() {

        Compiler compiler = new Compiler();

        Path path = compiler.getPath("testOpen.repl");

        compiler.writeToFile(path,

                "int a = 10;\ndouble x = 20;\ndouble a = 10;\n" +

                        "class A { public String toString() { return \"A\"; } }\nimport java.util.stream.*;");

        for (String s : new String[]{"/o", "/open"}) {

            test(

                    (a) -> assertCommand(a, s + " " + path.toString(), ""),

                    (a) -> assertCommand(a, "a", "|  Variable a of type double has value 10.0\n"),

                    (a) -> evaluateExpression(a, "A", "new A();", "\"A\""),