langtools/test/jdk/jshell/ExceptionsTest.java - platform/libcore - Git at Google

 /*
  * 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 exceptions
  * @build KullaTesting TestingInputStream
  * @run testng ExceptionsTest
  */

 import jdk.jshell.SnippetEvent;
 import jdk.jshell.EvalException;
 import java.io.PrintWriter;
 import java.io.StringWriter;

 import jdk.jshell.Snippet;
 import org.testng.annotations.Test;

 import static org.testng.Assert.*;

 @Test
 public class ExceptionsTest extends KullaTesting {

     public void throwUncheckedException() {
         String message = "error_message";
         SnippetEvent cr = assertEvalException("throw new RuntimeException(\"" + message + "\");");
         assertExceptionMatch(cr,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("", "", cr.snippet(), 1)));
     }

     public void throwCheckedException() {
         String message = "error_message";
         SnippetEvent cr = assertEvalException("throw new Exception(\"" + message + "\");");
         assertExceptionMatch(cr,
                 new ExceptionInfo(Exception.class, message,
                         newStackTraceElement("", "", cr.snippet(), 1)));
     }

     public void throwFromStaticMethodOfClass() {
         String message = "error_message";
         Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
         Snippet s2 = classKey(assertEval("class A { static void g() { f(); } }"));
         SnippetEvent cr3 = assertEvalException("A.g();");
         assertExceptionMatch(cr3,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("", "f", s1, 1),
                         newStackTraceElement("A", "g", s2, 1),
                         newStackTraceElement("", "", cr3.snippet(), 1)));
     }

     public void throwFromStaticMethodOfInterface() {
         String message = "error_message";
         Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
         Snippet s2 = classKey(assertEval("interface A { static void g() { f(); } }"));
         SnippetEvent cr3 = assertEvalException("A.g();");
         assertExceptionMatch(cr3,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("", "f", s1, 1),
                         newStackTraceElement("A", "g", s2, 1),
                         newStackTraceElement("", "", cr3.snippet(), 1)));
     }

     public void throwFromConstructor() {
         String message = "error_message";
         Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
         Snippet s2 = classKey(assertEval("class A { A() { f(); } }"));
         SnippetEvent cr3 = assertEvalException("new A();");
         assertExceptionMatch(cr3,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("", "f", s1, 1),
                         newStackTraceElement("A", "<init>", s2, 1),
                         newStackTraceElement("", "", cr3.snippet(), 1)));
     }

     public void throwFromDefaultMethodOfInterface() {
         String message = "error_message";
         Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
         Snippet s2 = classKey(assertEval("interface A { default void g() { f(); } }"));
         SnippetEvent cr3 = assertEvalException("new A() { }.g();");
         assertExceptionMatch(cr3,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("", "f", s1, 1),
                         newStackTraceElement("A", "g", s2, 1),
                         newStackTraceElement("", "", cr3.snippet(), 1)));
     }

     public void throwFromLambda() {
         String message = "lambda";
         Snippet s1 = varKey(assertEval(
                 "Runnable run = () -> {\n" +
                 "   throw new RuntimeException(\"" + message + "\");\n" +
                 "};"
         ));
         SnippetEvent cr2 = assertEvalException("run.run();");
         assertExceptionMatch(cr2,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("", "lambda$", s1, 2),
                         newStackTraceElement("", "", cr2.snippet(), 1)));
     }

     public void throwFromAnonymousClass() {
         String message = "anonymous";
         Snippet s1 = varKey(assertEval(
                 "Runnable run = new Runnable() {\n" +
                 "   public void run() {\n"+
                 "       throw new RuntimeException(\"" + message + "\");\n" +
                 "   }\n" +
                 "};"
         ));
         SnippetEvent cr2 = assertEvalException("run.run();");
         assertExceptionMatch(cr2,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("1", "run", s1, 3),
                         newStackTraceElement("", "", cr2.snippet(), 1)));
     }

     public void throwFromLocalClass() {
         String message = "local";
         Snippet s1 = methodKey(assertEval(
                 "void f() {\n" +
                 "   class A {\n" +
                 "       void f() {\n"+
                 "           throw new RuntimeException(\"" + message + "\");\n" +
                 "       }\n" +
                 "   }\n" +
                 "   new A().f();\n" +
                 "}"
         ));
         SnippetEvent cr2 = assertEvalException("f();");
         assertExceptionMatch(cr2,
                 new ExceptionInfo(RuntimeException.class, message,
                         newStackTraceElement("1A", "f", s1, 4),
                         newStackTraceElement("", "f", s1, 7),
                         newStackTraceElement("", "", cr2.snippet(), 1)));
     }

     @Test(enabled = false) // TODO 8129427
     public void outOfMemory() {
         assertEval("import java.util.*;");
         assertEval("List<byte[]> list = new ArrayList<>();");
         assertExecuteException("while (true) { list.add(new byte[10000]); }", OutOfMemoryError.class);
     }

     public void stackOverflow() {
         assertEval("void f() { f(); }");
         assertExecuteException("f();", StackOverflowError.class);
     }

     private StackTraceElement newStackTraceElement(String className, String methodName, Snippet key, int lineNumber) {
         return new StackTraceElement(className, methodName, "#" + key.id(), lineNumber);
     }

     private static class ExceptionInfo {
         public final Class<? extends Throwable> exception;
         public final String message;
         public final StackTraceElement[] stackTraceElements;

         public ExceptionInfo(Class<? extends Throwable> exception, String message, StackTraceElement...stackTraceElements) {
             this.exception = exception;
             this.message = message;
             this.stackTraceElements = stackTraceElements.length == 0 ? null : stackTraceElements;
         }
     }

     private void assertExecuteException(String input, Class<? extends Throwable> exception) {
         assertExceptionMatch(assertEvalException(input), new ExceptionInfo(exception, null));
     }

     private void assertExceptionMatch(SnippetEvent cr, ExceptionInfo exceptionInfo) {
         assertNotNull(cr.exception(), "Expected exception was not thrown: " + exceptionInfo.exception);
         if (cr.exception() instanceof EvalException) {
             EvalException ex = (EvalException) cr.exception();
             String actualException = ex.getExceptionClassName();
             String expectedException = exceptionInfo.exception.getCanonicalName();
             String stackTrace = getStackTrace(ex);
             String source = cr.snippet().source();
             assertEquals(actualException, expectedException,
                     String.format("Given \"%s\" expected exception: %s, got: %s%nStack trace:%n%s",
                             source, expectedException, actualException, stackTrace));
             if (exceptionInfo.message != null) {
                 assertEquals(ex.getMessage(), exceptionInfo.message,
                         String.format("Given \"%s\" expected message: %s, got: %s",
                                 source, exceptionInfo.message, ex.getMessage()));
             }
             if (exceptionInfo.stackTraceElements != null) {
                 assertStackTrace(ex.getStackTrace(), exceptionInfo.stackTraceElements,
                         String.format("Given \"%s\"%nStack trace:%n%s%n",
                                 source, stackTrace));
             }
         } else {
             fail("Unexpected execution exceptionInfo: " + cr.exception());
         }
     }

     private void assertStackTrace(StackTraceElement[] actual, StackTraceElement[] expected, String message) {
         if (actual != expected) {
             if (actual == null || expected == null) {
                 fail(message);
             } else {
                 assertEquals(actual.length, expected.length, message + " : arrays do not have the same size");
                 for (int i = 0; i < actual.length; ++i) {
                     StackTraceElement actualElement = actual[i];
                     StackTraceElement expectedElement = expected[i];
                     assertEquals(actualElement.getClassName(), expectedElement.getClassName(), message + " : class names");
                     String expectedMethodName = expectedElement.getMethodName();
                     if (expectedMethodName.startsWith("lambda$")) {
                         assertTrue(actualElement.getMethodName().startsWith("lambda$"), message + " : method names");
                     } else {
                         assertEquals(actualElement.getMethodName(), expectedElement.getMethodName(), message + " : method names");
                     }
                     assertEquals(actualElement.getFileName(), expectedElement.getFileName(), message + " : file names");
                     assertEquals(actualElement.getLineNumber(), expectedElement.getLineNumber(), message + " : line numbers");
                 }
             }
         }
     }

     private String getStackTrace(EvalException ex) {
         StringWriter st = new StringWriter();
         ex.printStackTrace(new PrintWriter(st));
         return st.toString();
     }
 }
	/*
	* 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 exceptions
	* @build KullaTesting TestingInputStream
	* @run testng ExceptionsTest
	*/

	import jdk.jshell.SnippetEvent;
	import jdk.jshell.EvalException;
	import java.io.PrintWriter;
	import java.io.StringWriter;

	import jdk.jshell.Snippet;
	import org.testng.annotations.Test;

	import static org.testng.Assert.*;

	@Test
	public class ExceptionsTest extends KullaTesting {

	public void throwUncheckedException() {
	String message = "error_message";
	SnippetEvent cr = assertEvalException("throw new RuntimeException(\"" + message + "\");");
	assertExceptionMatch(cr,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("", "", cr.snippet(), 1)));
	}

	public void throwCheckedException() {
	String message = "error_message";
	SnippetEvent cr = assertEvalException("throw new Exception(\"" + message + "\");");
	assertExceptionMatch(cr,
	new ExceptionInfo(Exception.class, message,
	newStackTraceElement("", "", cr.snippet(), 1)));
	}

	public void throwFromStaticMethodOfClass() {
	String message = "error_message";
	Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
	Snippet s2 = classKey(assertEval("class A { static void g() { f(); } }"));
	SnippetEvent cr3 = assertEvalException("A.g();");
	assertExceptionMatch(cr3,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("", "f", s1, 1),
	newStackTraceElement("A", "g", s2, 1),
	newStackTraceElement("", "", cr3.snippet(), 1)));
	}

	public void throwFromStaticMethodOfInterface() {
	String message = "error_message";
	Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
	Snippet s2 = classKey(assertEval("interface A { static void g() { f(); } }"));
	SnippetEvent cr3 = assertEvalException("A.g();");
	assertExceptionMatch(cr3,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("", "f", s1, 1),
	newStackTraceElement("A", "g", s2, 1),
	newStackTraceElement("", "", cr3.snippet(), 1)));
	}

	public void throwFromConstructor() {
	String message = "error_message";
	Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
	Snippet s2 = classKey(assertEval("class A { A() { f(); } }"));
	SnippetEvent cr3 = assertEvalException("new A();");
	assertExceptionMatch(cr3,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("", "f", s1, 1),
	newStackTraceElement("A", "<init>", s2, 1),
	newStackTraceElement("", "", cr3.snippet(), 1)));
	}

	public void throwFromDefaultMethodOfInterface() {
	String message = "error_message";
	Snippet s1 = methodKey(assertEval("void f() { throw new RuntimeException(\"" + message + "\"); }"));
	Snippet s2 = classKey(assertEval("interface A { default void g() { f(); } }"));
	SnippetEvent cr3 = assertEvalException("new A() { }.g();");
	assertExceptionMatch(cr3,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("", "f", s1, 1),
	newStackTraceElement("A", "g", s2, 1),
	newStackTraceElement("", "", cr3.snippet(), 1)));
	}

	public void throwFromLambda() {
	String message = "lambda";
	Snippet s1 = varKey(assertEval(
	"Runnable run = () -> {\n" +
	" throw new RuntimeException(\"" + message + "\");\n" +
	"};"
	));
	SnippetEvent cr2 = assertEvalException("run.run();");
	assertExceptionMatch(cr2,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("", "lambda$", s1, 2),
	newStackTraceElement("", "", cr2.snippet(), 1)));
	}

	public void throwFromAnonymousClass() {
	String message = "anonymous";
	Snippet s1 = varKey(assertEval(
	"Runnable run = new Runnable() {\n" +
	" public void run() {\n"+
	" throw new RuntimeException(\"" + message + "\");\n" +
	" }\n" +
	"};"
	));
	SnippetEvent cr2 = assertEvalException("run.run();");
	assertExceptionMatch(cr2,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("1", "run", s1, 3),
	newStackTraceElement("", "", cr2.snippet(), 1)));
	}

	public void throwFromLocalClass() {
	String message = "local";
	Snippet s1 = methodKey(assertEval(
	"void f() {\n" +
	" class A {\n" +
	" void f() {\n"+
	" throw new RuntimeException(\"" + message + "\");\n" +
	" }\n" +
	" }\n" +
	" new A().f();\n" +
	"}"
	));
	SnippetEvent cr2 = assertEvalException("f();");
	assertExceptionMatch(cr2,
	new ExceptionInfo(RuntimeException.class, message,
	newStackTraceElement("1A", "f", s1, 4),
	newStackTraceElement("", "f", s1, 7),
	newStackTraceElement("", "", cr2.snippet(), 1)));
	}

	@Test(enabled = false) // TODO 8129427
	public void outOfMemory() {
	assertEval("import java.util.*;");
	assertEval("List<byte[]> list = new ArrayList<>();");
	assertExecuteException("while (true) { list.add(new byte[10000]); }", OutOfMemoryError.class);
	}

	public void stackOverflow() {
	assertEval("void f() { f(); }");
	assertExecuteException("f();", StackOverflowError.class);
	}

	private StackTraceElement newStackTraceElement(String className, String methodName, Snippet key, int lineNumber) {
	return new StackTraceElement(className, methodName, "#" + key.id(), lineNumber);
	}

	private static class ExceptionInfo {
	public final Class<? extends Throwable> exception;
	public final String message;
	public final StackTraceElement[] stackTraceElements;

	public ExceptionInfo(Class<? extends Throwable> exception, String message, StackTraceElement...stackTraceElements) {
	this.exception = exception;
	this.message = message;
	this.stackTraceElements = stackTraceElements.length == 0 ? null : stackTraceElements;
	}
	}

	private void assertExecuteException(String input, Class<? extends Throwable> exception) {
	assertExceptionMatch(assertEvalException(input), new ExceptionInfo(exception, null));
	}

	private void assertExceptionMatch(SnippetEvent cr, ExceptionInfo exceptionInfo) {
	assertNotNull(cr.exception(), "Expected exception was not thrown: " + exceptionInfo.exception);
	if (cr.exception() instanceof EvalException) {
	EvalException ex = (EvalException) cr.exception();
	String actualException = ex.getExceptionClassName();
	String expectedException = exceptionInfo.exception.getCanonicalName();
	String stackTrace = getStackTrace(ex);
	String source = cr.snippet().source();
	assertEquals(actualException, expectedException,
	String.format("Given \"%s\" expected exception: %s, got: %s%nStack trace:%n%s",
	source, expectedException, actualException, stackTrace));
	if (exceptionInfo.message != null) {
	assertEquals(ex.getMessage(), exceptionInfo.message,
	String.format("Given \"%s\" expected message: %s, got: %s",
	source, exceptionInfo.message, ex.getMessage()));
	}
	if (exceptionInfo.stackTraceElements != null) {
	assertStackTrace(ex.getStackTrace(), exceptionInfo.stackTraceElements,
	String.format("Given \"%s\"%nStack trace:%n%s%n",
	source, stackTrace));
	}
	} else {
	fail("Unexpected execution exceptionInfo: " + cr.exception());
	}
	}

	private void assertStackTrace(StackTraceElement[] actual, StackTraceElement[] expected, String message) {
	if (actual != expected) {
	if (actual == null \|\| expected == null) {
	fail(message);
	} else {
	assertEquals(actual.length, expected.length, message + " : arrays do not have the same size");
	for (int i = 0; i < actual.length; ++i) {
	StackTraceElement actualElement = actual[i];
	StackTraceElement expectedElement = expected[i];
	assertEquals(actualElement.getClassName(), expectedElement.getClassName(), message + " : class names");
	String expectedMethodName = expectedElement.getMethodName();
	if (expectedMethodName.startsWith("lambda$")) {
	assertTrue(actualElement.getMethodName().startsWith("lambda$"), message + " : method names");
	} else {
	assertEquals(actualElement.getMethodName(), expectedElement.getMethodName(), message + " : method names");
	}
	assertEquals(actualElement.getFileName(), expectedElement.getFileName(), message + " : file names");
	assertEquals(actualElement.getLineNumber(), expectedElement.getLineNumber(), message + " : line numbers");
	}
	}
	}
	}

	private String getStackTrace(EvalException ex) {
	StringWriter st = new StringWriter();
	ex.printStackTrace(new PrintWriter(st));
	return st.toString();
	}
	}