--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/jdk/jshell/ErrorTranslationTest.java Mon Oct 19 19:15:16 2015 +0200
@@ -0,0 +1,162 @@
+/*
+ * 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 shell error translation
+ * @library /tools/lib
+ * @build KullaTesting TestingInputStream ExpectedDiagnostic ToolBox Compiler
+ * @run testng ErrorTranslationTest
+ */
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+import javax.tools.Diagnostic;
+
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+@Test
+public class ErrorTranslationTest extends ReplToolTesting {
+
+ @Test(enabled = false) // TODO 8080353
+ public void testErrors() {
+ test(
+ a -> assertDiagnostic(a, "abstract void f();", newExpectedDiagnostic(0, 8, 0, -1, -1, Diagnostic.Kind.ERROR)),
+ a -> assertDiagnostic(a, "native void f();", newExpectedDiagnostic(0, 6, 0, -1, -1, Diagnostic.Kind.ERROR)),
+ a -> assertDiagnostic(a, "static void f();", newExpectedDiagnostic(0, 16, 0, -1, -1, Diagnostic.Kind.ERROR)),
+ a -> assertDiagnostic(a, "synchronized void f();", newExpectedDiagnostic(0, 12, 0, -1, -1, Diagnostic.Kind.ERROR)),
+ a -> assertDiagnostic(a, "default void f();", newExpectedDiagnostic(0, 7, 0, -1, -1, Diagnostic.Kind.ERROR))
+ );
+ }
+
+ public void testWarnings() {
+ List<ReplTest> list = new ArrayList<>();
+ ExpectedDiagnostic[] diagnostics = new ExpectedDiagnostic[]{
+ newExpectedDiagnostic(0, 6, 0, -1, -1, Diagnostic.Kind.WARNING),
+ newExpectedDiagnostic(0, 9, 0, -1, -1, Diagnostic.Kind.WARNING),
+ newExpectedDiagnostic(0, 7, 0, -1, -1, Diagnostic.Kind.WARNING),
+ newExpectedDiagnostic(0, 6, 0, -1, -1, Diagnostic.Kind.WARNING),
+ newExpectedDiagnostic(0, 5, 0, -1, -1, Diagnostic.Kind.WARNING)};
+ String[] mods = {"public", "protected", "private", "static", "final"};
+ for (int i = 0; i < mods.length; ++i) {
+ for (String code : new String[] {"class A {}", "void f() {}", "int a;"}) {
+ final int finalI = i;
+ list.add(a -> assertDiagnostic(a, mods[finalI] + " " + code, diagnostics[finalI]));
+ }
+ }
+ test(list.toArray(new ReplTest[list.size()]));
+ }
+
+ @Test(enabled = false) // TODO 8132147
+ public void stressTest() {
+ Compiler compiler = new Compiler();
+ Path oome = compiler.getPath("OOME.repl");
+ Path soe = compiler.getPath("SOE.repl");
+ compiler.writeToFile(oome,
+ "List<byte[]> list = new ArrayList<>();\n",
+ "while (true) {\n" +
+ " list.add(new byte[1000000]);\n" +
+ "}");
+ compiler.writeToFile(soe,
+ "void f() { f(); }",
+ "f();");
+ List<ReplTest> tests = new ArrayList<>();
+ for (int i = 0; i < 25; ++i) {
+ tests.add(a -> assertCommandCheckOutput(a, "/o " + soe.toString(),
+ assertStartsWith("| java.lang.StackOverflowError thrown")));
+ tests.add(a -> assertCommandCheckOutput(a, "/o " + oome.toString(),
+ assertStartsWith("| java.lang.OutOfMemoryError thrown: Java heap space")));
+ }
+ test(tests.toArray(new ReplTest[tests.size()]));
+ }
+
+ private ExpectedDiagnostic newExpectedDiagnostic(long startPosition, long endPosition, long position,
+ long lineNumber, long columnNumber, Diagnostic.Kind kind) {
+ return new ExpectedDiagnostic("", startPosition, endPosition, position, lineNumber, columnNumber, kind);
+ }
+
+ private void assertDiagnostic(boolean after, String cmd, ExpectedDiagnostic expectedDiagnostic) {
+ assertCommandCheckOutput(after, cmd, assertDiagnostic(cmd, expectedDiagnostic));
+ }
+
+ private Consumer<String> assertDiagnostic(String expectedSource, ExpectedDiagnostic expectedDiagnostic) {
+ int start = (int) expectedDiagnostic.getStartPosition();
+ int end = (int) expectedDiagnostic.getEndPosition();
+ String expectedMarkingLine = createMarkingLine(start, end);
+ return s -> {
+ String[] lines = s.split("\n");
+ if (lines.length <= 3) {
+ throw new AssertionError("Not enough lines: " + s);
+ }
+ String kind = getKind(expectedDiagnostic.getKind());
+ assertEquals(lines[0], kind);
+ String source;
+ String markingLine;
+ switch (expectedDiagnostic.getKind()) {
+ case ERROR:
+ case WARNING:
+ source = lines[2];
+ markingLine = lines[3];
+ break;
+ default:
+ throw new AssertionError("Unsupported diagnostic kind: " + expectedDiagnostic.getKind());
+ }
+ assertTrue(source.endsWith(expectedSource), "Expected: " + expectedSource + ", found: " + source);
+ assertEquals(markingLine, expectedMarkingLine, "Input: " + expectedSource + ", marking line: ");
+ };
+ }
+
+ private String createMarkingLine(int start, int end) {
+ assertTrue(end >= start, String.format("End position %d is less than start position %d", end, start));
+ StringBuilder sb = new StringBuilder();
+ sb.append("| ");
+ for (int i = 0; i < start; ++i) {
+ sb.append(' ');
+ }
+ sb.append('^');
+ for (int i = 1; i < end - start - 1; ++i) {
+ sb.append('-');
+ }
+ if (start < end) {
+ sb.append('^');
+ }
+ return sb.toString();
+ }
+
+ public String getKind(Diagnostic.Kind kind) {
+ switch (kind) {
+ case WARNING:
+ return "| Warning:";
+ case ERROR:
+ return "| Error:";
+ default:
+ throw new AssertionError("Unsupported kind: " + kind);
+ }
+ }
+}