| /* |
| * Copyright (c) 2015, 2018, 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 8143037 8142447 8144095 8140265 8144906 8146138 8147887 8147886 8148316 8148317 8143955 8157953 8080347 8154714 8166649 8167643 8170162 8172102 8165405 8174796 8174797 8175304 8167554 8180508 8166232 8196133 8199912 8211694 8223688 |
| * @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 |
| * @key intermittent |
| */ |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.net.InetAddress; |
| import java.net.InetSocketAddress; |
| 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.stream.Collectors; |
| import java.util.stream.Stream; |
| |
| import com.sun.net.httpserver.HttpServer; |
| import org.testng.annotations.Test; |
| |
| import static org.testng.Assert.assertEquals; |
| import static org.testng.Assert.assertTrue; |
| import static org.testng.Assert.assertFalse; |
| 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()) |
| ); |
| } |
| } |
| |
| public void testCtrlD() { |
| test(false, new String[]{"--no-startup"}, |
| a -> { |
| if (!a) { |
| closeCommandInput(); |
| } else { |
| throw new IllegalStateException(); |
| } |
| } |
| ); |
| } |
| |
| 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 snippet with ID: 0"), |
| (a) -> assertCommand(a, "/5", "| No snippet with ID: 5") |
| ); |
| 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 snippet with ID: s1"), |
| (a) -> assertCommand(a, "/1", "| No snippet with ID: 1"), |
| (a) -> assertCommand(a, "/e1", "| No snippet with ID: e1") |
| ); |
| } |
| |
| 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") |
| ); |
| } |
| |
| public void testEnvInStartUp() { |
| 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); |
| Path sup = compiler.getPath("startup.jsh"); |
| compiler.writeToFile(sup, |
| "int xxx;\n" + |
| "/env -class-path " + classpath + "\n" + |
| "int aaa = 735;\n" |
| ); |
| test( |
| (a) -> assertCommand(a, "/set start -retain " + sup, ""), |
| (a) -> assertCommand(a, "/reset", |
| "| Resetting state."), |
| (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "A"), |
| (a) -> assertCommand(a, "aaa", "aaa ==> 735") |
| ); |
| test( |
| (a) -> assertCommandOutputContains(a, "/env", "--class-path"), |
| (a) -> assertCommandOutputContains(a, "xxx", "cannot find symbol", "variable xxx"), |
| (a) -> evaluateExpression(a, "pkg.A", "new pkg.A();", "A"), |
| (a) -> assertCommand(a, "aaa", "aaa ==> 735") |
| ); |
| } |
| |
| 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 '" + Paths.get(System.getProperty("user.home"), "forblato").toString() |
| + "' for '--class-path' is not found."), |
| (a) -> assertCommand(a, "/env --class-path " + jarPath + File.pathSeparator |
| + tilde + "forblato", |
| "| File '" + Paths.get(System.getProperty("user.home"), "forblato").toString() |
| + "' 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()) |
| ); |
| } |
| |
| private String makeBadSourceJar() { |
| Compiler compiler = new Compiler(); |
| Path outDir = Paths.get("testClasspathJar"); |
| Path src = compiler.getPath(outDir.resolve("pkg/A.java")); |
| compiler.writeToFile(src, "package pkg; /** \u0086 */public class A { public String toString() { return \"A\"; } }"); |
| String jarName = "test.jar"; |
| compiler.jar(outDir, jarName, "pkg/A.java"); |
| return compiler.getPath(outDir).resolve(jarName).toString(); |
| } |
| |
| public void testBadSourceJarClasspath() { |
| String jarPath = makeBadSourceJar(); |
| test( |
| (a) -> assertCommand(a, "/env --class-path " + jarPath, |
| "| Setting new options and restoring state."), |
| (a) -> assertCommandOutputStartsWith(a, "new pkg.A();", |
| "| Error:\n" |
| + "| cannot find symbol\n" |
| + "| symbol: class A") |
| ); |
| test(new String[]{"--class-path", jarPath}, |
| (a) -> assertCommandOutputStartsWith(a, "new pkg.A();", |
| "| Error:\n" |
| + "| cannot find symbol\n" |
| + "| symbol: class A") |
| ); |
| } |
| |
| 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 '" + Paths.get(System.getProperty("user.home"), "snardugol").toString() |
| + "' 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") |
| ); |
| } |
| |
| 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 testOpenLocalFileUrl() { |
| Compiler compiler = new Compiler(); |
| Path path = compiler.getPath("testOpen.repl"); |
| compiler.writeToFile(path, "int a = 10;int b = 20;int c = a + b;\n"); |
| for (String s : new String[]{"/o", "/open"}) { |
| test( |
| (a) -> assertCommand(a, s + " " + path.toUri(), ""), |
| (a) -> assertCommand(a, "a", "a ==> 10"), |
| (a) -> assertCommand(a, "b", "b ==> 20"), |
| (a) -> assertCommand(a, "c", "c ==> 30") |
| ); |
| } |
| } |
| |
| public void testOpenFileOverHttp() throws IOException { |
| var script = "int a = 10;int b = 20;int c = a + b;"; |
| |
| var localhostAddress = new InetSocketAddress(InetAddress.getLoopbackAddress().getHostAddress(), 0); |
| var httpServer = HttpServer.create(localhostAddress, 0); |
| try { |
| httpServer.createContext("/script", exchange -> { |
| exchange.sendResponseHeaders(200, script.length()); |
| try (var output = exchange.getResponseBody()) { |
| output.write(script.getBytes()); |
| } |
| }); |
| httpServer.setExecutor(null); |
| httpServer.start(); |
| |
| var urlAddress = "http:/" + httpServer.getAddress().toString() + "/script"; |
| for (String s : new String[]{"/o", "/open"}) { |
| test( |
| (a) -> assertCommand(a, s + " " + urlAddress, ""), |
| (a) -> assertCommand(a, "a", "a ==> 10"), |
| (a) -> assertCommand(a, "b", "b ==> 20"), |
| (a) -> assertCommand(a, "c", "c ==> 30") |
| ); |
| } |
| } finally { |
| httpServer.stop(0); |
| } |
| } |
| |
| 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)) |
| .filter(str -> !str.startsWith("/")) |
| .collect(Collectors.toList()))), |
| (a) -> assertCommand(a, "/save -all " + path.toString(), "") |
| ); |
| assertEquals(Files.readAllLines(path), output); |
| } |
| { |
| List<String> output = new ArrayList<>(); |
| test( |
| (a) -> assertCommand(a, "int a;", null), |
| (a) -> assertCommand(a, "int b;", null), |
| (a) -> assertCommand(a, "int c;", null), |
| (a) -> assertClass(a, "class A { public String toString() { return \"A\"; } }", "class", "A"), |
| (a) -> assertCommandCheckOutput(a, "/list b c a A", (out) -> |
| output.addAll(Stream.of(out.split("\n")) |
| .filter(str -> !str.isEmpty()) |
| .map(str -> str.substring(str.indexOf(':') + 2)) |
| .filter(str -> !str.startsWith("/")) |
| .collect(Collectors.toList()))), |
| (a) -> assertCommand(a, "/save 2-3 1 4 " + path.toString(), "") |
| ); |
| assertEquals(Files.readAllLines(path), output); |
| } |
| { |
| List<String> output = new ArrayList<>(); |
| 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) -> assertCommandCheckOutput(a, "/history", (out) -> |
| output.addAll(Stream.of(out.split("\n")) |
| .filter(str -> !str.isEmpty()) |
| .collect(Collectors.toList()))), |
| (a) -> assertCommand(a, "/save -history " + path.toString(), "") |
| ); |
| output.add("/save -history " + path.toString()); |
| assertEquals(Files.readAllLines(path), output); |
| } |
| } |
| |
| public void testStartRetain() { |
| Compiler compiler = new Compiler(); |
| Path startUpFile = compiler.getPath("startUp.txt"); |
| test( |
| (a) -> assertVariable(a, "int", "a"), |
| (a) -> assertVariable(a, "double", "b", "10", "10.0"), |
| (a) -> assertMethod(a, "void f() {}", "()V", "f"), |
| (a) -> assertImport(a, "import java.util.stream.*;", "", "java.util.stream.*"), |
| (a) -> assertCommand(a, "/save " + startUpFile.toString(), null), |
| (a) -> assertCommand(a, "/set start -retain " + startUpFile.toString(), null) |
| ); |
| Path unknown = compiler.getPath("UNKNOWN"); |
| test( |
| (a) -> assertCommandOutputStartsWith(a, "/set start -retain " + unknown.toString(), |
| "| File '" + unknown + "' for '/set start' is not found.") |
| ); |
| test(false, new String[0], |
| (a) -> { |
| loadVariable(a, "int", "a"); |
| loadVariable(a, "double", "b", "10.0", "10.0"); |
| loadMethod(a, "void f() {}", "()void", "f"); |
| loadImport(a, "import java.util.stream.*;", "", "java.util.stream.*"); |
| assertCommandCheckOutput(a, "/types", assertClasses()); |
| }, |
| (a) -> assertCommandCheckOutput(a, "/vars", assertVariables()), |
| (a) -> assertCommandCheckOutput(a, "/methods", assertMethods()), |
| (a) -> assertCommandCheckOutput(a, "/imports", assertImports()) |
| ); |
| } |
| |
| public void testStartSave() throws IOException { |
| Compiler compiler = new Compiler(); |
| Path startSave = compiler.getPath("startSave.txt"); |
| test(a -> assertCommand(a, "/save -start " + startSave.toString(), null)); |
| List<String> lines = Files.lines(startSave) |
| .filter(s -> !s.isEmpty()) |
| .collect(Collectors.toList()); |
| assertEquals(lines, START_UP); |
| } |
| |
| public void testConstrainedUpdates() { |
| test( |
| a -> assertClass(a, "class XYZZY { }", "class", "XYZZY"), |
| a -> assertVariable(a, "XYZZY", "xyzzy"), |
| a -> assertCommandCheckOutput(a, "import java.util.stream.*", |
| (out) -> assertTrue(out.trim().isEmpty(), "Expected no output, got: " + out)) |
| ); |
| } |
| |
| public void testRemoteExit() { |
| test( |
| a -> assertVariable(a, "int", "x"), |
| a -> assertCommandCheckOutput(a, "/vars", assertVariables()), |
| a -> assertCommandOutputContains(a, "System.exit(5);", "terminated"), |
| a -> assertCommandCheckOutput(a, "/vars", s -> |
| assertTrue(s.trim().isEmpty(), s)), |
| a -> assertMethod(a, "void f() { }", "()void", "f"), |
| a -> assertCommandCheckOutput(a, "/methods", assertMethods()) |
| ); |
| } |
| |
| public void testFeedbackNegative() { |
| test(a -> assertCommandCheckOutput(a, "/set feedback aaaa", |
| assertStartsWith("| Does not match any current feedback mode"))); |
| } |
| |
| public void testFeedbackSilent() { |
| for (String off : new String[]{"s", "silent"}) { |
| test( |
| a -> assertCommand(a, "/set feedback " + off, ""), |
| a -> assertCommand(a, "int a", ""), |
| a -> assertCommand(a, "void f() {}", ""), |
| a -> assertCommandCheckOutput(a, "aaaa", assertStartsWith("| Error:")), |
| a -> assertCommandCheckOutput(a, "static void f() {}", assertStartsWith("| Warning:")) |
| ); |
| } |
| } |
| |
| public void testFeedbackNormal() { |
| Compiler compiler = new Compiler(); |
| Path testNormalFile = compiler.getPath("testConciseNormal"); |
| String[] sources = new String[] {"int a", "void f() {}", "class A {}", "a = 10"}; |
| String[] sources2 = new String[] {"int a //again", "void f() {int y = 4;}", "class A {} //again", "a = 10"}; |
| String[] output = new String[] { |
| "a ==> 0", |
| "| created method f()", |
| "| created class A", |
| "a ==> 10" |
| }; |
| compiler.writeToFile(testNormalFile, sources2); |
| for (String feedback : new String[]{"/set fe", "/set feedback"}) { |
| for (String feedbackState : new String[]{"n", "normal"}) { |
| test( |
| a -> assertCommand(a, feedback + " " + feedbackState, "| Feedback mode: normal"), |
| a -> assertCommand(a, sources[0], output[0]), |
| a -> assertCommand(a, sources[1], output[1]), |
| a -> assertCommand(a, sources[2], output[2]), |
| a -> assertCommand(a, sources[3], output[3]), |
| a -> assertCommand(a, "/o " + testNormalFile.toString(), "") |
| ); |
| } |
| } |
| } |
| |
| public void testVarsWithNotActive() { |
| test( |
| a -> assertVariable(a, "Blath", "x"), |
| a -> assertCommandOutputContains(a, "/var -all", "(not-active)") |
| ); |
| } |
| |
| public void testHistoryReference() { |
| test(false, new String[]{"--no-startup"}, |
| a -> assertCommand(a, "System.err.println(99)", "", "", null, "", "99\n"), |
| a -> assertCommand(a, "/exit", "") |
| ); |
| test(false, new String[]{"--no-startup"}, |
| a -> assertCommand(a, "System.err.println(1)", "", "", null, "", "1\n"), |
| a -> assertCommand(a, "System.err.println(2)", "", "", null, "", "2\n"), |
| a -> assertCommand(a, "/-2", "System.err.println(1)", "", null, "", "1\n"), |
| a -> assertCommand(a, "/history", |
| "/debug 0\n" + |
| "System.err.println(1)\n" + |
| "System.err.println(2)\n" + |
| "System.err.println(1)\n" + |
| "/history\n"), |
| a -> assertCommand(a, "/history -all", |
| "/debug 0\n" + |
| "System.err.println(99)\n" + |
| "/exit\n" + |
| "/debug 0\n" + |
| "System.err.println(1)\n" + |
| "System.err.println(2)\n" + |
| "System.err.println(1)\n" + |
| "/history\n" + |
| "/history -all\n"), |
| a -> assertCommand(a, "/-2", "System.err.println(2)", "", null, "", "2\n"), |
| a -> assertCommand(a, "/!", "System.err.println(2)", "", null, "", "2\n"), |
| a -> assertCommand(a, "/2", "System.err.println(2)", "", null, "", "2\n"), |
| a -> assertCommand(a, "/1", "System.err.println(1)", "", null, "", "1\n") |
| ); |
| } |
| |
| public void testRerunIdRange() { |
| Compiler compiler = new Compiler(); |
| Path startup = compiler.getPath("rangeStartup"); |
| String[] startupSources = new String[] { |
| "boolean go = false", |
| "void println(String s) { if (go) System.out.println(s); }", |
| "void println(int i) { if (go) System.out.println(i); }", |
| "println(\"s4\")", |
| "println(\"s5\")", |
| "println(\"s6\")" |
| }; |
| String[] sources = new String[] { |
| "frog", |
| "go = true", |
| "println(2)", |
| "println(3)", |
| "println(4)", |
| "querty" |
| }; |
| compiler.writeToFile(startup, startupSources); |
| test(false, new String[]{"--startup", startup.toString()}, |
| a -> assertCommandOutputStartsWith(a, sources[0], "| Error:"), |
| a -> assertCommand(a, sources[1], "go ==> true", "", null, "", ""), |
| a -> assertCommand(a, sources[2], "", "", null, "2\n", ""), |
| a -> assertCommand(a, sources[3], "", "", null, "3\n", ""), |
| a -> assertCommand(a, sources[4], "", "", null, "4\n", ""), |
| a -> assertCommandOutputStartsWith(a, sources[5], "| Error:"), |
| a -> assertCommand(a, "/3", "println(3)", "", null, "3\n", ""), |
| a -> assertCommand(a, "/s4", "println(\"s4\")", "", null, "s4\n", ""), |
| a -> assertCommandOutputStartsWith(a, "/e1", "frog\n| Error:"), |
| a -> assertCommand(a, "/2-4", |
| "println(2)\nprintln(3)\nprintln(4)", |
| "", null, "2\n3\n4\n", ""), |
| a -> assertCommand(a, "/s4-s6", |
| startupSources[3] + "\n" +startupSources[4] + "\n" +startupSources[5], |
| "", null, "s4\ns5\ns6\n", ""), |
| a -> assertCommand(a, "/s4-4", null, |
| "", null, "s4\ns5\ns6\n2\n3\n4\n", ""), |
| a -> assertCommandCheckOutput(a, "/e1-e2", |
| s -> { |
| assertTrue(s.trim().startsWith("frog\n| Error:"), |
| "Output: \'" + s + "' does not start with: " + "| Error:"); |
| assertTrue(s.trim().lastIndexOf("| Error:") > 10, |
| "Output: \'" + s + "' does not have second: " + "| Error:"); |
| }), |
| a -> assertCommand(a, "/4 s4 2", |
| "println(4)\nprintln(\"s4\")\nprintln(2)", |
| "", null, "4\ns4\n2\n", ""), |
| a -> assertCommand(a, "/s5 2-4 3", |
| "println(\"s5\")\nprintln(2)\nprintln(3)\nprintln(4)\nprintln(3)", |
| "", null, "s5\n2\n3\n4\n3\n", ""), |
| a -> assertCommand(a, "/2 ff", "| No such snippet: ff"), |
| a -> assertCommand(a, "/4-2", "| End of snippet range less than start: 4 - 2"), |
| a -> assertCommand(a, "/s5-s3", "| End of snippet range less than start: s5 - s3"), |
| a -> assertCommand(a, "/4-s5", "| End of snippet range less than start: 4 - s5") |
| ); |
| } |
| |
| @Test(enabled = false) // TODO 8158197 |
| public void testHeadlessEditPad() { |
| String prevHeadless = System.getProperty("java.awt.headless"); |
| try { |
| System.setProperty("java.awt.headless", "true"); |
| test( |
| (a) -> assertCommandOutputStartsWith(a, "/edit printf", "| Cannot launch editor -- unexpected exception:") |
| ); |
| } finally { |
| System.setProperty("java.awt.headless", prevHeadless==null? "false" : prevHeadless); |
| } |
| } |
| |
| public void testAddExports() { |
| test(false, new String[]{"--no-startup"}, |
| a -> assertCommandOutputStartsWith(a, "import jdk.internal.misc.VM;", "| Error:") |
| ); |
| test(false, new String[]{"--no-startup", |
| "-R--add-exports", "-Rjava.base/jdk.internal.misc=ALL-UNNAMED", |
| "-C--add-exports", "-Cjava.base/jdk.internal.misc=ALL-UNNAMED"}, |
| a -> assertImport(a, "import jdk.internal.misc.VM;", "", "jdk.internal.misc.VM"), |
| a -> assertCommand(a, "System.err.println(VM.isBooted())", "", "", null, "", "true\n") |
| ); |
| test(false, new String[]{"--no-startup", "--add-exports", "java.base/jdk.internal.misc"}, |
| a -> assertImport(a, "import jdk.internal.misc.VM;", "", "jdk.internal.misc.VM"), |
| a -> assertCommand(a, "System.err.println(VM.isBooted())", "", "", null, "", "true\n") |
| ); |
| } |
| |
| public void testRedeclareVariableNoInit() { |
| test( |
| a -> assertCommand(a, "Integer a;", "a ==> null"), |
| a -> assertCommand(a, "a instanceof Integer;", "$2 ==> false"), |
| a -> assertCommand(a, "a = 1;", "a ==> 1"), |
| a -> assertCommand(a, "Integer a;", "a ==> null"), |
| a -> assertCommand(a, "a instanceof Integer;", "$5 ==> false"), |
| a -> assertCommand(a, "a", "a ==> null") |
| ); |
| } |
| |
| public void testWarningUnchecked() { //8223688 |
| test(false, new String[]{"--no-startup"}, |
| a -> assertCommand(a, "abstract class A<T> { A(T t){} }", "| created class A"), |
| a -> assertCommandCheckOutput(a, "new A(\"\") {}", s -> { |
| assertStartsWith("| Warning:"); |
| assertTrue(s.contains("unchecked call")); |
| assertFalse(s.contains("Exception")); |
| }) |
| ); |
| } |
| |
| } |
