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

 /*
  * 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 8081431 8080069
  * @summary Test of JShell#drop().
  * @build KullaTesting TestingInputStream
  * @run testng DropTest
  */

 import jdk.jshell.DeclarationSnippet;
 import jdk.jshell.PersistentSnippet;
 import jdk.jshell.VarSnippet;
 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, true, null),
                 ste(clazz, VALID, RECOVERABLE_DEFINED, false, method));
         VarSnippet cc = varKey(assertEval("C c;"));
         assertEvalUnresolvedException("new C();", "C", 1, 0);
         assertVariables();
         assertMethods();
         assertClasses();
         assertActiveKeys();

         method = methodKey(assertEval("int mu() { return x * 4; }",
                 ste(MAIN_SNIPPET, DROPPED, RECOVERABLE_DEFINED, true, null),
                 ste(clazz, RECOVERABLE_DEFINED, VALID, false, MAIN_SNIPPET)));
         assertEval("int x = 10;", "10",
                 ste(MAIN_SNIPPET, 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();",
                 ste(MAIN_SNIPPET, VALID, VALID, false, null),
                 ste(cc, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
         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();
     }

     public void testDropImport() {
         PersistentSnippet imp = importKey(assertEval("import java.util.*;"));
         PersistentSnippet decl = varKey(
                 assertEval("List<Integer> 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_DEFINED, false, x));
         assertEval("A foo() { return null; }");
         assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "variable x");
         assertEvalUnresolvedException("new A();", "A", 1, 0);
         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_DEFINED, false, x));
         assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "method x()");
         assertEvalUnresolvedException("new A();", "A", 1, 0);
         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<Boolean> {}";
         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));
     }
 }
	/*
	* 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 8081431 8080069
	* @summary Test of JShell#drop().
	* @build KullaTesting TestingInputStream
	* @run testng DropTest
	*/

	import jdk.jshell.DeclarationSnippet;
	import jdk.jshell.PersistentSnippet;
	import jdk.jshell.VarSnippet;
	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, true, null),
	ste(clazz, VALID, RECOVERABLE_DEFINED, false, method));
	VarSnippet cc = varKey(assertEval("C c;"));
	assertEvalUnresolvedException("new C();", "C", 1, 0);
	assertVariables();
	assertMethods();
	assertClasses();
	assertActiveKeys();

	method = methodKey(assertEval("int mu() { return x * 4; }",
	ste(MAIN_SNIPPET, DROPPED, RECOVERABLE_DEFINED, true, null),
	ste(clazz, RECOVERABLE_DEFINED, VALID, false, MAIN_SNIPPET)));
	assertEval("int x = 10;", "10",
	ste(MAIN_SNIPPET, 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();",
	ste(MAIN_SNIPPET, VALID, VALID, false, null),
	ste(cc, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
	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();
	}

	public void testDropImport() {
	PersistentSnippet imp = importKey(assertEval("import java.util.*;"));
	PersistentSnippet decl = varKey(
	assertEval("List<Integer> 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_DEFINED, false, x));
	assertEval("A foo() { return null; }");
	assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "variable x");
	assertEvalUnresolvedException("new A();", "A", 1, 0);
	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_DEFINED, false, x));
	assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "method x()");
	assertEvalUnresolvedException("new A();", "A", 1, 0);
	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<Boolean> {}";
	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));
	}
	}