/*

 * 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

 * @summary Tests for Basic tests for REPL tool

 * @modules jdk.compiler/com.sun.tools.javac.api

 *          jdk.compiler/com.sun.tools.javac.main

 *          jdk.jdeps/com.sun.tools.javap

 *          jdk.jshell/jdk.internal.jshell.tool

 * @library /tools/lib

 * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask

 * @build KullaTesting TestingInputStream Compiler

 * @run testng/timeout=600 ToolBasicTest

 */

import java.io.File;

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.Locale;

import java.util.Scanner;

import java.util.function.BiFunction;

import java.util.function.Consumer;

import java.util.function.Function;

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 elideStartUpFromList() {

        test(

                (a) -> assertCommandOutputContains(a, "123", "==> 123"),

                (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) -> assertCommandOutputContains(a, "123", "==> 123"),

                (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[]{"--no-startup"},

                    (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, "/types", assertClasses()),

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

                    (a) -> assertCommandCheckOutput(a, "/types", 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().trim(), output, "user");

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

        }

    }

    public void testStop() {

        test(

                (a) -> assertStop(a, "while (true) {}", ""),

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

        );

    }

    public void testRerun() {

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

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

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

        );

        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));

        }

        // Test /1 through /5 -- assure references are correct

        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));

        }

        // Test /-1 ... note that the snippets added by history must be stepped over

        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, "/-" + (2 * finalI + 1), check));

        }

        tests.add((a) -> assertCommandCheckOutput(a, "/!", assertStartsWith("int a = 0;")));

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

                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[] {"--no-startup"},

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

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

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

        );

    }

    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, "/env --class-path " + classpath,

                        "|  Setting new options and restoring state."),

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

        );

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

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

        );

    }

    private String makeSimpleJar() {

        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");

        return compiler.getPath(outDir).resolve(jarName).toString();

    }

    public void testClasspathJar() {

        String jarPath = makeSimpleJar();

        test(

                (a) -> assertCommand(a, "/env --class-path " + jarPath,

                        "|  Setting new options and restoring state."),

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

        );

        test(new String[] { "--class-path", jarPath },

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

        );

    }

    public void testClasspathUserHomeExpansion() {

        String jarPath = makeSimpleJar();

        String tilde = "~" + File.separator;

        test(

                (a) -> assertCommand(a, "/env --class-path " + tilde + "forblato",

                        "|  File '" + System.getProperty("user.home") + File.separator

                                + "forblato' for '--class-path' is not found."),

                (a) -> assertCommand(a, "/env --class-path " + jarPath + File.pathSeparator

                                                            + tilde + "forblato",

                        "|  File '" + System.getProperty("user.home") + File.separator

                                + "forblato' for '--class-path' is not found.")

        );

    }

    public void testBadClasspath() {

        String jarPath = makeSimpleJar();

        Compiler compiler = new Compiler();

        Path t1 = compiler.getPath("whatever/thing.zip");

        compiler.writeToFile(t1, "");

        Path t2 = compiler.getPath("whatever/thing.jmod");

        compiler.writeToFile(t2, "");

        test(

                (a) -> assertCommand(a, "/env --class-path " + t1.toString(),

                        "|  Invalid '--class-path' argument: " + t1.toString()),

                (a) -> assertCommand(a, "/env --class-path " + jarPath + File.pathSeparator + t1.toString(),

                        "|  Invalid '--class-path' argument: " + t1.toString()),

                (a) -> assertCommand(a, "/env --class-path " + t2.toString(),

                        "|  Invalid '--class-path' argument: " + t2.toString())

        );

    }

    public void testModulePath() {

        Compiler compiler = new Compiler();

        Path modsDir = Paths.get("mods");

        Path outDir = Paths.get("mods", "org.astro");

        compiler.compile(outDir, "package org.astro; public class World { public static String name() { return \"world\"; } }");

        compiler.compile(outDir, "module org.astro { exports org.astro; }");

        Path modsPath = compiler.getPath(modsDir);

        test(new String[] { "--module-path", modsPath.toString(), "--add-modules", "org.astro" },

                (a) -> assertCommand(a, "import org.astro.World;", ""),

                (a) -> evaluateExpression(a, "String",

                        "String.format(\"Greetings %s!\", World.name());",

                        "\"Greetings world!\"")

        );

    }

    public void testModulePathUserHomeExpansion() {

        String tilde = "~" + File.separatorChar;

        test(

                (a) -> assertCommand(a, "/env --module-path " + tilde + "snardugol",

                        "|  File '" + System.getProperty("user.home")

                                + File.separatorChar + "snardugol' for '--module-path' is not found.")

        );

    }

    public void testBadModulePath() {

        Compiler compiler = new Compiler();

        Path t1 = compiler.getPath("whatever/thing.zip");

        compiler.writeToFile(t1, "");

        test(

                (a) -> assertCommand(a, "/env --module-path " + t1.toString(),

                        "|  Invalid '--module-path' argument: " + t1.toString())

        );

    }

    public void testStartupFileOption() {

        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")

        );

        test(new String[]{"--no-startup"},

                (a) -> assertCommandCheckOutput(a, "Pattern.compile(\"x+\")", assertStartsWith("|  Error:\n|  cannot find symbol"))

        );

        test(

                (a) -> assertCommand(a, "Pattern.compile(\"x+\")", "$1 ==> x+", "", null, "", "")

        );

    }

    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", "x ==> 20.0"),

                (a) -> assertCommand(a, "a", "a ==> 10.0")

        );

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

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

                "|  File '" + unknown

                + "' for 'jshell' is not found.");

    }

    public void testReset() {

        test(

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

                (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, "/types", 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, "/types", 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", "a ==> 10.0"),

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

                    (a) -> evaluateExpression(a, "long", "Stream.of(\"A\").count();", "1"),

                    (a) -> {

                        loadVariable(a, "double", "x", "20.0", "20.0");

                        loadVariable(a, "double", "a", "10.0", "10.0");

                        loadVariable(a, "A", "$7", "new A();", "A");

                        loadVariable(a, "long", "$8", "Stream.of(\"A\").count();", "1");

                        loadClass(a, "class A { public String toString() { return \"A\"; } }",

                                "class", "A");

                        loadImport(a, "import java.util.stream.*;", "", "java.util.stream.*");

                        assertCommandCheckOutput(a, "/types", assertClasses());

                    },

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

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

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

            );

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

            test(

                    (a) -> assertCommand(a, s + " " + unknown,

                            "|  File '" + unknown + "' for '/open' is not found.")

            );

        }

    }

    public void testOpenResource() {

        test(

                (a) -> assertCommand(a, "/open PRINTING", ""),

                (a) -> assertCommandOutputContains(a, "/list",

                        "void println", "System.out.printf"),

                (a) -> assertCommand(a, "printf(\"%4.2f\", Math.PI)",

                        "", "", null, "3.14", "")

        );

    }

    public void testSave() throws IOException {

        Compiler compiler = new Compiler();

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

        List<String> list = Arrays.asList(

                "int a;",

                "class A { public String toString() { return \"A\"; } }"

        );

        test(

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

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

                (a) -> assertClass(a, "class A { public String toString() { return \"A\"; } }", "class", "A"),

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

        );

        assertEquals(Files.readAllLines(path), list);

        {

            List<String> output = new ArrayList<>();

            test(

                    (a) -> assertCommand(a, "int a;", null),

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

                    (a) -> assertClass(a, "class A { public String toString() { return \"A\"; } }", "class", "A"),

                    (a) -> assertCommandCheckOutput(a, "/list -all", (out) ->

                            output.addAll(Stream.of(out.split("\n"))

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

                                    .map(str -> str.substring(str.indexOf(':') + 2))