Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
langtools/test/jdk/jshell/ReplaceTest.java
changeset 36499 9d823cc0fe98
parent 33362 65ec6de1d6b4
child 36780 6bf2bef08a91
equal deleted inserted replaced
36498:8a741def7f32 36499:9d823cc0fe98 
     1 /*
 
     1 /*
 
     2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 
     2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     4  *
 
     4  *
 
     5  * This code is free software; you can redistribute it and/or modify it
 
     5  * This code is free software; you can redistribute it and/or modify it
 
     6  * under the terms of the GNU General Public License version 2 only, as
 
     6  * under the terms of the GNU General Public License version 2 only, as
 
     7  * published by the Free Software Foundation.
 
     7  * published by the Free Software Foundation.
 
    20  * or visit www.oracle.com if you need additional information or have any
 
    20  * or visit www.oracle.com if you need additional information or have any
 
    21  * questions.
 
    21  * questions.
 
    22  */
 
    22  */
 
    23 
    23 
    24 /*
 
    24 /*
 
    25  * @test
 
    25  * @test 8080069
 
    26  * @summary Test of Snippet redefinition and replacement.
 
    26  * @summary Test of Snippet redefinition and replacement.
 
    27  * @build KullaTesting TestingInputStream
 
    27  * @build KullaTesting TestingInputStream
 
    28  * @run testng ReplaceTest
 
    28  * @run testng ReplaceTest
 
    29  */
 
    29  */
 
    30 
    30 
    31 import java.util.Collection;
 
    31 import java.util.Collection;
 
    32 
    32 
       
    33 import java.util.List;
 
    33 import jdk.jshell.Snippet;
 
    34 import jdk.jshell.Snippet;
 
    34 import jdk.jshell.MethodSnippet;
 
    35 import jdk.jshell.MethodSnippet;
 
    35 import jdk.jshell.PersistentSnippet;
 
    36 import jdk.jshell.PersistentSnippet;
 
    36 import jdk.jshell.TypeDeclSnippet;
 
    37 import jdk.jshell.TypeDeclSnippet;
 
    37 import jdk.jshell.VarSnippet;
 
    38 import jdk.jshell.VarSnippet;
 
    38 import jdk.jshell.DeclarationSnippet;
 
    39 import jdk.jshell.DeclarationSnippet;
 
    39 import org.testng.annotations.Test;
 
    40 import org.testng.annotations.Test;
 
    40 
    41 
       
    42 import jdk.jshell.SnippetEvent;
 
       
    43 import jdk.jshell.UnresolvedReferenceException;
 
       
    44 import static org.testng.Assert.assertEquals;
 
    41 import static jdk.jshell.Snippet.Status.*;
 
    45 import static jdk.jshell.Snippet.Status.*;
 
    42 import static jdk.jshell.Snippet.SubKind.*;
 
    46 import static jdk.jshell.Snippet.SubKind.*;
 
    43 import static org.testng.Assert.assertEquals;
 
       
    44 import static org.testng.Assert.assertTrue;
 
    47 import static org.testng.Assert.assertTrue;
 
    45 
    48 
    46 @Test
 
    49 @Test
 
    47 public class ReplaceTest extends KullaTesting {
 
    50 public class ReplaceTest extends KullaTesting {
 
    48 
    51 
   257                 DiagCheck.DIAG_OK,
 
   260                 DiagCheck.DIAG_OK,
 
   258                 DiagCheck.DIAG_ERROR,
 
   261                 DiagCheck.DIAG_ERROR,
 
   259                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   262                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   260                 ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   263                 ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   261                 ste(f, VALID, RECOVERABLE_DEFINED, false, MAIN_SNIPPET));
 
   264                 ste(f, VALID, RECOVERABLE_DEFINED, false, MAIN_SNIPPET));
 
   262         MethodSnippet exsn = assertEvalUnresolvedException("t();", "f", 0, 1);
 
   265         DeclarationSnippet exsn = assertEvalUnresolvedException("t();", "f", 0, 1);
 
   263         assertTrue(exsn == f, "Identity must not change");
 
   266         assertTrue(exsn == f, "Identity must not change");
 
   264         assertActiveKeys();
 
   267         assertActiveKeys();
 
   265     }
 
   268     }
 
   266 
   269 
   267     public void testForwardClassToMethod() {
 
   270     public void testForwardClassToMethod() {
 
   287         assertEvalUnresolvedException("t();", "t", 0, 1);
 
   290         assertEvalUnresolvedException("t();", "t", 0, 1);
 
   288         assertActiveKeys();
 
   291         assertActiveKeys();
 
   289     }
 
   292     }
 
   290 
   293 
   291     public void testForwardVarToClass() {
 
   294     public void testForwardVarToClass() {
 
   292         DeclarationSnippet a = classKey(assertEval("class A { int f() { return g; } }", added(RECOVERABLE_NOT_DEFINED)));
 
   295         DeclarationSnippet a = classKey(assertEval("class A { int f() { return g; } }", added(RECOVERABLE_DEFINED)));
 
   293         assertUnresolvedDependencies1(a, RECOVERABLE_NOT_DEFINED, "variable g");
 
   296         assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "variable g");
 
   294         Snippet g = varKey(assertEval("int g = 10;", "10",
 
   297         Snippet g = varKey(assertEval("int g = 10;", "10",
 
   295                 added(VALID),
 
   298                 added(VALID),
 
   296                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null)));
 
   299                 ste(a, RECOVERABLE_DEFINED, VALID, false, null)));
 
   297         assertEval("new A().f();", "10");
 
   300         assertEval("new A().f();", "10");
 
   298         assertEval("double g = 10;", "10.0", null,
 
   301         assertEval("double g = 10;", "10.0", null,
 
       
   302                 DiagCheck.DIAG_OK,
 
       
   303                 DiagCheck.DIAG_ERROR,
 
       
   304                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
       
   305                 ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
       
   306                 ste(a, VALID, RECOVERABLE_DEFINED, false, MAIN_SNIPPET));
 
       
   307         assertUnresolvedDependencies(a, 0);
 
       
   308         assertActiveKeys();
 
       
   309     }
 
       
   310 
       
   311     public void testForwardVarToClassGeneric() {
 
       
   312         DeclarationSnippet a = classKey(assertEval("class A<T> { final T x; A(T v) { this.x = v; } ; T get() { return x; } int core() { return g; } }", added(RECOVERABLE_DEFINED)));
 
       
   313         assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "variable g");
 
       
   314 
       
   315         List<SnippetEvent> events = assertEval("A<String> as = new A<>(\"hi\");", null,
 
       
   316                 UnresolvedReferenceException.class, DiagCheck.DIAG_OK, DiagCheck.DIAG_OK, null);
 
       
   317         SnippetEvent ste = events.get(0);
 
       
   318         Snippet assn = ste.snippet();
 
       
   319         DeclarationSnippet unsn = ((UnresolvedReferenceException) ste.exception()).getSnippet();
 
       
   320         assertEquals(unsn.name(), "A", "Wrong with unresolved");
 
       
   321         assertEquals(getState().unresolvedDependencies(unsn).size(), 1, "Wrong size unresolved");
 
       
   322         assertEquals(getState().diagnostics(unsn).size(), 0, "Expected no diagnostics");
 
       
   323 
       
   324         Snippet g = varKey(assertEval("int g = 10;", "10",
 
       
   325                 added(VALID),
 
       
   326                 ste(a, RECOVERABLE_DEFINED, VALID, false, MAIN_SNIPPET)));
 
       
   327         assertEval("A<String> as = new A<>(\"low\");",
 
       
   328                 ste(MAIN_SNIPPET, VALID, VALID, false, null),
 
       
   329                 ste(assn, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
 
       
   330         assertEval("as.get();", "\"low\"");
 
       
   331         assertUnresolvedDependencies(a, 0);
 
       
   332         assertActiveKeys();
 
       
   333     }
 
       
   334 
       
   335    public void testForwardVarToClassExtendsImplements() {
 
       
   336         DeclarationSnippet ik = classKey(assertEval("interface I { default int ii() { return 1; } }", added(VALID)));
 
       
   337         DeclarationSnippet jk = classKey(assertEval("interface J { default int jj() { return 2; } }", added(VALID)));
 
       
   338         DeclarationSnippet ck = classKey(assertEval("class C { int cc() { return 3; } }", added(VALID)));
 
       
   339         DeclarationSnippet dk = classKey(assertEval("class D extends C implements I,J { int dd() { return g; } }", added(RECOVERABLE_DEFINED)));
 
       
   340         DeclarationSnippet ek = classKey(assertEval("class E extends D { int ee() { return 5; } }", added(VALID)));
 
       
   341         assertUnresolvedDependencies1(dk, RECOVERABLE_DEFINED, "variable g");
 
       
   342         assertEvalUnresolvedException("new D();", "D", 1, 0);
 
       
   343         assertEvalUnresolvedException("new E();", "D", 1, 0);
 
       
   344         VarSnippet g = varKey(assertEval("int g = 10;", "10",
 
       
   345                 added(VALID),
 
       
   346                 ste(dk, RECOVERABLE_DEFINED, VALID, false, MAIN_SNIPPET)));
 
       
   347         assertEval("E e = new E();");
 
       
   348         assertDrop(g,
 
       
   349                 ste(g, VALID, DROPPED, true, null),
 
       
   350                 ste(dk, VALID, RECOVERABLE_DEFINED, false, g));
 
       
   351         assertEvalUnresolvedException("new D();", "D", 1, 0);
 
       
   352         assertEvalUnresolvedException("new E();", "D", 1, 0);
 
       
   353         assertEval("e.ee();", "5");
 
       
   354         assertEvalUnresolvedException("e.dd();", "D", 1, 0);
 
       
   355         assertEval("e.cc();", "3");
 
       
   356         assertEval("e.jj();", "2");
 
       
   357         assertEval("e.ii();", "1");
 
       
   358         assertActiveKeys();
 
       
   359     }
 
       
   360 
       
   361     public void testForwardVarToInterface() {
 
       
   362         DeclarationSnippet i = classKey(assertEval("interface I { default int f() { return x; } }", added(RECOVERABLE_DEFINED)));
 
       
   363         assertUnresolvedDependencies1(i, RECOVERABLE_DEFINED, "variable x");
 
       
   364         DeclarationSnippet c = classKey(assertEval("class C implements I { int z() { return 2; } }", added(VALID)));
 
       
   365         assertEval("C c = new C();");
 
       
   366         assertEval("c.z();", "2");
 
       
   367         assertEvalUnresolvedException("c.f()", "I", 1, 0);
 
       
   368         Snippet g = varKey(assertEval("int x = 55;", "55",
 
       
   369                 added(VALID),
 
       
   370                 ste(i, RECOVERABLE_DEFINED, VALID, false, null)));
 
       
   371         assertEval("c.f();", "55");
 
       
   372         assertUnresolvedDependencies(i, 0);
 
       
   373         assertActiveKeys();
 
       
   374     }
 
       
   375 
       
   376     public void testForwardVarToEnum() {
 
       
   377         DeclarationSnippet a = classKey(assertEval("enum E { Q, W, E; float ff() { return fff; } }", added(RECOVERABLE_NOT_DEFINED)));
 
       
   378         assertUnresolvedDependencies1(a, RECOVERABLE_NOT_DEFINED, "variable fff");
 
       
   379         Snippet g = varKey(assertEval("float fff = 4.5f;", "4.5",
 
       
   380                 added(VALID),
 
       
   381                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null)));
 
       
   382         assertEval("E.Q.ff();", "4.5");
 
       
   383         assertEval("double fff = 3.3;", "3.3", null,
 
   299                 DiagCheck.DIAG_OK,
 
   384                 DiagCheck.DIAG_OK,
 
   300                 DiagCheck.DIAG_ERROR,
 
   385                 DiagCheck.DIAG_ERROR,
 
   301                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   386                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   302                 ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   387                 ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   303                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET));
 
   388                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET));
 
   304         assertUnresolvedDependencies(a, 0);
 
   389         assertUnresolvedDependencies(a, 0);
 
   305         assertActiveKeys();
 
   390         assertActiveKeys();
 
   306     }
 
   391     }
 
   307 
   392 
   308 
       
   309     public void testForwardMethodToClass() {
 
   393     public void testForwardMethodToClass() {
 
   310         DeclarationSnippet a = classKey(assertEval("class A { int f() { return g(); } }", added(RECOVERABLE_NOT_DEFINED)));
 
   394         DeclarationSnippet a = classKey(assertEval("class A { int f() { return g(); } }", added(RECOVERABLE_DEFINED)));
 
   311         assertUnresolvedDependencies1(a, RECOVERABLE_NOT_DEFINED, "method g()");
 
   395         assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "method g()");
 
       
   396         assertEval("A foo() { return null; }");
 
       
   397         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   312         Snippet g = methodKey(assertEval("int g() { return 10; }",
 
   398         Snippet g = methodKey(assertEval("int g() { return 10; }",
 
   313                 added(VALID),
 
   399                 added(VALID),
 
   314                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null)));
 
   400                 ste(a, RECOVERABLE_DEFINED, VALID, false, null)));
 
   315         assertEval("new A().f();", "10");
 
   401         assertEval("new A().f();", "10");
 
   316         assertEval("double g() { return 10; }",
 
   402         assertEval("double g() { return 10; }",
 
   317                 DiagCheck.DIAG_OK,
 
   403                 DiagCheck.DIAG_OK,
 
   318                 DiagCheck.DIAG_ERROR,
 
   404                 DiagCheck.DIAG_ERROR,
 
   319                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   405                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   320                 ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   406                 ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   321                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET));
 
   407                 ste(a, VALID, RECOVERABLE_DEFINED, false, MAIN_SNIPPET));
 
   322         assertUnresolvedDependencies(a, 0);
 
   408         assertUnresolvedDependencies(a, 0);
 
   323         assertActiveKeys();
 
   409         assertActiveKeys();
 
   324     }
 
   410     }
 
   325 
   411 
   326     public void testForwardClassToClass1() {
 
   412     public void testForwardClassToClass1() {
 
   334         assertEval("interface B { }",
 
   420         assertEval("interface B { }",
 
   335                 DiagCheck.DIAG_OK,
 
   421                 DiagCheck.DIAG_OK,
 
   336                 DiagCheck.DIAG_ERROR,
 
   422                 DiagCheck.DIAG_ERROR,
 
   337                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   423                 ste(MAIN_SNIPPET, VALID, VALID, true, null),
 
   338                 ste(b, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   424                 ste(b, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
 
   339                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET));
 
   425                 ste(a, VALID, RECOVERABLE_DEFINED, true, MAIN_SNIPPET));
 
   340         assertDeclareFail("new A().b;", "compiler.err.cant.resolve.location");
 
   426         assertEvalUnresolvedException("new A().b;", "A", 0, 1);
 
   341         assertActiveKeys();
 
   427         assertActiveKeys();
 
   342     }
 
   428     }
 
   343 
   429 
   344     public void testForwardClassToClass2() {
 
   430     public void testForwardClassToClass2() {
 
   345         Snippet a = classKey(assertEval("class A extends B { }", added(RECOVERABLE_NOT_DEFINED)));
 
   431         Snippet a = classKey(assertEval("class A extends B { }", added(RECOVERABLE_NOT_DEFINED)));
 
   501         assertActiveKeys();
 
   587         assertActiveKeys();
 
   502     }
 
   588     }
 
   503 
   589 
   504     public void testForwardSingleImportMethodToClass1() {
 
   590     public void testForwardSingleImportMethodToClass1() {
 
   505         PersistentSnippet a = classKey(assertEval("class A { String s = format(\"%d\", 10); }",
 
   591         PersistentSnippet a = classKey(assertEval("class A { String s = format(\"%d\", 10); }",
 
   506                 added(RECOVERABLE_NOT_DEFINED)));
 
   592                 added(RECOVERABLE_DEFINED)));
 
   507         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   593         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   508         assertEval("import static java.lang.String.format;",
 
   594         assertEval("import static java.lang.String.format;",
 
   509                 added(VALID),
 
   595                 added(VALID),
 
   510                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   596                 ste(a, RECOVERABLE_DEFINED, VALID, false, null));
 
   511         assertEval("new A().s;", "\"10\"");
 
   597         assertEval("new A().s;", "\"10\"");
 
   512         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   598         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   513                 DiagCheck.DIAG_OK,
 
   599                 DiagCheck.DIAG_OK,
 
   514                 DiagCheck.DIAG_ERROR,
 
   600                 DiagCheck.DIAG_ERROR,
 
   515                 added(VALID),
 
   601                 added(VALID),
 
   516                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET)));
 
   602                 ste(a, VALID, RECOVERABLE_DEFINED, false, MAIN_SNIPPET)));
 
   517         assertDeclareFail("new A().s;", "compiler.err.cant.resolve.location");
 
   603         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   518         assertActiveKeys();
 
   604         assertActiveKeys();
 
   519         assertDrop(format,
 
   605         assertDrop(format,
 
   520                 ste(format, VALID, DROPPED, true, null),
 
   606                 ste(format, VALID, DROPPED, true, null),
 
   521                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, format));
 
   607                 ste(a, RECOVERABLE_DEFINED, VALID, false, format));
 
   522     }
 
   608     }
 
   523 
   609 
   524     public void testForwardSingleImportMethodToClass2() {
 
   610     public void testForwardSingleImportMethodToClass2() {
 
   525         PersistentSnippet a = classKey(assertEval("class A { String s() { return format(\"%d\", 10); } }",
 
   611         PersistentSnippet a = classKey(assertEval("class A { String s() { return format(\"%d\", 10); } }",
 
   526                 added(RECOVERABLE_NOT_DEFINED)));
 
   612                 added(RECOVERABLE_DEFINED)));
 
   527         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   613         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   528         assertEval("import static java.lang.String.format;",
 
   614         assertEval("import static java.lang.String.format;",
 
   529                 added(VALID),
 
   615                 added(VALID),
 
   530                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   616                 ste(a, RECOVERABLE_DEFINED, VALID, false, null));
 
   531         assertEval("new A().s();", "\"10\"");
 
   617         assertEval("new A().s();", "\"10\"");
 
   532         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   618         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   533                 DiagCheck.DIAG_OK,
 
   619                 DiagCheck.DIAG_OK,
 
   534                 DiagCheck.DIAG_ERROR,
 
   620                 DiagCheck.DIAG_ERROR,
 
   535                 added(VALID),
 
   621                 added(VALID),
 
   536                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
 
   622                 ste(a, VALID, RECOVERABLE_DEFINED, false, null)));
 
   537         assertDeclareFail("new A().s();", "compiler.err.cant.resolve.location");
 
   623         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   538         assertActiveKeys();
 
   624         assertActiveKeys();
 
   539         assertDrop(format,
 
   625         assertDrop(format,
 
   540                 ste(format, VALID, DROPPED, true, null),
 
   626                 ste(format, VALID, DROPPED, true, null),
 
   541                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, format));
 
   627                 ste(a, RECOVERABLE_DEFINED, VALID, false, format));
 
   542     }
 
   628     }
 
   543 
   629 
   544     public void testForwardSingleImportClassToClass1() {
 
   630     public void testForwardSingleImportClassToClass1() {
 
   545         PersistentSnippet a = classKey(assertEval("class A { static List<Integer> list; }",
 
   631         PersistentSnippet a = classKey(assertEval("class A { static List<Integer> list; }",
 
   546                 added(RECOVERABLE_NOT_DEFINED)));
 
   632                 added(RECOVERABLE_NOT_DEFINED)));
 
   587                 ste(clsA, RECOVERABLE_NOT_DEFINED, VALID, true, arraylist));
 
   673                 ste(clsA, RECOVERABLE_NOT_DEFINED, VALID, true, arraylist));
 
   588     }
 
   674     }
 
   589 
   675 
   590     public void testForwardImportOnDemandMethodToClass1() {
 
   676     public void testForwardImportOnDemandMethodToClass1() {
 
   591         PersistentSnippet a = classKey(assertEval("class A { String s = format(\"%d\", 10); }",
 
   677         PersistentSnippet a = classKey(assertEval("class A { String s = format(\"%d\", 10); }",
 
   592                 added(RECOVERABLE_NOT_DEFINED)));
 
   678                 added(RECOVERABLE_DEFINED)));
 
   593         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   679         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   594         assertEval("import static java.lang.String.*;",
 
   680         assertEval("import static java.lang.String.*;",
 
   595                 added(VALID),
 
   681                 added(VALID),
 
   596                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   682                 ste(a, RECOVERABLE_DEFINED, VALID, false, null));
 
   597         assertEval("new A().s;", "\"10\"");
 
   683         assertEval("A x = new A();");
 
       
   684         assertEval("x.s;", "\"10\"");
 
   598         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   685         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   599                 DiagCheck.DIAG_OK,
 
   686                 DiagCheck.DIAG_OK,
 
   600                 DiagCheck.DIAG_ERROR,
 
   687                 DiagCheck.DIAG_ERROR,
 
   601                 added(VALID),
 
   688                 added(VALID),
 
   602                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
 
   689                 ste(a, VALID, RECOVERABLE_DEFINED, false, null)));
 
   603         assertDeclareFail("new A().s;", "compiler.err.cant.resolve.location");
 
   690         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   604         assertActiveKeys();
 
   691         assertActiveKeys();
 
   605         assertDrop(format,
 
   692         assertDrop(format,
 
   606                 ste(format, VALID, DROPPED, true, null),
 
   693                 ste(format, VALID, DROPPED, true, null),
 
   607                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, format));
 
   694                 ste(a, RECOVERABLE_DEFINED, VALID, false, format));
 
       
   695         assertEval("x.s;", "\"10\"");
 
   608     }
 
   696     }
 
   609 
   697 
   610     public void testForwardImportOnDemandMethodToClass2() {
 
   698     public void testForwardImportOnDemandMethodToClass2() {
 
   611         PersistentSnippet a = classKey(assertEval("class A { String s() { return format(\"%d\", 10); } }",
 
   699         PersistentSnippet a = classKey(assertEval("class A { String s() { return format(\"%d\", 10); } }",
 
   612                 added(RECOVERABLE_NOT_DEFINED)));
 
   700                 added(RECOVERABLE_DEFINED)));
 
   613         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   701         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   614         assertEval("import static java.lang.String.*;",
 
   702         assertEval("import static java.lang.String.*;",
 
   615                 added(VALID),
 
   703                 added(VALID),
 
   616                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   704                 ste(a, RECOVERABLE_DEFINED, VALID, false, null));
 
   617         assertEval("new A().s();", "\"10\"");
 
   705         assertEval("new A().s();", "\"10\"");
 
   618         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   706         PersistentSnippet format = methodKey(assertEval("void format(String s, int d) { }",
 
   619                 DiagCheck.DIAG_OK,
 
   707                 DiagCheck.DIAG_OK,
 
   620                 DiagCheck.DIAG_ERROR,
 
   708                 DiagCheck.DIAG_ERROR,
 
   621                 added(VALID),
 
   709                 added(VALID),
 
   622                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
 
   710                 ste(a, VALID, RECOVERABLE_DEFINED, false, null)));
 
   623         assertDeclareFail("new A().s();", "compiler.err.cant.resolve.location");
 
   711         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   624         assertActiveKeys();
 
   712         assertActiveKeys();
 
   625         assertDrop(format,
 
   713         assertDrop(format,
 
   626                 ste(format, VALID, DROPPED, true, null),
 
   714                 ste(format, VALID, DROPPED, true, null),
 
   627                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, format));
 
   715                 ste(a, RECOVERABLE_DEFINED, VALID, false, format));
 
   628     }
 
   716     }
 
   629 
   717 
   630     public void testForwardImportOnDemandClassToClass1() {
 
   718     public void testForwardImportOnDemandClassToClass1() {
 
   631         PersistentSnippet a = classKey(assertEval("class A { static List<Integer> list; }",
 
   719         PersistentSnippet a = classKey(assertEval("class A { static List<Integer> list; }",
 
   632                 added(RECOVERABLE_NOT_DEFINED)));
 
   720                 added(RECOVERABLE_NOT_DEFINED)));
 
   671                 ste(vara, RECOVERABLE_NOT_DEFINED, VALID, true, clsA));
 
   759                 ste(vara, RECOVERABLE_NOT_DEFINED, VALID, true, clsA));
 
   672     }
 
   760     }
 
   673 
   761 
   674     public void testForwardSingleImportFieldToClass1() {
 
   762     public void testForwardSingleImportFieldToClass1() {
 
   675         PersistentSnippet a = classKey(assertEval("class A { static double pi() { return PI; } }",
 
   763         PersistentSnippet a = classKey(assertEval("class A { static double pi() { return PI; } }",
 
   676                 added(RECOVERABLE_NOT_DEFINED)));
 
   764                 added(RECOVERABLE_DEFINED)));
 
   677         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   765         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   678         assertEval("import static java.lang.Math.PI;",
 
   766         assertEval("import static java.lang.Math.PI;",
 
   679                 added(VALID),
 
   767                 added(VALID),
 
   680                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   768                 ste(a, RECOVERABLE_DEFINED, VALID, false, null));
 
   681         assertEval("Math.abs(A.pi() - 3.1415) < 0.001;", "true");
 
   769         assertEval("Math.abs(A.pi() - 3.1415) < 0.001;", "true");
 
   682 
   770 
   683         PersistentSnippet list = varKey(assertEval("String PI;",
 
   771         PersistentSnippet list = varKey(assertEval("String PI;",
 
   684                 DiagCheck.DIAG_OK,
 
   772                 DiagCheck.DIAG_OK,
 
   685                 DiagCheck.DIAG_ERROR,
 
   773                 DiagCheck.DIAG_ERROR,
 
   686                 added(VALID),
 
   774                 added(VALID),
 
   687                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
 
   775                 ste(a, VALID, RECOVERABLE_DEFINED, false, null)));
 
   688         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   776         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   689         assertActiveKeys();
 
   777         assertActiveKeys();
 
   690         assertDrop(list,
 
   778         assertDrop(list,
 
   691                 ste(list, VALID, DROPPED, true, null),
 
   779                 ste(list, VALID, DROPPED, true, null),
 
   692                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, list));
 
   780                 ste(a, RECOVERABLE_DEFINED, VALID, false, list));
 
   693     }
 
   781     }
 
   694 
   782 
   695     public void testForwardSingleImportFieldToClass2() {
 
   783     public void testForwardSingleImportFieldToClass2() {
 
   696         PersistentSnippet a = classKey(assertEval("class A { static double pi = PI; }",
 
   784         PersistentSnippet a = classKey(assertEval("class A { static double pi = PI; }",
 
   697                 added(RECOVERABLE_NOT_DEFINED)));
 
   785                 added(RECOVERABLE_DEFINED)));
 
   698         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   786         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   699         assertEval("import static java.lang.Math.PI;",
 
   787         assertEval("import static java.lang.Math.PI;",
 
   700                 added(VALID),
 
   788                 added(VALID),
 
   701                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   789                 ste(a, RECOVERABLE_DEFINED, VALID, true, null));
 
   702         assertEval("Math.abs(A.pi - 3.1415) < 0.001;", "true");
 
   790         assertEval("Math.abs(A.pi - 3.1415) < 0.001;", "true");
 
   703 
   791 
   704         PersistentSnippet list = varKey(assertEval("String PI;",
 
   792         PersistentSnippet list = varKey(assertEval("String PI;",
 
   705                 DiagCheck.DIAG_OK,
 
   793                 DiagCheck.DIAG_OK,
 
   706                 DiagCheck.DIAG_ERROR,
 
   794                 DiagCheck.DIAG_ERROR,
 
   707                 added(VALID),
 
   795                 added(VALID),
 
   708                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
 
   796                 ste(a, VALID, RECOVERABLE_DEFINED, true, null)));
 
   709         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   797         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   710         assertActiveKeys();
 
   798         assertActiveKeys();
 
   711         assertDrop(list,
 
   799         assertDrop(list,
 
   712                 ste(list, VALID, DROPPED, true, null),
 
   800                 ste(list, VALID, DROPPED, true, null),
 
   713                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, list));
 
   801                 ste(a, RECOVERABLE_DEFINED, VALID, true, list));
 
   714     }
 
   802     }
 
   715 
   803 
   716     public void testForwardImportOnDemandFieldToClass1() {
 
   804     public void testForwardImportOnDemandFieldToClass1() {
 
   717         PersistentSnippet a = classKey(assertEval("class A { static double pi() { return PI; } }",
 
   805         PersistentSnippet a = classKey(assertEval("class A { static double pi() { return PI; } }",
 
   718                 added(RECOVERABLE_NOT_DEFINED)));
 
   806                 added(RECOVERABLE_DEFINED)));
 
   719         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   807         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   720         assertEval("import static java.lang.Math.*;",
 
   808         assertEval("import static java.lang.Math.*;",
 
   721                 added(VALID),
 
   809                 added(VALID),
 
   722                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   810                 ste(a, RECOVERABLE_DEFINED, VALID, false, null));
 
   723         assertEval("Math.abs(A.pi() - 3.1415) < 0.001;", "true");
 
   811         assertEval("Math.abs(A.pi() - 3.1415) < 0.001;", "true");
 
   724 
   812 
   725         PersistentSnippet list = varKey(assertEval("String PI;",
 
   813         PersistentSnippet list = varKey(assertEval("String PI;",
 
   726                 DiagCheck.DIAG_OK,
 
   814                 DiagCheck.DIAG_OK,
 
   727                 DiagCheck.DIAG_ERROR,
 
   815                 DiagCheck.DIAG_ERROR,
 
   728                 added(VALID),
 
   816                 added(VALID),
 
   729                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
 
   817                 ste(a, VALID, RECOVERABLE_DEFINED, false, null)));
 
   730         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   818         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   731         assertActiveKeys();
 
   819         assertActiveKeys();
 
   732         assertDrop(list,
 
   820         assertDrop(list,
 
   733                 ste(list, VALID, DROPPED, true, null),
 
   821                 ste(list, VALID, DROPPED, true, null),
 
   734                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, list));
 
   822                 ste(a, RECOVERABLE_DEFINED, VALID, false, list));
 
   735     }
 
   823     }
 
   736 
   824 
   737     public void testForwardImportOnDemandFieldToClass2() {
 
   825     public void testForwardImportOnDemandFieldToClass2() {
 
   738         PersistentSnippet a = classKey(assertEval("class A { static double pi = PI; }",
 
   826         PersistentSnippet a = classKey(assertEval("class A { static double pi = PI; }",
 
   739                 added(RECOVERABLE_NOT_DEFINED)));
 
   827                 added(RECOVERABLE_DEFINED)));
 
   740         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   828         assertEvalUnresolvedException("new A();", "A", 1, 0);
 
   741         assertEval("import static java.lang.Math.*;",
 
   829         assertEval("import static java.lang.Math.*;",
 
   742                 added(VALID),
 
   830                 added(VALID),
 
   743                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
 
   831                 ste(a, RECOVERABLE_DEFINED, VALID, true, null));
 
   744         assertEval("Math.abs(A.pi - 3.1415) < 0.001;", "true");
 
   832         assertEval("Math.abs(A.pi - 3.1415) < 0.001;", "true");
 
   745 
   833 
   746         PersistentSnippet list = varKey(assertEval("String PI;",
 
   834         PersistentSnippet list = varKey(assertEval("String PI;",
 
   747                 DiagCheck.DIAG_OK,
 
   835                 DiagCheck.DIAG_OK,
 
   748                 DiagCheck.DIAG_ERROR,
 
   836                 DiagCheck.DIAG_ERROR,
 
   749                 added(VALID),
 
   837                 added(VALID),
 
   750                 ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
 
   838                 ste(a, VALID, RECOVERABLE_DEFINED, true, null)));
 
   751         assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
 
   839         assertEvalUnresolvedException("new A();", "A", 0, 1);
 
   752         assertActiveKeys();
 
   840         assertActiveKeys();
 
   753         assertDrop(list,
 
   841         assertDrop(list,
 
   754                 ste(list, VALID, DROPPED, true, null),
 
   842                 ste(list, VALID, DROPPED, true, null),
 
   755                 ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, list));
 
   843                 ste(a, RECOVERABLE_DEFINED, VALID, true, list));
 
       
   844         assertEval("Math.abs(A.pi - 3.1415) < 0.001;", "true");
 
   756     }
 
   845     }
 
   757 
   846 
   758     public void testReplaceCausesMethodReferenceError() {
 
   847     public void testReplaceCausesMethodReferenceError() {
 
   759         Snippet l = classKey(assertEval("interface Logger { public void log(String message); }", added(VALID)));
 
   848         Snippet l = classKey(assertEval("interface Logger { public void log(String message); }", added(VALID)));
 
   760         Snippet v = varKey(assertEval("Logger l = System.out::println;", added(VALID)));
 
   849         Snippet v = varKey(assertEval("Logger l = System.out::println;", added(VALID)));
jdk-sandbox