archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-20 11:04:34 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8134254: JShell API/tool: REPL for Java into JDK9

Browse source 
Adding the implementation of the jshell (read-eval-print-loop) tool.

Co-authored-by: Robert Field <robert.field@oracle.com>
Co-authored-by: Shinya Yoshida <bitterfoxc@gmail.com>
Reviewed-by: briangoetz, mcimadamore, psandoz, forax
This commit is contained in:
Jan Lahoda 2015-10-19 19:15:16 +02:00
parent 9cd68d0633
commit a21102b5f4
110 changed files with 24672 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

846
langtools/test/jdk/jshell/ToolBasicTest.java Normal file
View file

@ -0,0 +1,846 @@
/*
* 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
* @summary Tests for Basic tests for REPL tool
* @ignore 8139873
* @library /tools/lib
* @build KullaTesting TestingInputStream ToolBox Compiler
* @run testng ToolBasicTest
*/
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.Consumer;
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, "/v", assertVariables()),
(a) -> evaluateExpression(a, "int", "2", "2"),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertCommand(a, "void f() {", ""),
(a) -> assertCommand(a, "int q = 10;" + s, ""),
interrupt,
(a) -> assertCommand(a, "void f() {}\u0003", ""),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertMethod(a, "int f() { return 0; }", "()int", "f"),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertCommand(a, "class A {" + s, ""),
interrupt,
(a) -> assertCommand(a, "class A {}\u0003", ""),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses()),
(a) -> assertClass(a, "interface A {}", "interface", "A"),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses())
);
}
}
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", "| Cannot find snippet 0\n"),
(a) -> assertCommand(a, "/5", "| Cannot find snippet 5\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 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, "/db", "| Debugging on\n"),
(a) -> assertCommand(a, "/debug", "| Debugging off\n"),
(a) -> assertCommand(a, "/debug", "| Debugging on\n"),
(a) -> assertCommand(a, "/db", "| Debugging off\n")
);
}
public void testHelp() {
Consumer<String> testOutput = (s) -> {
List<String> ss = Stream.of(s.split("\n"))
.filter(l -> !l.isEmpty())
.collect(Collectors.toList());
assertTrue(ss.size() >= 5, "Help does not print enough lines:\n" + s);
};
test(
(a) -> assertCommandCheckOutput(a, "/?", testOutput),
(a) -> assertCommandCheckOutput(a, "/help", 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, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),
(a) -> assertVariable(a, "int", "a"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),
(a) -> assertVariable(a, "double", "a", "1", "1.0"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertCommandCheckOutput(a, "/vars", assertVariables()),
(a) -> evaluateExpression(a, "double", "2 * a", "2.0"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertCommandCheckOutput(a, "/vars", assertVariables())
);
}
public void defineMethods() {
test(
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),
(a) -> assertMethod(a, "int f() { return 0; }", "()int", "f"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),
(a) -> assertMethod(a, "void f(int a) { g(); }", "(int)void", "f"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertCommandCheckOutput(a, "/methods", assertMethods()),
(a) -> assertMethod(a, "void g() {}", "()void", "g"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertCommandCheckOutput(a, "/methods", assertMethods())
);
}
public void defineClasses() {
test(
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses()),
(a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),
(a) -> assertClass(a, "class A { }", "class", "A"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses()),
(a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),
(a) -> assertClass(a, "interface A { }", "interface", "A"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses()),
(a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),
(a) -> assertClass(a, "enum A { }", "enum", "A"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses()),
(a) -> assertCommandCheckOutput(a, "/classes", assertClasses()),
(a) -> assertClass(a, "@interface A { }", "@interface", "A"),
(a) -> assertCommandCheckOutput(a, "/l", assertList()),
(a) -> assertCommandCheckOutput(a, "/list", assertList()),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses()),
(a) -> assertCommandCheckOutput(a, "/classes", assertClasses())
);
}
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, "/cp " + 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: " + unknown
+ " (No such file or directory)\n");
}
public void testReset() {
test(
(a) -> assertReset(a, "/r"),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertVariable(a, "int", "x"),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertMethod(a, "void f() { }", "()void", "f"),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertClass(a, "class A { }", "class", "A"),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses()),
(a) -> assertReset(a, "/reset"),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertCommandCheckOutput(a, "/c", assertClasses())
);
}
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\"; } }");
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\""),
(a) -> {
loadVariable(a, "double", "x", "20.0", "20.0");
loadVariable(a, "double", "a", "10.0", "10.0");
loadVariable(a, "A", "$6", "new A();", "A");
loadClass(a, "class A { public String toString() { return \"A\"; } }",
"class", "A");
assertCommandCheckOutput(a, "/c", assertClasses());
},
(a) -> assertCommandCheckOutput(a, "/m", assertMethods()),
(a) -> assertCommandCheckOutput(a, "/v", assertVariables())
);
Path unknown = compiler.getPath("UNKNOWN.repl");
test(
(a) -> assertCommand(a, s + " " + unknown,
"| File '" + unknown
+ "' is not found: " + unknown
+ " (No such file or directory)\n")
);
}
}
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\"; } }"
);
for (String s : new String[]{"/s", "/save"}) {
test(
(a) -> assertVariable(a, "int", "a"),
(a) -> assertClass(a, "class A { public String toString() { return \"A\"; } }", "class", "A"),
(a) -> assertCommand(a, s + " " + path.toString(), "")
);
assertEquals(Files.readAllLines(path), list);
}
for (String s : new String[]{"/s", "/save"}) {
List<String> output = new ArrayList<>();
test(
(a) -> assertCommand(a, "int a;", 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, s + " all " + path.toString(), "")
);
assertEquals(Files.readAllLines(path), output);
}
for (String s : new String[]{"/s", "/save"}) {
List<String> output = new ArrayList<>();
test(
(a) -> assertVariable(a, "int", "a"),
(a) -> assertClass(a, "class A { public String toString() { return \"A\"; } }", "class", "A"),
(a) -> assertCommandCheckOutput(a, "/h", (out) ->
output.addAll(Stream.of(out.split("\n"))
.filter(str -> !str.isEmpty())
.collect(Collectors.toList()))),
(a) -> assertCommand(a, s + " history " + path.toString(), "")
);
output.add(s + " history " + path.toString());
assertEquals(Files.readAllLines(path), output);
}
}
public void testStartSet() throws BackingStoreException {
try {
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) -> assertCommand(a, "/s " + startUpFile.toString(), null),
(a) -> assertCommand(a, "/setstart " + startUpFile.toString(), null)
);
Path unknown = compiler.getPath("UNKNOWN");
test(
(a) -> assertCommand(a, "/setstart " + unknown.toString(),
"| File '" + unknown + "' for /setstart is not found.\n")
);
test(false, new String[0],
(a) -> {
loadVariable(a, "int", "a");
loadVariable(a, "double", "b", "10.0", "10.0");
loadMethod(a, "void f() {}", "()void", "f");
assertCommandCheckOutput(a, "/c", assertClasses());
},
(a) -> assertCommandCheckOutput(a, "/v", assertVariables()),
(a) -> assertCommandCheckOutput(a, "/m", assertMethods())
);
} finally {
removeStartup();
}
}
private void removeStartup() {
Preferences preferences = Preferences.userRoot().node("tool/REPL");
if (preferences != null) {
preferences.remove("STARTUP");
}
}
public void testUnknownCommand() {
test((a) -> assertCommand(a, "/unknown",
"| No such command: /unknown\n" +
"| Type /help for help.\n"));
}
public void testEmptyClassPath() {
String[] commands = {"/cp", "/classpath"};
test(Stream.of(commands)
.map(cmd -> (ReplTest) after -> assertCommand(after, cmd, "| /classpath requires a path argument\n"))
.toArray(ReplTest[]::new));
}
public void testNoArgument() {
String[] commands = {"/s", "/save", "/o", "/open", "/setstart", "/savestart"};
test(Stream.of(commands)
.map(cmd -> {
String c = cmd;
if ("/s".equals(cmd)) {
c = "/save";
}
if ("/o".equals(cmd)) {
c = "/open";
}
final String finalC = c;
return (ReplTest) after -> assertCommand(after, cmd,
"| The " + finalC + " command requires a filename argument.\n");
})
.toArray(ReplTest[]::new));
}
public void testStartSave() throws IOException {
Compiler compiler = new Compiler();
Path startSave = compiler.getPath("startSave.txt");
test(a -> assertCommand(a, "/savestart " + startSave.toString(), null));
List<String> lines = Files.lines(startSave)
.filter(s -> !s.isEmpty())
.collect(Collectors.toList());
assertEquals(lines, Arrays.asList(
"import java.util.*;",
"import java.io.*;",
"import java.math.*;",
"import java.net.*;",
"import java.util.concurrent.*;",
"import java.util.prefs.*;",
"import java.util.regex.*;",
"void printf(String format, Object... args) { System.out.printf(format, args); }"));
}
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, "/v", assertVariables()),
a -> assertCommandCheckOutput(a, "System.exit(5);", s ->
assertTrue(s.contains("terminated"), s)),
a -> assertCommandCheckOutput(a, "/v", s ->
assertTrue(s.trim().isEmpty(), s)),
a -> assertMethod(a, "void f() { }", "()void", "f"),
a -> assertCommandCheckOutput(a, "/m", assertMethods())
);
}
public void testListArgs() {
Consumer<String> assertList = s -> assertTrue(s.split("\n").length >= 7, s);
String arg = "qqqq";
Consumer<String> assertError = s -> assertEquals(s, "| Invalid /list argument: " + arg + "\n");
test(
a -> assertCommandCheckOutput(a, "/l all", assertList),
a -> assertCommandCheckOutput(a, "/list all", assertList),
a -> assertCommandCheckOutput(a, "/l " + arg, assertError),
a -> assertCommandCheckOutput(a, "/list " + arg, assertError),
a -> assertVariable(a, "int", "a"),
a -> assertCommandCheckOutput(a, "/l history", assertList),
a -> assertCommandCheckOutput(a, "/list history", assertList)
);
}
public void testFeedbackNegative() {
for (String feedback : new String[]{"/f", "/feedback"}) {
test(a -> assertCommandCheckOutput(a, feedback + " aaaa",
assertStartsWith("| Follow /feedback with of the following")));
}
}
public void testFeedbackOff() {
for (String feedback : new String[]{"/f", "/feedback"}) {
for (String off : new String[]{"o", "off"}) {
test(
a -> assertCommand(a, feedback + " " + off, ""),
a -> assertCommand(a, "int a", ""),
a -> assertCommand(a, "void f() {}", ""),
a -> assertCommandCheckOutput(a, "aaaa", assertStartsWith("| Error:")),
a -> assertCommandCheckOutput(a, "public void f() {}", assertStartsWith("| Warning:"))
);
}
}
}
public void testFeedbackConcise() {
Compiler compiler = new Compiler();
Path testConciseFile = compiler.getPath("testConciseFeedback");
String[] sources = new String[] {"int a", "void f() {}", "class A {}", "a = 10"};
compiler.writeToFile(testConciseFile, sources);
for (String feedback : new String[]{"/f", "/feedback"}) {
for (String concise : new String[]{"c", "concise"}) {
test(
a -> assertCommand(a, feedback + " " + concise, ""),
a -> assertCommand(a, sources[0], ""),
a -> assertCommand(a, sources[1], ""),
a -> assertCommand(a, sources[2], ""),
a -> assertCommand(a, sources[3], "| a : 10\n"),
a -> assertCommand(a, "/o " + testConciseFile.toString(), "| a : 10\n")
);
}
}
}
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[] {
"| Added variable a of type int\n",
"| Added method f()\n",
"| Added class A\n",
"| Variable a has been assigned the value 10\n"
};
compiler.writeToFile(testNormalFile, sources2);
for (String feedback : new String[]{"/f", "/feedback"}) {
for (String feedbackState : new String[]{"n", "normal", "v", "verbose"}) {
String f = null;
if (feedbackState.startsWith("n")) {
f = "normal";
} else if (feedbackState.startsWith("v")) {
f = "verbose";
}
final String finalF = f;
test(
a -> assertCommand(a, feedback + " " + feedbackState, "| Feedback mode: " + finalF +"\n"),
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(),
"| Modified variable a of type int\n" +
"| Modified method f()\n" +
"| Update overwrote method f()\n" +
"| Modified class A\n" +
"| Update overwrote class A\n" +
"| Variable a has been assigned the value 10\n")
);
}
}
}
public void testFeedbackDefault() {
Compiler compiler = new Compiler();
Path testDefaultFile = compiler.getPath("testDefaultFeedback");
String[] sources = new String[] {"int a", "void f() {}", "class A {}", "a = 10"};
String[] output = new String[] {
"| Added variable a of type int\n",
"| Added method f()\n",
"| Added class A\n",
"| Variable a has been assigned the value 10\n"
};
compiler.writeToFile(testDefaultFile, sources);
for (String feedback : new String[]{"/f", "/feedback"}) {
for (String defaultFeedback : new String[]{"", "d", "default"}) {
test(
a -> assertCommand(a, "/f o", ""),
a -> assertCommand(a, "int x", ""),
a -> assertCommand(a, feedback + " " + defaultFeedback, "| Feedback mode: default\n"),
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 " + testDefaultFile.toString(), "")
);
}
}
}
public void testDrop() {
for (String drop : new String[]{"/d", "/drop"}) {
test(false, new String[]{"-nostartup"},
a -> assertVariable(a, "int", "a"),
a -> dropVariable(a, drop + " 1", "int a = 0"),
a -> assertMethod(a, "int b() { return 0; }", "()I", "b"),
a -> dropMethod(a, drop + " 2", "b ()I"),
a -> assertClass(a, "class A {}", "class", "A"),
a -> dropClass(a, drop + " 3", "class A"),
a -> assertCommandCheckOutput(a, "/v", assertVariables()),
a -> assertCommandCheckOutput(a, "/m", assertMethods()),
a -> assertCommandCheckOutput(a, "/c", assertClasses())
);
test(false, new String[]{"-nostartup"},
a -> assertVariable(a, "int", "a"),
a -> dropVariable(a, drop + " a", "int a = 0"),
a -> assertMethod(a, "int b() { return 0; }", "()I", "b"),
a -> dropMethod(a, drop + " b", "b ()I"),
a -> assertClass(a, "class A {}", "class", "A"),
a -> dropClass(a, drop + " A", "class A"),
a -> assertCommandCheckOutput(a, "/v", assertVariables()),
a -> assertCommandCheckOutput(a, "/m", assertMethods()),
a -> assertCommandCheckOutput(a, "/c", assertClasses())
);
}
}
public void testDropNegative() {
for (String drop : new String[]{"/d", "/drop"}) {
test(false, new String[]{"-nostartup"},
a -> assertCommand(a, drop + " 0", "| No definition or id named 0 found. See /classes /methods /vars or /list\n"),
a -> assertCommand(a, drop + " a", "| No definition or id named a found. See /classes /methods /vars or /list\n"),
a -> assertCommandCheckOutput(a, drop,
assertStartsWith("| In the /drop argument, please specify an import, variable, method, or class to drop.")),
a -> assertVariable(a, "int", "a"),
a -> assertCommand(a, "a", "| Variable a of type int has value 0\n"),
a -> assertCommand(a, drop + " 2", "| The argument did not specify an import, variable, method, or class to drop.\n")
);
}
}
public void testAmbiguousDrop() {
Consumer<String> check = s -> {
assertTrue(s.startsWith("| The argument references more than one import, variable, method, or class"), s);
int lines = s.split("\n").length;
assertEquals(lines, 5, "Expected 3 ambiguous keys, but found: " + (lines - 2) + "\n" + s);
};
for (String drop : new String[]{"/d", "/drop"}) {
test(
a -> assertVariable(a, "int", "a"),
a -> assertMethod(a, "int a() { return 0; }", "()int", "a"),
a -> assertClass(a, "class a {}", "class", "a"),
a -> assertCommandCheckOutput(a, drop + " a", check),
a -> assertCommandCheckOutput(a, "/v", assertVariables()),
a -> assertCommandCheckOutput(a, "/m", assertMethods()),
a -> assertCommandCheckOutput(a, "/c", assertClasses())
);
test(
a -> assertMethod(a, "int a() { return 0; }", "()int", "a"),
a -> assertMethod(a, "double a(int a) { return 0; }", "(int)double", "a"),
a -> assertMethod(a, "double a(double a) { return 0; }", "(double)double", "a"),
a -> assertCommandCheckOutput(a, drop + " a", check),
a -> assertCommandCheckOutput(a, "/m", assertMethods())
);
}
}
public void testHistoryReference() {
test(false, new String[]{"-nostartup"},
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)\n", "", null, "", "1\n"),
a -> assertCommand(a, "/history", "\n" +
"/debug 0\n" +
"System.err.println(1)\n" +
"System.err.println(2)\n" +
"System.err.println(1)\n" +
"/history\n"),
a -> assertCommand(a, "/-2", "System.err.println(2)\n", "", null, "", "2\n"),
a -> assertCommand(a, "/!", "System.err.println(2)\n", "", null, "", "2\n"),
a -> assertCommand(a, "/2", "System.err.println(2)\n", "", null, "", "2\n"),
a -> assertCommand(a, "/1", "System.err.println(1)\n", "", null, "", "1\n")
);
}
}