IDEA-79862 Java: auto-insert space after completing "extends" and "implements"
[idea/community.git] / plugins / groovy / test / org / jetbrains / plugins / groovy / completion / GroovyCompletionTest.groovy
1 /*
2  * Copyright 2000-2009 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
17 package org.jetbrains.plugins.groovy.completion;
18
19
20 import com.intellij.codeInsight.CodeInsightSettings
21 import com.intellij.codeInsight.lookup.LookupElement
22 import com.intellij.codeInsight.lookup.LookupElementPresentation
23 import org.jetbrains.plugins.groovy.GroovyFileType
24 import org.jetbrains.plugins.groovy.util.TestUtils
25 import com.intellij.psi.codeStyle.CodeStyleSettingsManager
26 import org.jetbrains.plugins.groovy.formatter.GroovyCodeStyleSettings
27 import com.intellij.codeInsight.completion.CompletionType
28
29 /**
30  * @author Maxim.Medvedev
31  */
32 public class GroovyCompletionTest extends GroovyCompletionTestBase {
33   @Override
34   protected String getBasePath() {
35     return TestUtils.getTestDataPath() + "groovy/completion/";
36   }
37
38   @Override
39   protected void tearDown() {
40     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.FIRST_LETTER
41     super.tearDown()
42   }
43
44   public void testFinishMethodWithLParen() throws Throwable {
45     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "getBar", "getClass", "getFoo");
46     myFixture.type('(');
47     myFixture.checkResultByFile(getTestName(false) + "_after.groovy");
48   }
49
50   public void testNamedParametersForApplication() throws Throwable {
51     doVariantableTest("abx", "aby");
52   }
53
54   public void testNamedParametersForMethodCall() throws Throwable {
55     doVariantableTest("abx", "aby");
56   }
57
58   public void testNamedParameters1() throws Throwable {
59     doVariantableTest("abx", "aby");
60   }
61
62   public void testNamedParameters2() throws Throwable {
63     doVariantableTest("abx", "aby");
64   }
65
66   public void testNamedParametersInMap1() throws Throwable {
67     doVariantableTest("abx", "aby");
68   }
69
70   public void testNamedParametersInMap2() throws Throwable {
71     doVariantableTest("abx", "aby");
72   }
73
74   public void testNamedParametersInSecondMap1() throws Throwable {
75     doVariantableTest();
76   }
77
78   public void testNamedParametersInSecondMap2() throws Throwable {
79     doVariantableTest();
80   }
81
82   public void testNamedParametersExcludeExisted() throws Throwable {
83     doVariantableTest("abx", "aby");
84   }
85
86   public void testNamedParametersExcludeExisted2() throws Throwable {
87     doVariantableTest("abx", "aby", "abz");
88   }
89
90   public void testNamedParametersExcludeExistedMap() throws Throwable {
91     doVariantableTest("abx", "aby");
92   }
93
94   public void testNamedParametersForNotMap() throws Throwable {
95     doBasicTest();
96   }
97
98   public void testNamedParametersForConstructorCall() throws Throwable {
99     doVariantableTest("hahaha", "hohoho");
100   }
101
102   public void testUnfinishedMethodTypeParameter() throws Throwable {
103     doVariantableTest("MyParameter", "MySecondParameter");
104   }
105
106   public void testUnfinishedMethodTypeParameter2() throws Throwable {
107     doVariantableTest("MyParameter", "MySecondParameter");
108   }
109
110   public void testInstanceofHelpsDetermineType() throws Throwable {
111     doBasicTest();
112   }
113
114   public void testNotInstanceofDoesntHelpDetermineType() throws Throwable {
115     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
116   }
117
118   public void testNotInstanceofDoesntHelpDetermineType2() throws Throwable {
119     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
120   }
121
122   public void testTypeParameterCompletion() throws Throwable {
123     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "put", "putAll");
124   }
125
126   public void testCatchClauseParameter() throws Throwable {
127     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "getCause", "getClass");
128   }
129
130   public void testFieldSuggestedOnce1() throws Throwable {
131     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
132     assertNull(myFixture.getLookupElements());
133   }
134
135   public void testFieldSuggestedOnce2() throws Throwable {
136     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
137     assertNull(myFixture.getLookupElements());
138   }
139
140   public void testFieldSuggestedOnce3() throws Throwable {
141     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
142     assertNull(myFixture.getLookupElements());
143   }
144
145   public void testFieldSuggestedOnce4() throws Throwable {
146     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
147     assertNull(myFixture.getLookupElements());
148   }
149
150   public void testFieldSuggestedOnce5() throws Throwable {
151     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
152     assertNull(myFixture.getLookupElements());
153   }
154
155   public void testFieldSuggestedInMethodCall() throws Throwable {
156     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + "_after.groovy");
157   }
158
159   public void testMethodParameterNoSpace() throws Throwable {
160     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + "_after.groovy");
161   }
162
163   public void testGroovyDocParameter() throws Throwable {
164     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "xx", "xy");
165   }
166
167   public void testInnerClassExtendsImplementsCompletion() throws Throwable {
168     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "extends", "implements");
169   }
170
171   public void testInnerClassCompletion() throws Throwable {
172     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "Inner1", "Inner2");
173   }
174
175   public void testQualifiedThisCompletion() throws Throwable {
176     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "foo1", "foo2");
177   }
178
179   public void testQualifiedSuperCompletion() throws Throwable {
180     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "foo1", "foo2");
181   }
182
183   public void testThisKeywordCompletionAfterClassName1() throws Throwable {
184     doBasicTest();
185   }
186
187   public void testThisKeywordCompletionAfterClassName2() throws Throwable {
188     doBasicTest();
189   }
190
191   public void testCompletionInParameterListInClosableBlock() throws Throwable { doBasicTest(); }
192   public void testCompletionInParameterListInClosableBlock3() throws Throwable { doBasicTest(); }
193
194   public void testCompletionInParameterListInClosableBlock2() throws Throwable {
195     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "aDouble");
196   }
197
198   public void testStaticMemberFromInstanceContext() throws Throwable {
199     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "var1", "var2");
200   }
201
202   public void testInstanceMemberFromStaticContext() throws Throwable {
203     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "var3", "var4");
204   }
205
206   public void testTypeCompletionInVariableDeclaration1() throws Throwable {
207     doBasicTest();
208   }
209
210   public void testTypeCompletionInVariableDeclaration2() throws Throwable {
211     doBasicTest();
212   }
213
214   public void testTypeCompletionInParameter() throws Throwable {
215     doBasicTest();
216   }
217
218   public void testGStringConcatenationCompletion() throws Throwable {
219     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "substring", "substring", "subSequence");
220   }
221
222   public void testPropertyWithSecondUpperLetter() throws Exception {
223     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "geteMail", "getePost");
224   }
225
226   public void testInferredVariableType() throws Exception {
227     myFixture.configureByText "a.groovy", "def foo = 'xxx'; fo<caret>"
228     def presentation = new LookupElementPresentation()
229     myFixture.completeBasic()[0].renderElement(presentation)
230     assert presentation.itemText == 'foo'
231     assert presentation.typeText == 'String'
232   }
233
234   public void testSubstitutedMethodType() throws Exception {
235     myFixture.configureByText "a.groovy", "new HashMap<String, Integer>().put<caret>x"
236     def presentation = new LookupElementPresentation()
237     myFixture.completeBasic()[0].renderElement(presentation)
238     assert presentation.itemText == 'put'
239     assert presentation.tailText == '(String key, Integer value)'
240     assert presentation.typeText == 'Integer'
241   }
242
243   public void testIntCompletionInPlusMethod() {doBasicTest();}
244   public void testIntCompletionInGenericParameter() {doBasicTest();}
245
246   public void testWhenSiblingIsStaticallyImported_Method() throws Exception {
247     myFixture.addFileToProject "foo/Foo.groovy", """package foo
248       class Foo {
249         static def abcMethod() {}
250         static def defMethod() {}
251       }
252     """
253
254     myFixture.configureByText("a.groovy", """
255       import static foo.Foo.abcMethod
256
257       abcMethod()
258       defM<caret>
259     """)
260     myFixture.completeBasic()
261     myFixture.checkResult """
262       import static foo.Foo.abcMethod
263       import static foo.Foo.defMethod
264
265       abcMethod()
266       defMethod()<caret>
267     """
268   }
269
270   public void testWhenSiblingIsStaticallyImported_Field() throws Exception {
271     myFixture.addFileToProject "foo/Foo.groovy", """package foo
272       class Foo {
273         static def abcField = 4
274         static def defField = 2
275       }
276     """
277
278     myFixture.configureByText("a.groovy", """
279       import static foo.Foo.abcField
280
281       println abcField
282       defF<caret>
283     """)
284     myFixture.completeBasic()
285     myFixture.checkResult """
286       import static foo.Foo.abcField
287       import static foo.Foo.defField
288
289       println abcField
290       defField<caret>
291     """
292   }
293
294   public void testCompletionNamedArgumentWithoutSpace() {
295     def settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(GroovyCodeStyleSettings.class)
296     settings.SPACE_IN_NAMED_ARGUMENT = false
297
298     try {
299       myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
300   class A {
301    public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
302    { m(arg11<caret>) }
303   }
304   """)
305       myFixture.completeBasic()
306       myFixture.checkResult """
307   class A {
308    public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
309    { m(arg111:<caret>) }
310   }
311   """
312     }
313     finally {
314       settings.SPACE_IN_NAMED_ARGUMENT = true
315     }
316   }
317
318   public void testCompletionNamedArgument1() {
319     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
320 class A {
321  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
322  { m(arg111: 1, arg<caret>: 2,   arg333: 3) }
323 }
324 """)
325     myFixture.completeBasic()
326
327     myFixture.checkResult """
328 class A {
329  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
330  { m(arg111: 1, arg222: <caret>2,   arg333: 3) }
331 }
332 """
333   }
334
335   public void testCompletionNamedArgument2() {
336     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
337 class A {
338  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
339  { m arg111: 1, arg<caret>: 2,   arg333: 3 }
340 }
341 """)
342     myFixture.completeBasic()
343
344     myFixture.checkResult """
345 class A {
346  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
347  { m arg111: 1, arg222: <caret>2,   arg333: 3 }
348 }
349 """
350   }
351
352   public void testCompletionNamedArgument3() {
353     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
354 class A {
355  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
356  { m arg1<caret> }
357 }
358 """)
359     myFixture.completeBasic()
360
361     myFixture.checkResult """
362 class A {
363  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
364  { m arg111: <caret> }
365 }
366 """
367   }
368
369   public void testCompletionNamedArgument4() {
370     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
371 class A {
372  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
373  { m (arg1<caret> zzz) }
374 }
375 """)
376     myFixture.completeBasic()
377
378     myFixture.checkResult """
379 class A {
380  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
381  { m (arg111: <caret>, zzz) }
382 }
383 """
384   }
385
386   public void testCompletionNamedArgument5() {
387     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
388 class A {
389  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
390  { m (arg1<caret>, {
391       out << "asdasdas"
392  } ) }
393 }
394 """)
395     myFixture.completeBasic()
396
397     myFixture.checkResult("""
398 class A {
399  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
400  { m (arg111: <caret>, {
401       out << "asdasdas"
402  } ) }
403 }
404 """)
405   }
406
407   public void testCompletionNamedArgument6() {
408     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
409 class A {
410  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
411  { m([arg1<caret>])}
412 }
413 """)
414     myFixture.completeBasic()
415
416     myFixture.checkResult """
417 class A {
418  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
419  { m([arg111: <caret>])}
420 }
421 """
422   }
423
424   public void testCompletionNamedArgument7() {
425     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
426 class A {
427  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
428  { m(arg1<caret>)}
429 }
430 """)
431     myFixture.completeBasic()
432
433     myFixture.checkResult """
434 class A {
435  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
436  { m(arg111: <caret>)}
437 }
438 """
439   }
440
441   public void testCompletionNamedArgument8() {
442     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
443 class A {
444  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
445  { m(arg1<caret>,)}
446 }
447 """)
448     myFixture.completeBasic()
449
450     myFixture.checkResult """
451 class A {
452  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
453  { m(arg111: <caret>,)}
454 }
455 """
456   }
457
458   public void testCompletionNamedArgumentWithDD() {
459     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
460 class A {
461  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
462  { m(arg<caret>)}
463 }
464 """)
465     myFixture.completeBasic()
466     myFixture.type(':')
467
468     myFixture.checkResult """
469 class A {
470  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
471  { m(arg111: <caret>)}
472 }
473 """
474   }
475
476   public void testCompletionNamedArgumentReplace() {
477     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
478 class A {
479  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
480  { m(arg<caret>222: 'a')}
481 }
482 """)
483     myFixture.completeBasic()
484     myFixture.type("1\t")
485
486     myFixture.checkResult """
487 class A {
488  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
489  { m(arg111: 'a')}
490 }
491 """
492   }
493
494   public void testCompletionNamedArgumentWithSpace() {
495     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
496 class A {
497  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
498  { m(arg<caret>)}
499 }
500 """)
501     myFixture.completeBasic()
502     myFixture.type(' ')
503
504     myFixture.checkResult """
505 class A {
506  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
507  { m(arg111: <caret>)}
508 }
509 """
510   }
511
512   public void testCompletionNamedArgumentWithNewLine1() {
513     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
514 class A {
515  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
516  {
517    m(arg<caret>
518      arg222: 222,
519    )
520  }
521 }
522 """)
523     myFixture.completeBasic()
524     myFixture.type(' ')
525
526     myFixture.checkResult """
527 class A {
528  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
529  {
530    m(arg111: <caret>,
531      arg222: 222,
532    )
533  }
534 }
535 """
536   }
537
538   public void testCompletionNamedArgumentWithNewLine2() {
539     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
540 class A {
541  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
542  {
543    m(arg<caret>,
544      arg222: 222,
545    )
546  }
547 }
548 """)
549     myFixture.completeBasic()
550     myFixture.type(':')
551
552     myFixture.checkResult """
553 class A {
554  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
555  {
556    m(arg111: <caret>,
557      arg222: 222,
558    )
559  }
560 }
561 """
562   }
563
564   public void testCompletionNamedArgumentWithNewLine4() {
565     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
566 class A {
567  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
568  {
569    m(arg<caret>
570      , arg222: 222,
571      arg333: 333,
572    )
573  }
574 }
575 """)
576     myFixture.completeBasic()
577
578     myFixture.checkResult """
579 class A {
580  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
581  {
582    m(arg111: <caret>
583      , arg222: 222,
584      arg333: 333,
585    )
586  }
587 }
588 """
589   }
590
591   public void testSpreadOperator() {
592     doVariantableTest("foo1", "foo2")
593   }
594
595   public void testGrvy945() {
596     def file = myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """class MyCategory {
597   static def plus(MyCategory t, MyCat<caret>) {
598   }
599 }""")
600     LookupElement[] lookupElements = myFixture.completeBasic()
601     assertNull(lookupElements)
602
603     assertEquals """class MyCategory {
604   static def plus(MyCategory t, MyCategory) {
605   }
606 }""", file.text
607   }
608
609   void configure(String text) {
610     myFixture.configureByText("a.groovy", text)
611   }
612
613   public void testGenericsAfterNew() {
614     configure "List<String> l = new ArrLi<caret>"
615     myFixture.completeBasic()
616     myFixture.type '\n'
617     myFixture.checkResult "List<String> l = new ArrayList<String>(<caret>)"
618   }
619
620   public void testAfterNewWithInner() {
621     myFixture.addClass """class Zzoo {
622         static class Impl {}
623       }"""
624     configure "Zzoo l = new Zz<caret>"
625     myFixture.completeBasic()
626     myFixture.checkResult "Zzoo l = new Zzoo()<caret>"
627   }
628
629   public void testNothingAfterIntegerLiteral() {
630     configure "2f<caret>"
631     assertEmpty myFixture.completeBasic()
632   }
633
634   public void testPackagedContainingClassNameAfterStatic() {
635     myFixture.configureFromExistingVirtualFile(myFixture.addFileToProject("foo/cls.groovy", """
636     package foo
637     class Zzzzzzz {
638       static Zzz<caret>
639     }
640     """).virtualFile)
641     myFixture.completeBasic()
642     assert myFixture.editor.document.text.contains("static Zzzzzzz")
643   }
644
645   public void testDontCompleteSubpackageOfImplicitlyImported() {
646     myFixture.addFileToProject "A.groovy", """
647 in<caret>"""
648     myFixture.testCompletionVariants "A.groovy", "int", "interface" //don't complete 'instrument' from 'java.lang'
649   }
650
651
652   public void testEatingThisReference() {
653     configure "def x = []; x.<caret> this"
654     myFixture.completeBasic()
655     myFixture.type 'ad\t'
656     myFixture.checkResult "def x = []; x.add(<caret>) this"
657   }
658
659   public void testEatingClosingParenthesis() {
660     checkCompletion """
661 def xxxx = []
662 def xxxy = []
663 foo((xx<caret>):2)
664 """, '\t', """
665 def xxxx = []
666 def xxxy = []
667 foo((xxxx<caret>):2)
668 """
669   }
670
671   public void testDontAddStaticImportSecondTime() {
672     configure """import static java.lang.String.format
673 form<caret>"""
674
675     myFixture.completeBasic()
676     myFixture.checkResult """import static java.lang.String.format
677 format(<caret>)"""
678   }
679   
680   public void testImportAsterisk() {
681     myFixture.configureByText "a.groovy", "import java.lang.<caret>"
682     myFixture.completeBasic()
683     myFixture.type '*\n'
684     myFixture.checkResult "import java.lang.*<caret>"
685   }
686
687   public void testNoDotsInImport() {
688     myFixture.configureByText "a.groovy", "import java.<caret>"
689     myFixture.completeBasic()
690     myFixture.type 'lan\n'
691     myFixture.checkResult "import java.lang<caret>"
692   }
693
694   public void testInvalidScriptClass() {
695     myFixture.addFileToProject("b.groovy", "//comment")
696     myFixture.configureByText "a.groovy", "def b<caret>"
697     myFixture.completeBasic()
698     myFixture.checkResult "def b<caret>"
699   }
700
701   public void testSpacesAroundEq() {
702     myFixture.configureByText "a.groovy", "int xxx, xxy; xx<caret>"
703     myFixture.completeBasic()
704     myFixture.type '='
705     myFixture.checkResult "int xxx, xxy; xxx = <caret>"
706   }
707
708   public void testOnlyAnnotationsAfterAt() {
709     myFixture.addClass "class AbcdClass {}; @interface AbcdAnno {}"
710     myFixture.configureByText "a.groovy", "@Abcd<caret> class A {}"
711     myFixture.completeBasic()
712     myFixture.checkResult "@AbcdAnno<caret> class A {}"
713   }
714
715   public void testOnlyAnnotationsAfterAtInMethodParameters() {
716     myFixture.addClass "class AbcdClass {}; @interface AbcdAnno {}"
717     myFixture.configureByText "a.groovy", "def foo(@Abcd<caret> ) {}"
718     myFixture.completeBasic()
719     myFixture.checkResult "def foo(@AbcdAnno<caret> ) {}"
720   }
721
722   public void testNoCompletionInClassBodyComments() {
723     myFixture.configureByText "a.groovy", "class Foo { /* protec<caret> */ }"
724     assertEmpty(myFixture.completeBasic())
725   }
726
727   public void testNoCompletionInCodeBlockComments() {
728     myFixture.configureByText "a.groovy", "def Foo() { /* whil<caret> */ }"
729     assertEmpty(myFixture.completeBasic())
730   }
731
732   public void testParenthesesForExpectedClassTypeRegardlessInners() {
733     myFixture.addClass "class Fooooo { interface Bar {} }"
734     myFixture.configureByText "a.groovy", "Fooooo f = new Foo<caret>"
735     myFixture.completeBasic()
736     myFixture.checkResult "Fooooo f = new Fooooo()<caret>"
737   }
738
739   public void testParenthesesForUnexpectedClassTypeRegardingInners() {
740     myFixture.addClass "class Fooooo { interface Bar {} }"
741     myFixture.configureByText "a.groovy", "Fooooo.Bar f = new Foo<caret>"
742     myFixture.completeBasic()
743     myFixture.checkResult "Fooooo.Bar f = new Fooooo<caret>"
744   }
745
746   public void testOnlyExceptionsInCatch() {
747     myFixture.addClass "package foo; public class AbcdClass {}; public class AbcdException extends Throwable {}"
748     myFixture.configureByText "a.groovy", "try {} catch (Abcd<caret>"
749     myFixture.completeBasic()
750     myFixture.type('\n')
751     myFixture.checkResult """import foo.AbcdException
752
753 try {} catch (AbcdException"""
754   }
755
756   public void testOnlyExceptionsInCatch2() {
757     myFixture.addClass "class AbcdClass {}; class AbcdException extends Throwable {}"
758     myFixture.configureByText "a.groovy", "try {} catch (Abcd<caret> e) {}"
759     myFixture.completeBasic()
760     myFixture.checkResult "try {} catch (AbcdException<caret> e) {}"
761   }
762
763   public void testTopLevelClassesFromPackaged() throws Throwable {
764     myFixture.addClass "public class Fooooo {}"
765     final text = "package foo; class Bar { Fooo<caret> }"
766     def file = myFixture.addFileToProject("foo/Bar.groovy", text)
767     myFixture.configureFromExistingVirtualFile file.virtualFile
768     assertEmpty myFixture.completeBasic()
769     myFixture.checkResult text
770   }
771
772   public void testLocalVarOverlaysField() {
773     myFixture.configureByText "a.groovy", """
774 class A {
775   def myVar = 2
776
777   def foo() {
778     def myVar = 3
779     print myVa<caret>
780   }
781 }"""
782     myFixture.completeBasic()
783
784     myFixture.checkResult """
785 class A {
786   def myVar = 2
787
788   def foo() {
789     def myVar = 3
790     print myVar<caret>
791   }
792 }"""
793
794   }
795
796   public void testParenthesesInMethodCompletion() {
797     myFixture.configureByText "a.groovy", """
798 def foo(def a) {2}
799 return fo<caret>"""
800     myFixture.completeBasic()
801     myFixture.checkResult """
802 def foo(def a) {2}
803 return foo()"""
804   }
805
806   public void testFinishClassNameWithSquareBracket() {
807     myFixture.addClass("class AbcdClass {}; class AbcdeClass {}")
808     checkCompletion("Abcd<caret>", '[', "AbcdClass[<caret>]")
809   }
810
811   public void testFinishClassNameWithSquareBracketAfterNew() {
812     myFixture.addClass("class AbcdClass {}; class AbcdeClass {}")
813     checkCompletion("new Abcd<caret>", '[', "new AbcdClass[<caret>]")
814   }
815
816   public void testFinishMethodNameWithSquareBracket() {
817     myFixture.addClass("""class AbcdClass {
818       static int[] foo(int x){}
819       static int[] fobar(){}
820     }""")
821     checkCompletion("AbcdClass.fo<caret>", '[', "AbcdClass.fobar()[<caret>]")
822   }
823
824   public void testFinishVariableNameWithSquareBracket() {
825     checkCompletion("int[] fooo, foobar; foo<caret>", '[', "int[] fooo, foobar; foobar[<caret>]")
826   }
827
828   public void testFinishClassNameWithLt() {
829     myFixture.addClass("class AbcdClass {}; class AbcdeClass {}")
830     checkCompletion("Abcd<caret>", '<', "AbcdClass<<caret>>")
831   }
832
833   public void testFinishClassNameWithLtAfterNew() {
834     myFixture.addClass("class AbcdClass<T> {}; class AbcdeClass {}")
835     checkCompletion("new Abcd<caret>", '<', "new AbcdClass<<caret>>()")
836   }
837
838   public void testMapKeysUsedInFile() throws Exception {
839     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
840     doVariantableTest 'foo1', 'foo3', 'foo4', 'Foo5', 'Foo7'
841   }
842
843   public void testNoClassesAsMapKeys() throws Exception {
844     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
845     doVariantableTest()
846   }
847
848   public void testNamedArgsUsedInFile() throws Exception {
849     myFixture.configureByFile(getTestName(false) + ".groovy");
850     doVariantableTest 'false', 'foo2', 'float', 'foo1', 'foo3', 'foo4', 'foo5'
851   }
852
853   public void testSuggestMembersOfExpectedType() {
854     myFixture.addClass("enum Foo { aaaaaaaaaaaaaaaaaaaaaa, bbbbbb }")
855     checkCompletion("Foo f = aaaaaaaa<caret>", '\n', "Foo f = Foo.aaaaaaaaaaaaaaaaaaaaaa<caret>")
856   }
857
858   public void testFieldTypeAfterModifier() {
859     myFixture.addClass("package bar; public class Fooooooooooo { }")
860     checkCompletion '''
861 class A {
862   private Foooo<caret>
863 }''', '\n', '''import bar.Fooooooooooo
864
865 class A {
866   private Fooooooooooo<caret>
867 }'''
868   }
869
870   public void testSuperClassProperty() throws Exception {
871     checkSingleItemCompletion """
872 class A { def foooooooooooo }
873
874 class B extends A {
875   def bar() {
876     foooo<caret>
877   }
878 }
879 """, """
880 class A { def foooooooooooo }
881
882 class B extends A {
883   def bar() {
884     foooooooooooo<caret>
885   }
886 }
887 """
888   }
889
890   public void testDoubleSpace() {
891     checkCompletion "asse<caret>x", ' ', 'assert <caret>x'
892   }
893
894   public void testDontShowAccessors() {
895     assertNull doContainsTest("getFoo", """
896 class MyClass {
897   def foo
898 }
899
900 def a = new MyClass()
901 a.<caret>""")
902   }
903
904   public void testPreferInstanceof() {
905     caseSensitiveNone()
906
907     configure '''
908 class Fopppp {
909     def foo() {
910         assert x ins<caret>
911     }
912 }
913 class Instantiation {}
914 '''
915     myFixture.completeBasic()
916     assert myFixture.lookupElementStrings[0] == 'instanceof'
917   }
918
919   public void testForFinal() {
920     assert doContainsTest('final', '''
921 class Fopppp {
922     def foo() {
923         for(fin<caret>
924     }
925 }
926 ''')
927   }
928
929   public void testExcludeStringBuffer() {
930     assert doContainsTest('StringBuffer', 'StringBuff<caret>f')
931     CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = [StringBuffer.name] as String[]
932     try {
933       assert !doContainsTest('StringBuffer', 'StringBuff<caret>f')
934     }
935     finally {
936       CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = new String[0]
937     }
938   }
939
940   private doContainsTest(String itemToCheck, String text) {
941     myFixture.configureByText "a.groovy", text
942
943     final LookupElement[] completion = myFixture.completeBasic()
944     return completion.find {println it.lookupString;itemToCheck == it.lookupString}
945   }
946
947   public void testWordCompletionInLiterals() {
948     checkSingleItemCompletion('def foo = "fo<caret>"', 'def foo = "foo<caret>"')
949   }
950   public void testWordCompletionInLiterals2() {
951     checkSingleItemCompletion('''
952 println "abcd"
953 "a<caret>"
954 ''', '''
955 println "abcd"
956 "abcd<caret>"
957 ''')
958   }
959
960   public void testWordCompletionInComments() {
961     checkSingleItemCompletion('''
962 println "abcd"
963 // a<caret>"
964 ''', '''
965 println "abcd"
966 // abcd<caret>"
967 ''')
968   }
969
970   public void testNoModifiersAfterDef() throws Exception {
971     checkSingleItemCompletion 'def priv<caret>', 'def priv<caret>'
972   }
973
974   public void testIfSpace() { checkCompletion 'int iff; if<caret>', ' ', "int iff; if <caret>" }
975
976   public void testIfParenthesis() { checkCompletion 'int iff; if<caret>', '(', "int iff; if (<caret>)" }
977
978   public void testEnumPropertyType() {
979     checkSingleItemCompletion 'enum Foo {a,b; static List<StringBui<caret>>', "enum Foo {a,b; static List<StringBuilder<caret>>"
980   }
981
982   public void testEnumPropertyType2() {
983     checkSingleItemCompletion 'enum Foo {a,b; static List<StringBui<caret>', "enum Foo {a,b; static List<StringBuilder<caret>"
984   }
985
986   public void testShowAccessor() {
987     assertNotNull doContainsTest("getFoo", """
988 class MyClass {
989   def foo
990 }
991
992 def a = new MyClass()
993 a.g<caret>
994 """)
995   }
996
997   public void testContinue() {
998     assertNotNull doContainsTest("continue", """
999 def conti = 4
1000 while(true) {
1001   if (tst) cont<caret>
1002 }""")
1003
1004   }
1005
1006   public void testPreferParametersToClasses() {
1007     caseSensitiveNone()
1008
1009     myFixture.configureByText "a.groovy", "def foo(stryng) { println str<caret> }"
1010     myFixture.completeBasic()
1011     assert myFixture.lookupElementStrings[0] == 'stryng'
1012   }
1013
1014   private def caseSensitiveNone() {
1015     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
1016   }
1017
1018   public void testFieldVsPackage() {
1019     myFixture.addFileToProject 'aaa/bbb/Foo.groovy', 'package aaa.bbb; class Foo{}'
1020     def file = myFixture.addFileToProject('aaa/bar.groovy', '''
1021 package aaa
1022
1023 import aaa.*
1024
1025 class X {
1026   def bbb = 'text'
1027
1028   def foo() {
1029     bbb.<caret>toString()
1030   }
1031 }
1032 ''')
1033     myFixture.configureFromExistingVirtualFile file.virtualFile
1034     myFixture.completeBasic()
1035     assertFalse(myFixture.lookupElementStrings.contains('Foo'))
1036   }
1037
1038   public void testFieldVsPackage2() {
1039     myFixture.addFileToProject 'aaa/bbb/Foo.groovy', 'package aaa.bbb; class Foo{}'
1040     def file = myFixture.addFileToProject('aaa/bar.groovy', '''
1041 package aaa
1042
1043 import aaa.*
1044
1045 class X {
1046   def bbb = 'text'
1047
1048   def foo() {
1049     bbb.<caret>
1050   }
1051 }
1052 ''')
1053     myFixture.configureFromExistingVirtualFile file.virtualFile
1054     myFixture.completeBasic()
1055     assertFalse(myFixture.lookupElementStrings.contains('Foo'))
1056   }
1057
1058   public void testClassNameBeforeParentheses(){
1059     doBasicTest()
1060   }
1061
1062   public void testNewClassGenerics() {
1063     checkSingleItemCompletion 'new ArrayLi<caret>', 'new ArrayList<<caret>>()'
1064   }
1065
1066   public void testInnerClassStart() {
1067     checkSingleItemCompletion 'class Foo { cl<caret> }', 'class Foo { class <caret> }'
1068   }
1069
1070   public void testPropertyBeforeAccessor() {
1071     doVariantableTest 'soSe', 'setSoSe'
1072   }
1073
1074   public void testSortOrder0() {
1075     doVariantableTest 'se', 'setMetaClass', 'setProperty', 'setSe'
1076   }
1077
1078   public void testPrimitiveCastOverwrite() {
1079     checkCompletion 'byte v1 = (by<caret>te) 0', '\t', 'byte v1 = (byte<caret>) 0'
1080   }
1081
1082   public void testInitializerMatters() throws Exception {
1083     myFixture.configureByText("a.groovy", "class Foo {{ String f<caret>x = getFoo(); }; String getFoo() {}; }");
1084     myFixture.completeBasic()
1085     assert myFixture.lookupElementStrings == ["foo"]
1086   }
1087
1088   public void testFieldInitializerMatters() throws Exception {
1089     myFixture.configureByText("a.groovy", "class Foo { String f<caret>x = getFoo(); String getFoo() {}; }");
1090     myFixture.completeBasic()
1091     assert myFixture.lookupElementStrings == ["foo"]
1092   }
1093
1094   public void testAccessStaticViaInstanceSecond() throws Exception {
1095     myFixture.configureByText("a.groovy", """
1096 public class KeyVO {
1097   { this.fo<caret>x }
1098   static void foo() {}
1099 }
1100 """);
1101     myFixture.complete(CompletionType.BASIC, 1)
1102     assert !myFixture.lookupElementStrings
1103     myFixture.complete(CompletionType.BASIC, 2)
1104     assert myFixture.lookupElementStrings == ["foo"]
1105   }
1106
1107   public void testNoRepeatingModifiers() {
1108     myFixture.configureByText 'a.groovy', 'class A { public static <caret> }'
1109     myFixture.completeBasic()
1110     assert !('public' in myFixture.lookupElementStrings)
1111     assert !('static' in myFixture.lookupElementStrings)
1112     assert 'final' in myFixture.lookupElementStrings
1113   }
1114
1115   public void testSpaceTail() {
1116     checkCompletion 'class A <caret> ArrayList {}', ' ', 'class A extends <caret> ArrayList {}'
1117     checkCompletion 'class A <caret> ArrayList {}', '\n', 'class A extends<caret> ArrayList {}'
1118     checkSingleItemCompletion 'class Foo impl<caret> {}', 'class Foo implements <caret> {}'
1119   }
1120
1121   public void testPreferInterfacesInImplements() {
1122     myFixture.addClass('interface FooIntf {}')
1123     myFixture.addClass('class FooClass {}')
1124     doVariantableTest('FooIntf', 'FooClass')
1125   }
1126 }