IDEA-136310 (parser error on missing constructor name)
[idea/community.git] / java / java-tests / testSrc / com / intellij / lang / java / parser / partial / DeclarationParserTest.java
1 /*
2  * Copyright 2000-2015 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.lang.java.parser.partial;
17
18 import com.intellij.lang.PsiBuilder;
19 import com.intellij.lang.java.parser.JavaParser;
20 import com.intellij.lang.java.parser.JavaParsingTestCase;
21
22 public class DeclarationParserTest extends JavaParsingTestCase {
23   public DeclarationParserTest() {
24     super("parser-partial/declarations");
25   }
26
27   public void testEmptyBody0() { doParserTest("{ }"); }
28   public void testEmptyBody1() { doParserTest("{ "); }
29   public void testEmptyBody2() { doParserTest("{ @Null }"); }
30
31   public void testNoType() { doParserTest("{ new X(); }"); }
32   public void testExtraSemicolon() { doParserTest("{ class C { }; }"); }
33   public void testParameterizedClass() { doParserTest("{ public class A <T extends java.util.List> { } }"); }
34   public void testPines() { doParserTest("{ class A<T extends List<String>> extends List<List<Integer>> { } }"); }
35   public void testIncompleteAnnotation() { doParserTest("{ public class Foo { public void testSomething(); @Null } }"); }
36   public void testClassInit() { doParserTest("{ { /*comment*/ } }"); }
37   public void testAnnoDeclaration() { doParserTest("{ public @interface Annotation {} }"); }
38   public void testEnumSmartTypeCompletion() { doParserTest("{ @Preliminary(A.B\n#) public class TimeTravel {}\n" +
39                                                            "  @Preliminary(a=A.B\n#) public class TimeTravel {}\n" +
40                                                            "  @Preliminary(a=A.B\n#, b=c) public class TimeTravel {} }"); }
41   public void testTypeAnno() {
42     doParserTest("{ class C<@D T extends @F Object> extends @F Object {\n" +
43                  "  @F int @F[] method() throws @F Exception {\n" +
44                  "    a = this instanceof @F C;\n" +
45                  "    C<@F @G C> c = new @Q C<@F C>();\n" +
46                  "    c = (@F Object)c;\n" +
47                  "    Class c = @TA String.class;\n" +
48                  "    @F C.field++;\n" +
49                  "  }\n} }");
50   }
51
52   public void testEnumBody0() { doParserTest("{ ; }", false, true); }
53   public void testEnumBody1() { doParserTest("{ RED, GREEN, BLUE; }", false, true); }
54   public void testEnumBody2() { doParserTest("{ RED, GREEN, BLUE }", false, true); }
55   public void testEnumBody3() { doParserTest("{ RED, GREEN, BLUE, }", false, true); }
56   public void testEnumBody4() { doParserTest("{ RED(0), GREEN(1), BLUE(2); }", false, true); }
57   public void testEnumBody5() { doParserTest("{ @ANNOTATION A(10) }", false, true); }
58   public void testEnumBody6() { doParserTest("{ RED, GREEN, BLUE\n OurEnum() {} }", false, true); }
59   public void testEnumWithInitializedConstants() { doParserTest("{ A(10) { },\n B { void method() {} } }", false, true); }
60   public void testEnumWithoutConstants() { doParserTest("{ private A }", false, true); }
61
62   public void testAnnoSimple() { doParserTest("{ int foo (); }", true, false); }
63   public void testAnnoDefault() { doParserTest("{ Class foo() default String.class; }", true, false); }
64   public void testAnnoNested() { doParserTest("{ @interface Inner { String bar () default \"<unspecified>\"; } }", true, false); }
65   public void testAnnoInner() { doParserTest("{ @interface Inner { double bar () default 0.0; } }"); }
66   public void testAnnoOtherMembers() { doParserTest("{ int field;\n void m() {}\n class C {}\n interface I {} }", true, false); }
67   public void testAnnoLoop() { doParserTest("{ @@@ int i; }"); }
68
69   public void testFieldSimple() { doParserTest("{ int field = 0; }"); }
70   public void testFieldMulti() { doParserTest("{ int field1 = 0, field2; }"); }
71   public void testUnclosedBracket() { doParserTest("{ int field[ }"); }
72   public void testMissingInitializer() { doParserTest("{ int field = }"); }
73   public void testUnclosedComma() { doParserTest("{ int field, }"); }
74   public void testUnclosedSemicolon() { doParserTest("{ int field }"); }
75   public void testMissingInitializerExpression() { doParserTest("{ int field=; }"); }
76   public void testMultiLineUnclosed() { doParserTest("{ int \n Object o; }"); }
77   public void testUnclosedField1() { doParserTest("{ String f1\n\n @Anno String f2; }"); }
78   public void testUnclosedField2() { doParserTest("{ String f1\n\n @Anno\n String f2; }"); }
79
80   public void testMethodNormal0() { doParserTest("{ void f() {} }"); }
81   public void testMethodNormal1() { doParserTest("{ void f(); }"); }
82   public void testMethodNormal2() { doParserTest("{ default public void f() { } }"); }
83   public void testSemicolons() { doParserTest("{ void f() {}; void g() {}; }"); }
84   public void testUnclosed0() { doParserTest("{ void f() }"); }
85   public void testExtension() { doParserTest("{ default int f() throws E { return 42; } }"); }
86   public void testUnclosed1() { doParserTest("{ void f( }"); }
87   public void testUnclosed2() { doParserTest("{ void f()\n void g(); }"); }
88   public void testUnclosed3() { doParserTest("{ void f(int a }"); }
89   public void testUnclosed4() { doParserTest("{ void f(int a,, }"); }
90   public void testUnclosed5() { doParserTest("{ void f(int a,); }"); }
91   public void testUnclosed6() { doParserTest("{ void f() default ; }", true, false); }
92   public void testUnclosed7() { doParserTest("{ void f() default {return 42;} }", true, false); }
93   public void testUnclosed8() { doParserTest("{ void f() default }"); }
94   public void testConstructorBrackets() { doParserTest("{ A() [] { } }"); }
95   public void testVarArgBrackets() { doParserTest("{ void foo(int... x[]); }"); }
96
97   public void testGenericMethod() { doParserTest("{ public static <E> test();\n" +
98                                                  " <E> void test1();\n" +
99                                                  " <E1 extends Integer, E2 extends Runnable> String test2(); }"); }
100   public void testGenericMethodErrors() { doParserTest("{ <Error sss /> test <error>(); }"); }
101   public void testErrors() { doParserTest("{ public static <error descr=\"2\">protected int f1 = 0; }"); }
102   public void testCompletionHack0() { doParserTest("{ <X IntelliJIdeaRulezz>\n String s = \"\"; }"); }
103   public void testCompletionHack1() { doParserTest("{ <X\n String s = \"\"; }"); }
104   public void testCompletionHack2() { doParserTest("{ String foo() def }", true, false); }
105   public void testWildcardParsing() { doParserTest("{ List<? extends B> x(Collection<? super B> x); }"); }
106   public void testParameterAnnotation() { doParserTest("{ void foo (@Annotation(value=77) int param) {} }"); }
107   public void testParameterizedMethod() { doParserTest("{ @Nullable <T> T bar() {} }"); }
108   public void testMethodNameOmitted() { doParserTest("{ void(); }"); }
109
110   private void doParserTest(String text) {
111     doParserTest(text, false, false);
112   }
113
114   private void doParserTest(String text, boolean isAnnotation, boolean isEnum) {
115     doParserTest(text, new MyTestParser(isAnnotation, isEnum));
116   }
117
118   private static class MyTestParser implements TestParser {
119     private final boolean myAnnotation;
120     private final boolean myAnEnum;
121
122     public MyTestParser(boolean annotation, boolean anEnum) {
123       myAnnotation = annotation;
124       myAnEnum = anEnum;
125     }
126
127     @Override
128     public void parse(PsiBuilder builder) {
129       JavaParser.INSTANCE.getDeclarationParser().parseClassBodyWithBraces(builder, myAnnotation, myAnEnum);
130     }
131   }
132 }