--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/langtools/jdk/jshell/MethodsTest.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,324 @@
+/*
+ * 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
+ * @bug 8080357 8167643
+ * @summary Tests for EvaluationState.methods
+ * @build KullaTesting TestingInputStream ExpectedDiagnostic
+ * @run testng MethodsTest
+ */
+
+import javax.tools.Diagnostic;
+
+import jdk.jshell.Snippet;
+import jdk.jshell.MethodSnippet;
+import jdk.jshell.Snippet.Status;
+import org.testng.annotations.Test;
+
+import static jdk.jshell.Snippet.Status.*;
+
+@Test
+public class MethodsTest extends KullaTesting {
+
+ public void noMethods() {
+ assertNumberOfActiveMethods(0);
+ }
+
+ public void testSignature1() {
+ MethodSnippet m1 = methodKey(assertEval("void f() { g(); }", added(RECOVERABLE_DEFINED)));
+ assertMethodDeclSnippet(m1, "f", "()void", RECOVERABLE_DEFINED, 1, 0);
+ MethodSnippet m2 = methodKey(assertEval("void g() { }",
+ added(VALID),
+ ste(m1, RECOVERABLE_DEFINED, VALID, false, null)));
+ assertMethodDeclSnippet(m2, "g", "()void", VALID, 0, 0);
+ }
+
+ public void testSignature2() {
+ MethodSnippet m1 = (MethodSnippet) assertDeclareFail("void f() { return g(); }", "compiler.err.prob.found.req");
+ assertMethodDeclSnippet(m1, "f", "()void", REJECTED, 0, 2);
+ MethodSnippet m2 = methodKey(assertEval("int f() { return g(); }",
+ added(RECOVERABLE_DEFINED)));
+ assertMethodDeclSnippet(m1, "f", "()void", REJECTED, 0, 2);
+ assertMethodDeclSnippet(m2, "f", "()int", RECOVERABLE_DEFINED, 1, 0);
+ }
+
+ @Test(enabled = false) // TODO 8081690
+ public void testSignature3() {
+ MethodSnippet m1 = methodKey(assertEval("void f(Bar b) { }", added(RECOVERABLE_NOT_DEFINED)));
+ assertMethodDeclSnippet(m1, "f", "(Bar)void", RECOVERABLE_NOT_DEFINED, 1, 0);
+ MethodSnippet m2 = methodKey(assertEval("void f(A.Bar b) { }", added(RECOVERABLE_NOT_DEFINED)));
+ assertMethodDeclSnippet(m1, "f", "(Bar)void", RECOVERABLE_NOT_DEFINED, 1, 0);
+ assertMethodDeclSnippet(m2, "f", "(A.Bar)void", RECOVERABLE_NOT_DEFINED, 1, 0);
+ assertDrop(m1, ste(m1, RECOVERABLE_NOT_DEFINED, DROPPED, false, null));
+ assertMethodDeclSnippet(m1, "f", "(Bar)void", DROPPED, 1, 0);
+ }
+
+ // 8080357
+ public void testNonReplUnresolved() {
+ // internal case
+ assertEval("class CCC {}", added(VALID));
+ assertEval("void f1() { CCC.xxxx(); }", added(RECOVERABLE_DEFINED));
+ // external case, not recoverable
+ assertDeclareFail("void f2() { System.xxxx(); }", "compiler.err.cant.resolve.location.args");
+ }
+
+ public void methods() {
+ assertEval("int x() { return 10; }");
+ assertEval("String y() { return null; }");
+ assertEval("long z() { return 0; }");
+ assertMethods(method("()int", "x"), method("()String", "y"), method("()long", "z"));
+ assertActiveKeys();
+ }
+
+ public void methodOverload() {
+ assertEval("int m() { return 1; }");
+ assertEval("int m(int x) { return 2; }");
+ assertEval("int m(String s) { return 3; }");
+ assertEval("int m(int x, int y) { return 4; }");
+ assertEval("int m(int x, String z) { return 5; }");
+ assertEval("int m(int x, String z, long g) { return 6; }");
+ assertMethods(
+ method("()int", "m"),
+ method("(int)int", "m"),
+ method("(String)int", "m"),
+ method("(int,int)int", "m"),
+ method("(int,String)int", "m"),
+ method("(int,String,long)int", "m")
+ );
+ assertEval("m();", "1");
+ assertEval("m(3);", "2");
+ assertEval("m(\"hi\");", "3");
+ assertEval("m(7, 8);", "4");
+ assertEval("m(7, \"eight\");", "5");
+ assertEval("m(7, \"eight\", 9L);", "6");
+ assertActiveKeys();
+ }
+
+ /***
+ public void methodOverloadDependent() {
+ assertEval("String m(String s) { return s + s; }");
+ assertEval("String m(double d) { return m(\"#\" + d); }");
+ assertEval("String m(int x) { return m(2.25 * x); }");
+ assertEval("String m() { return m(3); }");
+ assertMethods(
+ method("(String)String", "m"),
+ method("(double)String", "m"),
+ method("(int)String", "m"),
+ method("()String", "m")
+ );
+ assertEval("m();", "\"#6.75#6.75\"");
+ assertEval("m(2);", "\"#4.5#4.5\"");
+ assertEval("m(3.14);", "\"#3.14#3.14\"");
+ assertEval("m(\"hi\");", "\"hihi\"");
+ assertActiveKeys();
+ }
+ ***/
+
+ public void methodsRedeclaration1() {
+ Snippet x = methodKey(assertEval("int x() { return 10; }"));
+ Snippet y = methodKey(assertEval("String y() { return \"\"; }"));
+ assertMethods(method("()int", "x"), method("()String", "y"));
+ assertActiveKeys();
+
+ assertEval("long x() { return 0; }",
+ ste(MAIN_SNIPPET, VALID, VALID, true, null),
+ ste(x, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
+ assertMethods(method("()long", "x"), method("()String", "y"));
+ assertActiveKeys();
+
+ assertEval("String y() { return null; }",
+ ste(MAIN_SNIPPET, VALID, VALID, false, null),
+ ste(y, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
+ assertMethods(method("()long", "x"), method("()String", "y"));
+ assertActiveKeys();
+ }
+
+ public void methodsRedeclaration2() {
+ assertEval("int a() { return 1; }");
+ assertMethods(method("()int", "a"));
+ assertActiveKeys();
+
+ Snippet b = methodKey(assertEval("Integer b() { return a(); }"));
+ assertMethods(method("()int", "a"), method("()Integer", "b"));
+ assertActiveKeys();
+
+ Snippet c = methodKey(assertEval("double c() { return b(); }"));
+ assertMethods(method("()int", "a"), method("()Integer", "b"), method("()double", "c"));
+ assertActiveKeys();
+
+ assertEval("double b() { return 3.14159; }",
+ ste(MAIN_SNIPPET, VALID, VALID, true, null),
+ ste(b, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
+ assertMethods(method("()int", "a"), method("()double", "b"), method("()double", "c"));
+ assertEval("c();", "3.14159");
+ assertActiveKeys();
+ }
+
+ public void methodsRedeclaration3() {
+ Snippet x = methodKey(assertEval("int x(Object...a) { return 10; }"));
+ assertMethods(method("(Object...)int", "x"));
+ assertActiveKeys();
+
+ assertEval("int x(Object[]a) { return 10; }",
+ ste(MAIN_SNIPPET, VALID, VALID, true, null),
+ ste(x, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
+ assertMethods(method("(Object[])int", "x"));
+ assertActiveKeys();
+ }
+
+
+ public void methodsRedeclaration4() {
+ Snippet a = methodKey(assertEval("int foo(int a) { return a; }"));
+ assertEval("int x = foo(10);");
+ assertActiveKeys();
+ assertMethods(method("(int)int", "foo"));
+ assertEval("int foo(int a) { return a * a; }",
+ ste(MAIN_SNIPPET, VALID, VALID, false, null),
+ ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
+ assertActiveKeys();
+ }
+
+ public void methodsErrors() {
+ assertDeclareFail("String f();",
+ new ExpectedDiagnostic("compiler.err.missing.meth.body.or.decl.abstract", 0, 11, 7, -1, -1, Diagnostic.Kind.ERROR));
+ assertNumberOfActiveMethods(0);
+ assertActiveKeys();
+
+ assertDeclareFail("abstract String f();",
+ new ExpectedDiagnostic("jdk.eval.error.illegal.modifiers", 0, 8, 0, -1, -1, Diagnostic.Kind.ERROR));
+ assertNumberOfActiveMethods(0);
+ assertActiveKeys();
+
+ assertDeclareFail("native String f();",
+ new ExpectedDiagnostic("jdk.eval.error.illegal.modifiers", 0, 6, 0, -1, -1, Diagnostic.Kind.ERROR));
+ assertNumberOfActiveMethods(0);
+ assertActiveKeys();
+
+ assertDeclareFail("synchronized String f() {return null;}",
+ new ExpectedDiagnostic("jdk.eval.error.illegal.modifiers", 0, 12, 0, -1, -1, Diagnostic.Kind.ERROR));
+ assertNumberOfActiveMethods(0);
+ assertActiveKeys();
+
+ assertDeclareFail("int f() {}", "compiler.err.missing.ret.stmt",
+ added(REJECTED));
+ assertNumberOfActiveMethods(0);
+ assertActiveKeys();
+
+ assertEval("String x() { return \"\"; };");
+ assertMethods(method("()String", "x"));
+ assertActiveKeys();
+ }
+
+
+ public void methodsAccessModifierIgnored() {
+ Snippet f = methodKey(assertEval("public String f() {return null;}",
+ added(VALID)));
+ assertNumberOfActiveMethods(1);
+ assertActiveKeys();
+
+ f = methodKey(assertEval("protected String f() {return null;}",
+ ste(MAIN_SNIPPET, VALID, VALID, false, null),
+ ste(f, VALID, OVERWRITTEN, false, MAIN_SNIPPET)));
+ assertNumberOfActiveMethods(1);
+ assertActiveKeys();
+
+ assertEval("private String f() {return null;}",
+ ste(MAIN_SNIPPET, VALID, VALID, false, null),
+ ste(f, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
+ assertNumberOfActiveMethods(1);
+ assertActiveKeys();
+ }
+
+ public void methodsWarn() {
+ Snippet f = assertDeclareWarn1("static String f() {return null;}",
+ new ExpectedDiagnostic("jdk.eval.warn.illegal.modifiers", 0, 6, 0, -1, -1, Diagnostic.Kind.WARNING),
+ added(VALID));
+ assertNumberOfActiveMethods(1);
+ assertActiveKeys();
+
+ assertDeclareWarn1("final String f() {return null;}",
+ new ExpectedDiagnostic("jdk.eval.warn.illegal.modifiers", 0, 5, 0, -1, -1, Diagnostic.Kind.WARNING),
+ ste(MAIN_SNIPPET, VALID, VALID, false, null),
+ ste(f, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
+ assertNumberOfActiveMethods(1);
+ assertActiveKeys();
+ }
+
+ public void methodSignatureUnresolved() {
+ MethodSnippet key = (MethodSnippet) methodKey(assertEval("und m() { return new und(); }", added(RECOVERABLE_NOT_DEFINED)));
+ assertMethodDeclSnippet(key, "m", "()und", RECOVERABLE_NOT_DEFINED, 1, 0);
+ assertUnresolvedDependencies1(key, Status.RECOVERABLE_NOT_DEFINED, "class und");
+ assertEval("class und {}",
+ added(VALID),
+ ste(key, RECOVERABLE_NOT_DEFINED, VALID, true, null));
+ assertMethodDeclSnippet(key, "m", "()und", Status.VALID, 0, 0);
+ assertNumberOfActiveMethods(1);
+ assertActiveKeys();
+ }
+
+ @Test(enabled = false) // TODO 8081689
+ public void classMethodsAreNotVisible() {
+ assertEval(
+ "class A {" +
+ "int foo() {" +
+ "int x = 10;" +
+ "int y = 2 * x;" +
+ "return x * y;" +
+ "}" +
+ "}");
+ assertNumberOfActiveMethods(0);
+ assertEval("int x = 10;", "10");
+ assertEval("int foo() {" +
+ "int y = 2 * x;" +
+ "return x * y;" +
+ "}");
+ assertMethods(method("()int", "foo"));
+ assertEval("foo();", "200");
+ assertActiveKeys();
+ }
+
+ public void lambdas() {
+ assertEval("class Inner1 implements Runnable {" +
+ "public Runnable lambda1 = () -> {};" +
+ "public void function() {}" +
+ "public void run() {}" +
+ "}");
+
+ assertEval("class Inner2 {" +
+ "private Runnable lambda1 = () -> {};" +
+ "private static void staticFunction() {}" +
+ "}");
+
+ // the following method references and lambda functions
+ // generate synthetic methods
+ assertEval("Runnable run = () -> {};");
+ assertEval("Inner1 inner = new Inner1();");
+ assertEval("Runnable l1 = inner::function;");
+ assertEval("Runnable l2 = Inner1::new;");
+ assertEval("inner.lambda1 = inner::function;");
+ assertEval("java.util.stream.IntStream.of(2).mapToObj(int[]::new);");
+ assertNumberOfActiveMethods(0);
+ assertActiveKeys();
+ }
+}