diff -r 1c96344ecd49 -r 65ec6de1d6b4 langtools/test/jdk/jshell/DropTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/jdk/jshell/DropTest.java Mon Oct 19 19:15:16 2015 +0200 @@ -0,0 +1,216 @@ +/* + * 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 Test of JShell#drop(). + * @build KullaTesting TestingInputStream + * @run testng DropTest + */ + +import jdk.jshell.DeclarationSnippet; +import jdk.jshell.PersistentSnippet; +import org.testng.annotations.Test; + +import static jdk.jshell.Snippet.Status.*; + +@Test +public class DropTest extends KullaTesting { + + public void testDrop() { + PersistentSnippet var = varKey(assertEval("int x;")); + PersistentSnippet method = methodKey(assertEval("int mu() { return x * 4; }")); + PersistentSnippet clazz = classKey(assertEval("class C { String v() { return \"#\" + mu(); } }")); + assertDrop(var, + ste(var, VALID, DROPPED, true, null), + ste(method, VALID, RECOVERABLE_DEFINED, false, var)); + //assertDrop(method, + // ste(method, RECOVERABLE_DEFINED, DROPPED, false, null), + // ste(clazz, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, method)); + //assertDeclareFail("new C();", "compiler.err.cant.resolve.location"); + assertVariables(); + assertMethods(); + assertClasses(); + assertActiveKeys(); + + assertEval("int x = 10;", "10", + ste(var, DROPPED, VALID, true, null), + ste(method, RECOVERABLE_DEFINED, VALID, false, MAIN_SNIPPET)); + PersistentSnippet c0 = varKey(assertEval("C c0 = new C();")); + assertEval("c0.v();", "\"#40\""); + assertEval("C c = new C();"); + assertEval("c.v();", "\"#40\""); + assertEval("int mu() { return x * 3; }", + ste(MAIN_SNIPPET, VALID, VALID, false, null), + ste(method, VALID, OVERWRITTEN, false, MAIN_SNIPPET)); + assertEval("c.v();", "\"#30\""); + assertEval("class C { String v() { return \"@\" + mu(); } }", + ste(MAIN_SNIPPET, VALID, VALID, false, null), + ste(clazz, VALID, OVERWRITTEN, false, MAIN_SNIPPET)); + assertEval("c0.v();", "\"@30\""); + assertDrop(c0, + ste(c0, VALID, DROPPED, true, null)); + assertEval("c = new C();"); + assertEval("c.v();", "\"@30\""); + + assertVariables(); + assertMethods(); + assertClasses(); + assertActiveKeys(); + } + + @Test(enabled = false) // TODO 8081431 + public void testDropImport() { + PersistentSnippet imp = importKey(assertEval("import java.util.*;")); + PersistentSnippet decl = varKey( + assertEval("List list = Arrays.asList(1, 2, 3);", "[1, 2, 3]")); + assertEval("list;", "[1, 2, 3]"); + assertDrop(imp, + DiagCheck.DIAG_OK, + DiagCheck.DIAG_ERROR, + ste(imp, VALID, DROPPED, true, null), + ste(decl, VALID, RECOVERABLE_NOT_DEFINED, true, imp)); + assertDeclareFail("list;", "compiler.err.cant.resolve.location"); + } + + public void testDropVarToMethod() { + PersistentSnippet x = varKey(assertEval("int x;")); + DeclarationSnippet method = methodKey(assertEval("double mu() { return x * 4; }")); + assertEval("x == 0;", "true"); + assertEval("mu() == 0.0;", "true"); + + assertDrop(x, + ste(x, VALID, DROPPED, true, null), + ste(method, VALID, RECOVERABLE_DEFINED, false, x)); + assertUnresolvedDependencies1(method, RECOVERABLE_DEFINED, "variable x"); + assertEvalUnresolvedException("mu();", "mu", 1, 0); + + assertVariables(); + assertMethods(); + assertActiveKeys(); + } + + public void testDropMethodToMethod() { + PersistentSnippet a = methodKey(assertEval("double a() { return 2; }")); + DeclarationSnippet b = methodKey(assertEval("double b() { return a() * 10; }")); + assertEval("double c() { return b() * 3; }"); + DeclarationSnippet d = methodKey(assertEval("double d() { return c() + 1000; }")); + assertEval("d();", "1060.0"); + assertDrop(a, + ste(a, VALID, DROPPED, true, null), + ste(b, VALID, RECOVERABLE_DEFINED, false, a)); + assertUnresolvedDependencies1(b, RECOVERABLE_DEFINED, "method a()"); + assertUnresolvedDependencies(d, 0); + assertEvalUnresolvedException("d();", "b", 1, 0); + assertMethods(); + assertActiveKeys(); + } + + public void testDropClassToMethod() { + PersistentSnippet c = classKey(assertEval("class C { int f() { return 7; } }")); + DeclarationSnippet m = methodKey(assertEval("int m() { return new C().f(); }")); + assertDrop(c, + ste(c, VALID, DROPPED, true, null), + ste(m, VALID, RECOVERABLE_DEFINED, false, c)); + assertUnresolvedDependencies1(m, RECOVERABLE_DEFINED, "class C"); + assertEvalUnresolvedException("m();", "m", 1, 0); + assertActiveKeys(); + } + + public void testDropVarToClass() { + PersistentSnippet x = varKey(assertEval("int x;")); + DeclarationSnippet a = classKey(assertEval("class A { double a = 4 * x; }")); + assertDrop(x, + DiagCheck.DIAG_OK, + DiagCheck.DIAG_ERROR, + ste(x, VALID, DROPPED, true, null), + ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, x)); + assertUnresolvedDependencies1(a, RECOVERABLE_NOT_DEFINED, "variable x"); + assertDeclareFail("new A().a;", "compiler.err.cant.resolve.location"); + assertVariables(); + assertActiveKeys(); + } + + public void testDropMethodToClass() { + PersistentSnippet x = methodKey(assertEval("int x() { return 0; }")); + DeclarationSnippet a = classKey(assertEval("class A { double a = 4 * x(); }")); + assertDrop(x, + DiagCheck.DIAG_OK, + DiagCheck.DIAG_ERROR, + ste(x, VALID, DROPPED, true, null), + ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, x)); + assertUnresolvedDependencies1(a, RECOVERABLE_NOT_DEFINED, "method x()"); + assertDeclareFail("new A().a;", "compiler.err.cant.resolve.location"); + assertMethods(); + assertActiveKeys(); + } + + public void testDropClassToClass() { + PersistentSnippet a = classKey(assertEval("class A {}")); + PersistentSnippet b = classKey(assertEval("class B extends A {}")); + PersistentSnippet c = classKey(assertEval("class C extends B {}")); + PersistentSnippet d = classKey(assertEval("class D extends C {}")); + assertDrop(a, + DiagCheck.DIAG_OK, + DiagCheck.DIAG_ERROR, + ste(a, VALID, DROPPED, true, null), + ste(b, VALID, RECOVERABLE_NOT_DEFINED, true, a), + ste(c, VALID, RECOVERABLE_NOT_DEFINED, true, b), + ste(d, VALID, RECOVERABLE_NOT_DEFINED, true, c)); + assertUnresolvedDependencies1((DeclarationSnippet) b, RECOVERABLE_NOT_DEFINED, "class A"); + assertDrop(c, + DiagCheck.DIAG_OK, + DiagCheck.DIAG_ERROR, + ste(c, RECOVERABLE_NOT_DEFINED, DROPPED, false, null), + ste(d, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, c)); + assertEval("interface A {}", null, null, + DiagCheck.DIAG_OK, DiagCheck.DIAG_ERROR, + ste(a, DROPPED, VALID, true, null), + ste(b, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, MAIN_SNIPPET)); + assertClasses(); + assertActiveKeys(); + } + + public void testDropNoUpdate() { + String as1 = "class A {}"; + String as2 = "class A extends java.util.ArrayList {}"; + PersistentSnippet a = classKey(assertEval(as1, added(VALID))); + PersistentSnippet b = classKey(assertEval("class B extends A {}", added(VALID))); + PersistentSnippet ax = classKey(assertEval(as2, + ste(MAIN_SNIPPET, VALID, VALID, true, null), + ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET), + ste(b, VALID, VALID, true, MAIN_SNIPPET))); + ax = classKey(assertEval(as1, + ste(MAIN_SNIPPET, VALID, VALID, true, null), + ste(ax, VALID, OVERWRITTEN, false, MAIN_SNIPPET), + ste(b, VALID, VALID, true, MAIN_SNIPPET))); + assertDrop(b, + ste(b, VALID, DROPPED, true, null)); + ax = classKey(assertEval(as2, + ste(MAIN_SNIPPET, VALID, VALID, true, null), + ste(ax, VALID, OVERWRITTEN, false, MAIN_SNIPPET))); + assertEval(as1, + ste(MAIN_SNIPPET, VALID, VALID, true, null), + ste(ax, VALID, OVERWRITTEN, false, MAIN_SNIPPET)); + } +}