45 import static jdk.jshell.Snippet.Status.RECOVERABLE_NOT_DEFINED;

    45 import static jdk.jshell.Snippet.Status.RECOVERABLE_NOT_DEFINED;

    46 import static jdk.jshell.Snippet.Status.RECOVERABLE_DEFINED;

    46 import static jdk.jshell.Snippet.Status.RECOVERABLE_DEFINED;

    47 import static jdk.jshell.Snippet.Status.DROPPED;

    47 import static jdk.jshell.Snippet.Status.DROPPED;

    48 import static jdk.jshell.Snippet.Status.REJECTED;

    48 import static jdk.jshell.Snippet.Status.REJECTED;

    49 import static jdk.jshell.Snippet.Status.OVERWRITTEN;

    49 import static jdk.jshell.Snippet.Status.OVERWRITTEN;

    50 import static jdk.jshell.Snippet.SubKind.*;

    51 import static jdk.jshell.Snippet.SubKind.*;

    51 import static org.testng.Assert.assertEquals;

    52 import static org.testng.Assert.assertEquals;

    52 import static org.testng.Assert.assertTrue;

    53 import static org.testng.Assert.assertTrue;

    53 

    54 

    54 @Test

    55 @Test

    81 

    82 

    82     public void testSignature2() {

    83     public void testSignature2() {

    83         TypeDeclSnippet c1 = (TypeDeclSnippet) assertDeclareFail("class A { void f() { return g(); } }", "compiler.err.prob.found.req");

    84         TypeDeclSnippet c1 = (TypeDeclSnippet) assertDeclareFail("class A { void f() { return g(); } }", "compiler.err.prob.found.req");

    84         assertTypeDeclSnippet(c1, "A", REJECTED, CLASS_SUBKIND, 0, 2);

    85         assertTypeDeclSnippet(c1, "A", REJECTED, CLASS_SUBKIND, 0, 2);

    85         TypeDeclSnippet c2 = classKey(assertEval("class A { int f() { return g(); } }",

    86         TypeDeclSnippet c2 = classKey(assertEval("class A { int f() { return g(); } }",

    87         assertTypeDeclSnippet(c2, "A", RECOVERABLE_DEFINED, CLASS_SUBKIND, 1, 0);

    88         assertTypeDeclSnippet(c2, "A", RECOVERABLE_DEFINED, CLASS_SUBKIND, 1, 0);

    88         assertDrop(c2,

    89         assertDrop(c2,

    89                 ste(c2, RECOVERABLE_DEFINED, DROPPED, true, null));

    90                 ste(c2, RECOVERABLE_DEFINED, DROPPED, true, null));

    90     }

    91     }

    91 

    92 

   174                 DiagCheck.DIAG_ERROR,

   175                 DiagCheck.DIAG_ERROR,

   175                 added(REJECTED));

   176                 added(REJECTED));

   176         assertActiveKeys();

   177         assertActiveKeys();

   177     }

   178     }

   178 

   179 

   179     public void classesRedeclaration3() {

   181     public void classesRedeclaration3() {

   180         Snippet a = classKey(assertEval("class A { }"));

   182         Snippet a = classKey(assertEval("class A { }"));

   181         assertClasses(clazz(KullaTesting.ClassType.CLASS, "A"));

   183         assertClasses(clazz(KullaTesting.ClassType.CLASS, "A"));

   182         assertActiveKeys();

   184         assertActiveKeys();

   183 

   185 

   188 

   190 

   189         assertEval("interface A { }",

   191         assertEval("interface A { }",

   190                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   192                 ste(MAIN_SNIPPET, VALID, VALID, true, null),

   191                 ste(test1, VALID, VALID, true, MAIN_SNIPPET),

   193                 ste(test1, VALID, VALID, true, MAIN_SNIPPET),

   192                 ste(test2, VALID, VALID, true, MAIN_SNIPPET),

   194                 ste(test2, VALID, VALID, true, MAIN_SNIPPET),

   194                 ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   196                 ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET));

   195         assertClasses(clazz(KullaTesting.ClassType.INTERFACE, "A"));

   197         assertClasses(clazz(KullaTesting.ClassType.INTERFACE, "A"));

   196         assertMethods(method("()A", "test"), method("(A)void", "test"), method("(int)void", "test"));

   198         assertMethods(method("()A", "test"), method("(A)void", "test"), method("(int)void", "test"));

   197         assertActiveKeys();

   199         assertActiveKeys();

   198     }

   200     }

   199 

   201 

   200     public void classesCyclic1() {

   202     public void classesCyclic1() {

   201         Snippet b = classKey(assertEval("class B extends A { }",

   203         Snippet b = classKey(assertEval("class B extends A { }",

   202                 added(RECOVERABLE_NOT_DEFINED)));

   204                 added(RECOVERABLE_NOT_DEFINED)));

   203         Snippet a = classKey(assertEval("class A extends B { }", DiagCheck.DIAG_IGNORE, DiagCheck.DIAG_IGNORE,

   205         Snippet a = classKey(assertEval("class A extends B { }", DiagCheck.DIAG_IGNORE, DiagCheck.DIAG_IGNORE,

   206         /***

   207         /***

   207         assertDeclareFail("class A extends B { }", "****",

   208         assertDeclareFail("class A extends B { }", "****",

   208                 added(REJECTED),

   209                 added(REJECTED),

   209                 ste(b, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, MAIN_SNIPPET));

   210                 ste(b, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, MAIN_SNIPPET));

   210         ***/

   211         ***/