/*
* 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 shell error translation
* @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 KullaTesting TestingInputStream ExpectedDiagnostic toolbox.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, 5, 0, -1, -1, Diagnostic.Kind.WARNING)};
String[] mods = {"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);
}
}
}