IDEA-248001 Annotation parameter completion in generics doesn't work correctly
[idea/community.git] / java / java-tests / testSrc / com / intellij / java / codeInsight / completion / NormalCompletionTest.groovy
1 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
2 package com.intellij.java.codeInsight.completion
3
4 import com.intellij.codeInsight.CodeInsightSettings
5 import com.intellij.codeInsight.JavaProjectCodeInsightSettings
6 import com.intellij.codeInsight.completion.CompletionType
7 import com.intellij.codeInsight.completion.JavaPsiClassReferenceElement
8 import com.intellij.codeInsight.lookup.Lookup
9 import com.intellij.codeInsight.lookup.LookupElement
10 import com.intellij.codeInsight.lookup.LookupElementPresentation
11 import com.intellij.codeInsight.lookup.LookupManager
12 import com.intellij.codeInsight.lookup.impl.LookupImpl
13 import com.intellij.lang.java.JavaLanguage
14 import com.intellij.openapi.actionSystem.IdeActions
15 import com.intellij.psi.PsiClass
16 import com.intellij.psi.PsiDocumentManager
17 import com.intellij.psi.PsiMethod
18 import com.intellij.psi.PsiTypeParameter
19 import com.intellij.psi.codeStyle.CodeStyleSettingsManager
20 import com.intellij.psi.codeStyle.CommonCodeStyleSettings
21 import com.intellij.psi.codeStyle.JavaCodeStyleSettings
22 import com.intellij.testFramework.LightProjectDescriptor
23 import com.intellij.testFramework.NeedsIndex
24 import com.intellij.testFramework.PlatformTestUtil
25 import com.intellij.util.ui.UIUtil
26 import com.siyeh.ig.style.UnqualifiedFieldAccessInspection
27 import groovy.transform.CompileStatic
28 import org.jetbrains.annotations.NotNull
29
30 @CompileStatic
31 class NormalCompletionTest extends NormalCompletionTestCase {
32
33   @NotNull
34   @Override
35   protected LightProjectDescriptor getProjectDescriptor() {
36     return JAVA_9
37   }
38
39   void testSimple() throws Exception {
40     configureByFile("Simple.java")
41     assertStringItems("_local1", "_local2", "_field", "_baseField", "_method", "_baseMethod")
42   }
43
44   void testCastToPrimitive1() throws Exception {
45     configureByFile("CastToPrimitive1.java")
46
47     for (final LookupElement item : myItems) {
48       if (item.getLookupString().equals("int")) return
49     }
50     assertTrue(false)
51   }
52
53   void testCastToPrimitive2() throws Exception {
54     configureByFile("CastToPrimitive2.java")
55
56     for (final LookupElement item : myItems) {
57       if (item.getLookupString().equals("int")) return
58     }
59     assertTrue(false)
60   }
61
62   void testCastToPrimitive3() throws Exception {
63     configureByFile("CastToPrimitive3.java")
64
65     for (final LookupElement item : myItems) {
66       if (item.getLookupString().equals("int")) return
67     }
68     assertTrue(false)
69   }
70
71   void testWriteInInvokeLater() throws Exception {
72     configureByFile("WriteInInvokeLater.java")
73   }
74
75   void testQualifiedNew1() throws Exception {
76     configure()
77     assertStringItems "IInner", "Inner"
78   }
79
80   void testQualifiedNew2() throws Exception {
81     configure()
82     assertStringItems "AnInner", "Inner"
83   }
84
85   void testKeywordsInName() throws Exception {
86     doTest 'a\n'
87   }
88
89   @NeedsIndex.ForStandardLibrary
90   void testSimpleVariable() throws Exception { doTest('\n') }
91
92   void testTypeParameterItemPresentation() {
93     configure()
94     LookupElementPresentation presentation = renderElement(myItems[0])
95     assert "Param" == presentation.itemText
96     assert presentation.tailText == " type parameter of Foo"
97     assert !presentation.typeText
98     assert !presentation.icon
99     assert !presentation.itemTextBold
100
101     presentation = renderElement(myItems[1])
102     assert "Param2" == presentation.itemText
103     assert presentation.tailText == " type parameter of goo"
104   }
105
106   void testDisplayDefaultValueInAnnotationMethods() {
107     configure()
108     LookupElementPresentation presentation = renderElement(myItems[0])
109     assert "myInt" == presentation.itemText
110     assert presentation.tailText == " default 42"
111     assert presentation.tailFragments[0].grayed
112     assert !presentation.typeText
113     assert !presentation.itemTextBold
114
115     presentation = renderElement(myItems[1])
116     assert "myString" == presentation.itemText
117     assert presentation.tailText == ' default "unknown"'
118   }
119
120   @NeedsIndex.ForStandardLibrary
121   void testMethodItemPresentation() {
122     configure()
123     LookupElementPresentation presentation = renderElement(myItems[0])
124     assert "equals" == presentation.itemText
125     assert "(Object anObject)" == presentation.tailText
126     assert "boolean" == presentation.typeText
127
128     assert !presentation.tailFragments.any { it.grayed }
129     assert presentation.itemTextBold
130   }
131
132   void testFieldItemPresentationGenerics() {
133     configure()
134     LookupElementPresentation presentation = renderElement(myItems[0])
135     assert "target" == presentation.itemText
136     assert !presentation.tailText
137     assert "String" == presentation.typeText
138   }
139
140   @NeedsIndex.ForStandardLibrary
141   void testMethodItemPresentationGenerics() {
142     configure()
143     LookupElementPresentation presentation = renderElement(myItems[1])
144     assert "add" == presentation.itemText
145     assert "(int index, String element)" == presentation.tailText
146     assert "void" == presentation.typeText
147
148     presentation = renderElement(myItems[0])
149     assert "(String e)" == presentation.tailText
150     assert "boolean" == presentation.typeText
151
152     assert !presentation.tailFragments.any { it.grayed }
153     assert presentation.itemTextBold
154   }
155
156   void testPreferLongerNamesOption() throws Exception {
157     configureByFile("PreferLongerNamesOption.java")
158
159     assertEquals(3, myItems.length)
160     assertEquals("abcdEfghIjk", myItems[0].getLookupString())
161     assertEquals("efghIjk", myItems[1].getLookupString())
162     assertEquals("ijk", myItems[2].getLookupString())
163
164     LookupManager.getInstance(getProject()).hideActiveLookup()
165
166     JavaCodeStyleSettings.getInstance(getProject()).PREFER_LONGER_NAMES = false
167       configureByFile("PreferLongerNamesOption.java")
168
169       assertEquals(3, myItems.length)
170       assertEquals("ijk", myItems[0].getLookupString())
171       assertEquals("efghIjk", myItems[1].getLookupString())
172       assertEquals("abcdEfghIjk", myItems[2].getLookupString())
173   }
174
175   void testSCR7208() throws Exception {
176     configureByFile("SCR7208.java")
177   }
178
179   @NeedsIndex.ForStandardLibrary
180   void testProtectedFromSuper() throws Exception {
181     configureByFile("ProtectedFromSuper.java")
182     Arrays.sort(myItems)
183     assertTrue("Exception not found", Arrays.binarySearch(myItems, "xxx") > 0)
184   }
185
186   @NeedsIndex.ForStandardLibrary
187   void testBeforeInitialization() throws Exception {
188     configureByFile("BeforeInitialization.java")
189     assertNotNull(myItems)
190     assertTrue(myItems.length > 0)
191   }
192
193   @NeedsIndex.ForStandardLibrary
194   void testProtectedFromSuper2() throws Exception {
195
196     configureByFile("ProtectedFromSuper.java")
197     Arrays.sort(myItems)
198     assertTrue("Exception not found", Arrays.binarySearch(myItems, "xxx") > 0)
199   }
200
201   void testClassLiteralInArrayAnnoInitializer() throws Throwable { doTest() }
202
203   void testClassLiteralInArrayAnnoInitializer2() throws Throwable { doTest() }
204
205   void testReferenceParameters() throws Exception {
206     configureByFile("ReferenceParameters.java")
207     assertNotNull(myItems)
208     myFixture.assertPreferredCompletionItems 0, 'AAAA', 'AAAB'
209   }
210
211   @Override
212   protected void tearDown() throws Exception {
213     CodeInsightSettings.instance.AUTOCOMPLETE_ON_CODE_COMPLETION = true
214     CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.FIRST_LETTER)
215     CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = true
216     super.tearDown()
217   }
218
219   void testConstructorName1() throws Exception {
220     CodeInsightSettings.getInstance().AUTOCOMPLETE_ON_CODE_COMPLETION = false
221     configure()
222     assert 'ABCDE' in myFixture.lookupElementStrings
223   }
224
225   void testConstructorName2() throws Exception {
226     CodeInsightSettings.getInstance().AUTOCOMPLETE_ON_CODE_COMPLETION = false
227     configure()
228     assert 'ABCDE' in myFixture.lookupElementStrings
229   }
230
231   @NeedsIndex.ForStandardLibrary
232   void testObjectsInThrowsBlock() throws Exception {
233     configureByFile("InThrowsCompletion.java")
234     assert "C" == myFixture.lookupElementStrings[0]
235     assert "B" in myFixture.lookupElementStrings
236   }
237
238   void testAnnoParameterValue() throws Exception {
239     configure()
240     def strings = myFixture.lookupElementStrings
241     assert 'AssertionError' in strings
242     assert !('enum' in strings)
243     assert !('final' in strings)
244     assert !('equals' in strings)
245     assert !('new' in strings)
246     assert !('null' in strings)
247     assert !('public' in strings)
248     assert !('super' in strings)
249     assert !('null' in strings)
250   }
251
252   void testAfterInstanceof() throws Exception {
253     configureByFile("AfterInstanceof.java")
254     assert "A" in myFixture.lookupElementStrings
255   }
256
257   void testAfterCast1() throws Exception {
258     configureByFile("AfterCast1.java")
259
260     assertNotNull(myItems)
261     assertEquals(2, myItems.length)
262   }
263
264   void testAfterCast2() throws Exception {
265     configureByFile("AfterCast2.java")
266     checkResultByFile("AfterCast2-result.java")
267   }
268
269   void testMethodCallForTwoLevelSelection() throws Exception {
270     configureByFile("MethodLookup.java")
271     assertEquals(2, myItems.length)
272   }
273
274   void testMethodCallBeforeAnotherStatementWithParen() throws Exception {
275     configureByFile("MethodLookup2.java")
276     checkResultByFile("MethodLookup2_After.java")
277   }
278
279   void testMethodCallBeforeAnotherStatementWithParen2() throws Exception {
280     codeStyleSettings.METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE = true
281     configureByFile("MethodLookup2.java")
282     checkResultByFile("MethodLookup2_After2.java")
283   }
284
285   void testSwitchEnumLabel() throws Exception {
286     configureByFile("SwitchEnumLabel.java")
287     assertEquals(3, myItems.length)
288   }
289
290   void testSwitchCaseWithEnumConstant() { doTest() }
291
292   void testSecondSwitchCaseWithEnumConstant() { doTest() }
293
294   @NeedsIndex.ForStandardLibrary
295   void testInsideSwitchCaseWithEnumConstant() {
296     configure()
297     myFixture.assertPreferredCompletionItems 0, 'compareTo', 'equals'
298   }
299
300   void testMethodInAnnotation() throws Exception {
301     configureByFile("Annotation.java")
302     checkResultByFile("Annotation_after.java")
303   }
304
305   void testMethodInAnnotation2() throws Exception {
306     configureByFile("Annotation2.java")
307     checkResultByFile("Annotation2_after.java")
308   }
309
310   void testMethodInAnnotation3() throws Exception {
311     configureByFile("Annotation3.java")
312     checkResultByFile("Annotation3_after.java")
313   }
314
315   void testMethodInAnnotation5() throws Exception {
316     configureByFile("Annotation5.java")
317     checkResultByFile("Annotation5_after.java")
318   }
319
320   void testMethodInAnnotation7() throws Exception {
321     configureByFile("Annotation7.java")
322     selectItem(myItems[0])
323     checkResultByFile("Annotation7_after.java")
324   }
325
326   void testEnumInAnnotation() throws Exception {
327     configureByFile("Annotation4.java")
328     checkResultByFile("Annotation4_after.java")
329   }
330
331   void testEnumInTypeAnnotation() { doTest() }
332
333   void testSecondAttribute() throws Exception {
334     configureByFile("Annotation6.java")
335     checkResultByFile("Annotation6_after.java")
336   }
337
338   void testIDEADEV6408() throws Exception {
339     configureByFile("IDEADEV6408.java")
340     assertFirstStringItems "boolean", "byte"
341   }
342
343   void testMethodWithLeftParTailType() throws Exception {
344     configureByFile("MethodWithLeftParTailType.java")
345     type('(')
346     checkResultByFile("MethodWithLeftParTailType_after.java")
347
348     configureByFile("MethodWithLeftParTailType2.java")
349     type('(')
350     checkResultByFile("MethodWithLeftParTailType2_after.java")
351   }
352
353   void testSuperErasure() throws Exception {
354     configureByFile("SuperErasure.java")
355     checkResultByFile("SuperErasure_after.java")
356   }
357
358   void testMethodWithLeftParTailTypeNoPairBrace() throws Exception {
359     CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = false
360     doTest('(')
361   }
362
363   void testMethodWithLeftParTailTypeNoPairBrace2() throws Exception {
364     CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = false
365
366     //no tail type should work the normal way
367     configureByFile("MethodWithLeftParTailTypeNoPairBrace.java")
368     selectItem(myItems[0])
369     checkResultByFile("MethodWithLeftParTailTypeNoPairBrace_after2.java")
370   }
371
372   void testMethodNoPairBrace() throws Exception {
373     CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = false
374     doTest '\n'
375   }
376
377   void testExcessSpaceInTypeCast() throws Throwable {
378    configure()
379    selectItem(myItems[0])
380    checkResult()
381   }
382
383   void testFieldType() { doTest() }
384
385   void testFieldOfLocalClass() {
386     configure()
387     assert renderElement(myItems[0]).itemText == 'field'
388     type('\t')
389     checkResult()
390   }
391
392   void testPackageInAnnoParam() throws Throwable {
393     doTest()
394   }
395
396   void testAnonymousTypeParameter() throws Throwable { doTest() }
397
398   @NeedsIndex.ForStandardLibrary
399   void testClassLiteralInAnnoParam() throws Throwable {
400     doTest()
401   }
402
403   @NeedsIndex.ForStandardLibrary
404   void testNoForceBraces() {
405     codeStyleSettings.IF_BRACE_FORCE = CommonCodeStyleSettings.FORCE_BRACES_ALWAYS
406     doTest('\n')
407   }
408
409   void testExcludeStringBuffer() throws Throwable {
410     JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, StringBuffer.name)
411     configure()
412     assert !('StringBuffer' in myFixture.lookupElementStrings)
413   }
414
415   @NeedsIndex.Full
416   void testExcludeInstanceInnerClasses() throws Throwable {
417     JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo")
418     myFixture.addClass 'package foo; public class Outer { public class Inner {} }'
419     myFixture.addClass 'package bar; public class Inner {}'
420     configure()
421     assert 'bar.Inner' == ((JavaPsiClassReferenceElement)myFixture.lookupElements[0]).qualifiedName
422     assert myFixture.lookupElementStrings == ['Inner']
423   }
424
425   @NeedsIndex.Full
426   void testExcludedInstanceInnerClassCreation() throws Throwable {
427     JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo")
428     myFixture.addClass 'package foo; public class Outer { public class Inner {} }'
429     myFixture.addClass 'package bar; public class Inner {}'
430     configure()
431     assert 'foo.Outer.Inner' == ((JavaPsiClassReferenceElement)myFixture.lookupElements[0]).qualifiedName
432     assert myFixture.lookupElementStrings == ['Inner']
433   }
434
435   @NeedsIndex.Full
436   void testExcludedInstanceInnerClassQualifiedReference() throws Throwable {
437     JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo")
438     myFixture.addClass 'package foo; public class Outer { public class Inner {} }'
439     myFixture.addClass 'package bar; public class Inner {}'
440     configure()
441     assert 'foo.Outer.Inner' == ((JavaPsiClassReferenceElement)myFixture.lookupElements[0]).qualifiedName
442     assert myFixture.lookupElementStrings == ['Inner']
443   }
444
445   @NeedsIndex.Full
446   void testStaticMethodOfExcludedClass() {
447     JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo")
448     myFixture.addClass 'package foo; public class Outer { public static void method() {} }'
449     configure()
450     assert myFixture.lookupElementStrings == ['method']
451   }
452
453   @NeedsIndex.Full
454   void testExcludeWildcards() {
455     JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo.Outer.*1*")
456     myFixture.addClass '''
457 package foo; 
458 public class Outer { 
459   public static void method1() {} 
460   public static void method2() {} 
461   public static void method12() {} 
462   public static void method42() {} 
463 }'''
464     myFixture.configureByText 'a.java', 'class C {{ foo.Outer.m<caret> }}'
465     myFixture.completeBasic()
466     assert myFixture.lookupElementStrings == ['method2', 'method42']
467   }
468
469   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for int hashCode lookup preventing autocompletion and additional \n)")
470   void testAtUnderClass() throws Throwable {
471     doTest('\n')
472   }
473
474   void testLocalClassName() throws Throwable { doTest() }
475
476   void testAssigningFieldForTheFirstTime() throws Throwable { doTest() }
477
478   void testClassTypeParameters() throws Throwable {
479     configure()
480     assert 'K' in myFixture.lookupElementStrings
481   }
482
483   void testClassTypeParametersGenericBounds() throws Throwable {
484     configure()
485     assert 'K' in myFixture.lookupElementStrings
486   }
487
488   @NeedsIndex.ForStandardLibrary
489   void testLocalClassTwice() throws Throwable {
490     configure()
491     assertOrderedEquals myFixture.lookupElementStrings, 'Zoooz', 'Zooooo', 'ZipOutputStream'
492   }
493
494   @NeedsIndex.ForStandardLibrary
495   void testLocalTopLevelConflict() throws Throwable {
496     configure()
497     assertOrderedEquals myFixture.lookupElementStrings, 'Zoooz', 'Zooooo', 'ZipOutputStream'
498   }
499
500   @NeedsIndex.ForStandardLibrary
501   void testFinalBeforeMethodCall() throws Throwable {
502     configure()
503     assertStringItems 'final', 'finalize'
504   }
505
506   void testMethodCallAfterFinally() { doTest() }
507
508   void testPrivateInAnonymous() throws Throwable { doTest() }
509
510   void testStaticMethodFromOuterClass() {
511     configure()
512     assertStringItems 'foo', 'A.foo', 'for'
513     assert renderElement(myItems[1]).itemText == 'A.foo'
514     selectItem(myItems[1])
515     checkResult()
516   }
517
518   void testInstanceMethodFromOuterClass() {
519     configure()
520     assertStringItems 'foo', 'A.this.foo', 'for'
521     assert renderElement(myItems[1]).itemText == 'A.this.foo'
522     selectItem(myItems[1])
523     checkResult()
524   }
525
526   void testMethodParenthesesSpaces() throws Throwable {
527     codeStyleSettings.SPACE_BEFORE_METHOD_CALL_PARENTHESES = true
528     codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
529     doTest()
530   }
531
532   void testMethodParenthesesSpacesArgs() throws Throwable {
533     codeStyleSettings.SPACE_BEFORE_METHOD_CALL_PARENTHESES = true
534     codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
535     doTest()
536   }
537
538   void testAtUnderClassNoModifiers() throws Throwable {
539     doTest()
540   }
541
542   void testBreakInIfCondition() throws Throwable { doTest() }
543
544   void testAccessStaticViaInstance() throws Throwable { doTest() }
545
546   void testIfConditionLt() {
547     configure()
548     myFixture.assertPreferredCompletionItems 0, 'getAnnotationsAreaOffset'
549   }
550
551   @NeedsIndex.ForStandardLibrary(reason = "On emptly indices 'foo' is the only item, so is not filtered out in  JavaCompletionProcessor.dispreferStaticAfterInstance")
552   void testAccessStaticViaInstanceSecond() throws Throwable {
553     configure()
554     assert !('foo' in myFixture.lookupElementStrings)
555     myFixture.complete(CompletionType.BASIC, 2)
556     myFixture.assertPreferredCompletionItems 0, 'foo'
557     myFixture.type('\n')
558     checkResult()
559   }
560
561   void testAccessInstanceFromStaticSecond() throws Throwable {
562     configure()
563     myFixture.complete(CompletionType.BASIC, 2)
564     checkResult()
565   }
566
567   void testBreakLabel() {
568     myFixture.configureByText("a.java", """
569       class a {{
570         foo: while (true) break <caret>
571       }}""".stripIndent())
572     complete()
573     assert myFixture.lookupElementStrings == ['foo']
574   }
575
576   void testContinueLabel() {
577     myFixture.configureByText("a.java", """
578       class a {{
579         foo: while (true) continue <caret>
580       }}""".stripIndent())
581     complete()
582     assert myFixture.lookupElementStrings == ['foo']
583   }
584
585   void testContinueLabelTail() {
586     myFixture.configureByText("a.java", """
587       class a {{
588         foo: while (true) con<caret>
589       }}""".stripIndent())
590     complete()
591     myFixture.checkResult("""
592       class a {{
593         foo: while (true) continue <caret>
594       }}""".stripIndent())
595   }
596
597   @NeedsIndex.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode")
598   void testAnonymousProcess() {
599     myFixture.addClass 'package java.lang; public class Process {}'
600     myFixture.addClass '''
601 import java.util.*;
602 public class Process {}
603 interface Pred <A> { boolean predicate(A elem); }
604 public class ListUtils {
605     public static <A> List<A> filter(List<A> list, Pred<A> pred) {}
606 }
607 '''
608     configure()
609     type '\n'
610     checkResult()
611   }
612
613   void testNoThisInComment() throws Throwable { doAntiTest() }
614
615   void testIncNull() throws Throwable {
616     configure()
617     checkResultByFile(getTestName(false) + ".java")
618     assert !('null' in myFixture.lookupElementStrings)
619   }
620
621   void testLastExpressionInFor() throws Throwable { doTest() }
622
623   void testOnlyKeywordsInsideSwitch() throws Throwable {
624     configureByFile(getTestName(false) + ".java")
625     assertStringItems("case", "default")
626   }
627
628   @NeedsIndex.ForStandardLibrary
629   void testBooleanLiterals() throws Throwable {
630     doTest('\n')
631   }
632
633   void testDoubleBooleanInParameter() throws Throwable {
634     configure()
635     assertFirstStringItems("boolean", "byte")
636   }
637
638   void testDoubleConstant() throws Throwable {
639     configure()
640     assertStringItems("Intf.XFOO", "XFOO")
641   }
642
643   void testNotOnlyKeywordsInsideSwitch() throws Throwable {
644     doTest()
645   }
646
647   @NeedsIndex.ForStandardLibrary
648   void testChainedCallOnNextLine() throws Throwable {
649     configureByFile(getTestName(false) + ".java")
650     selectItem(myItems[0])
651     checkResult()
652   }
653
654   void testFinishWithDot() throws Throwable {
655     configureByFile(getTestName(false) + ".java")
656     type('.')
657     checkResult()
658   }
659
660   void testEnclosingThis() throws Throwable { doTest() }
661
662   @NeedsIndex.Full
663   void testSeamlessConstant() throws Throwable {
664     configureByFile(getTestName(false) + ".java")
665     selectItem(myItems[0])
666     checkResult()
667   }
668
669   void testDefaultAnnoParam() throws Throwable { doTest() }
670
671   void testSpaceAfterLookupString() throws Throwable {
672     configureByFile(getTestName(false) + ".java")
673     type(' ')
674     assertNull(getLookup())
675     checkResult()
676   }
677
678   @NeedsIndex.ForStandardLibrary
679   void testNoSpaceInParensWithoutParams() throws Throwable {
680     codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
681     try {
682       doTest()
683     }
684     finally {
685       codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = false
686     }
687   }
688
689   @NeedsIndex.ForStandardLibrary
690   void testTwoSpacesInParensWithParams() throws Throwable {
691     codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
692     doTest()
693   }
694
695   @NeedsIndex.ForStandardLibrary
696   void testQualifierAsPackage() throws Throwable {
697     configureByFile(getTestName(false) + ".java")
698     selectItem(myItems[0])
699     checkResult()
700   }
701
702   @NeedsIndex.ForStandardLibrary
703   void testQualifierAsPackage2() throws Throwable {
704     doTest()
705   }
706
707   @NeedsIndex.ForStandardLibrary
708   void testQualifierAsPackage3() throws Throwable {
709     doTest()
710   }
711
712   @NeedsIndex.ForStandardLibrary
713   void testPreselectEditorSelection() {
714     configure()
715     assert lookup.currentItem != myFixture.lookupElements[0]
716     assert 'finalize' == lookup.currentItem.lookupString
717   }
718
719   void testNoMethodsInNonStaticImports() {
720     configure()
721     assertStringItems("*")
722   }
723
724   @NeedsIndex.ForStandardLibrary
725   void testMembersInStaticImports() { doTest('\n') }
726
727   @NeedsIndex.ForStandardLibrary
728   void testPackageNamedVariableBeforeAssignment() throws Throwable {
729     doTest()
730   }
731
732   void testInnerEnumConstant() throws Throwable { doTest('\n') }
733
734   void testNoExpectedReturnTypeDuplication() {
735     configure()
736     assert myFixture.lookupElementStrings == ['boolean', 'byte']
737   }
738   void testNoExpectedVoidReturnTypeDuplication() {
739     configure()
740     assert myFixture.lookupElementStrings == ['void']
741   }
742
743   void testNoExpectedArrayTypeDuplication() {
744     configure()
745     assert myFixture.lookupElementStrings == ['char']
746   }
747
748   void testShadowedTypeParameter() {
749     configure()
750     assert myFixture.lookupElementStrings == ['MyParam']
751   }
752
753   @NeedsIndex.ForStandardLibrary
754   void testMethodReturnType() { doTest('\n') }
755
756   void testMethodReturnTypeNoSpace() throws Throwable {
757     configureByFile(getTestName(false) + ".java")
758     selectItem(myItems[0])
759     checkResult()
760   }
761
762   void testEnumWithoutConstants() throws Throwable {
763     doTest()
764   }
765
766   @NeedsIndex.ForStandardLibrary
767   void testDoWhileMethodCall() throws Throwable {
768     doTest()
769   }
770
771   void testSecondTypeParameterExtends() throws Throwable {
772     doTest()
773   }
774
775   @NeedsIndex.ForStandardLibrary
776   void testGetterWithExistingNonEmptyParameterList() throws Throwable {
777     doTest()
778   }
779
780   void testNothingAfterNumericLiteral() throws Throwable { doAntiTest() }
781
782   void testNothingAfterTypeParameterQualifier() { doAntiTest() }
783
784   void testExcludeVariableBeingDeclared() { doAntiTest() }
785
786   void testExcludeVariableBeingDeclared2() { doAntiTest() }
787
788   void testSpacesAroundEq() throws Throwable { doTest('=') }
789
790   void _testClassBeforeCast() throws Throwable { doTest '\n' }
791
792   void testNoAllClassesOnQualifiedReference() throws Throwable {
793     doAntiTest()
794   }
795
796   void testFinishClassNameWithDot() throws Throwable {
797     doTest('.')
798   }
799
800   @NeedsIndex.ForStandardLibrary
801   void testFinishClassNameWithLParen() throws Throwable {
802     doTest('(')
803   }
804
805   void testSelectNoParameterSignature() throws Throwable {
806     configureByFile(getTestName(false) + ".java")
807     final int parametersCount = ((PsiMethod)getLookup().getCurrentItem().getObject()).getParameterList().getParametersCount()
808     assertEquals(0, parametersCount)
809     type '\n'
810     checkResult()
811   }
812
813   @NeedsIndex.ForStandardLibrary
814   void testCompletionInsideClassLiteral() throws Throwable {
815     configureByFile(getTestName(false) + ".java")
816     type('\n')
817     checkResult()
818   }
819
820   void testFieldNegation() throws Throwable { doTest('!') }
821
822   void testDefaultInSwitch() throws Throwable { doTest() }
823
824   void testBreakInSwitch() throws Throwable { doTest() }
825
826   void testSuperInConstructor() throws Throwable {
827     doTest()
828   }
829
830   @NeedsIndex.ForStandardLibrary
831   void testSuperInConstructorWithParams() throws Throwable {
832     doTest()
833   }
834
835   void testSuperInMethod() throws Throwable {
836     doTest()
837   }
838
839   void testSecondMethodParameterName() throws Throwable {
840     doTest()
841   }
842
843   void testAnnotationAsUsualObject() throws Throwable {
844     doTest()
845   }
846
847   void testAnnotationAsUsualObjectFromJavadoc() throws Throwable {
848     doTest()
849   }
850
851   void testAnnotationAsUsualObjectInsideClass() throws Throwable {
852     doTest()
853   }
854
855   void testAnnotationOnNothingParens() throws Throwable {
856     doTest()
857   }
858
859   void testMultiResolveQualifier() throws Throwable {
860     doTest()
861   }
862
863   void testSecondMethodParameter() throws Throwable { doTest() }
864
865   void testReturnInCase() throws Throwable { doTest() }
866
867   void testUnboxedConstantsInCase() throws Throwable { doTest() }
868
869   void testAnnotationWithoutValueMethod() throws Throwable {
870     configureByFile(getTestName(false) + ".java")
871     assertStringItems("bar", "foo")
872   }
873
874   void testAddExplicitValueInAnnotation() throws Throwable {
875     configureByTestName()
876     assertStringItems("bar", "goo")
877     selectItem(myItems[0])
878     checkResult()
879   }
880
881   void testUnnecessaryMethodMerging() throws Throwable {
882     configureByFile(getTestName(false) + ".java")
883     assertStringItems("fofoo", "fofoo")
884   }
885
886   @NeedsIndex.ForStandardLibrary
887   void testMethodMergingMinimalTail() { doTest() }
888
889   void testAnnotationQualifiedName() throws Throwable {
890     doTest()
891   }
892
893   @NeedsIndex.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode")
894   void testClassNameAnonymous() throws Throwable {
895     doTest('\n')
896   }
897
898   @NeedsIndex.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode")
899   void testClassNameWithInner() throws Throwable {
900     configure()
901     assertStringItems 'Zzoo', 'Zzoo.Impl'
902     type '\n'
903     checkResult()
904   }
905
906   void testClassNameWithInner2() throws Throwable { doTest('\n') }
907
908   void testClassNameWithInstanceInner() throws Throwable { doTest('\n') }
909
910   @NeedsIndex.ForStandardLibrary
911   void testDoubleFalse() throws Throwable {
912     configureByFile(getTestName(false) + ".java")
913     assertFirstStringItems("false", "fefefef", "float", "finalize")
914   }
915
916   void testSameNamedVariableInNestedClasses() throws Throwable {
917     configure()
918     myFixture.assertPreferredCompletionItems 0, "ffid", "Beda.this.ffid"
919     selectItem(myItems[1])
920     checkResult()
921   }
922
923   void testHonorUnderscoreInPrefix() throws Throwable {
924     doTest()
925   }
926
927   @NeedsIndex.ForStandardLibrary
928   void testNoSemicolonAfterExistingParenthesesEspeciallyIfItsACast() throws Throwable { doTest() }
929
930   void testReturningTypeVariable() throws Throwable { doTest() }
931
932   void testReturningTypeVariable2() throws Throwable { doTest() }
933
934   void testReturningTypeVariable3() throws Throwable { doTest() }
935
936   @NeedsIndex.ForStandardLibrary
937   void testImportInGenericType() throws Throwable {
938     configure()
939     myFixture.complete(CompletionType.BASIC, 2)
940     myFixture.type('\n')
941     checkResult()
942   }
943
944   void testCaseTailType() throws Throwable { doTest() }
945
946   def doPrimitiveTypeTest() {
947     configure()
948     checkResultByFile(getTestName(false) + ".java")
949     assertTrue 'boolean' in myFixture.lookupElementStrings
950   }
951
952   void testFinalInForLoop() throws Throwable {
953     configure()
954     assertStringItems 'final'
955   }
956
957   @NeedsIndex.ForStandardLibrary
958   void testFinalInForLoop2() throws Throwable {
959     configure()
960     myFixture.assertPreferredCompletionItems 0, 'finalize', 'final'
961   }
962
963   void testOnlyClassesInExtends() throws Throwable {
964     configure()
965     assertStringItems 'Inner'
966   }
967
968   void testNoThisClassInExtends() throws Throwable {
969     configure()
970     assertStringItems 'Fooxxxx2'
971   }
972
973   void testPrimitiveTypesInForLoop() throws Throwable { doPrimitiveTypeTest() }
974
975   void testPrimitiveTypesInForLoop2() throws Throwable { doPrimitiveTypeTest() }
976
977   void testPrimitiveTypesInForLoop3() throws Throwable { doPrimitiveTypeTest() }
978
979   void testPrimitiveTypesInForLoop4() throws Throwable { doPrimitiveTypeTest() }
980
981   void testPrimitiveTypesInForLoop5() throws Throwable { doPrimitiveTypeTest() }
982
983   void testPrimitiveTypesInForLoop6() throws Throwable { doPrimitiveTypeTest() }
984
985   void testPrimitiveTypesInForLoopSpace() throws Throwable {
986     configure()
987     myFixture.type ' '
988     checkResultByFile(getTestName(false) + "_after.java")
989   }
990
991   void testSuggestInaccessibleOnSecondInvocation() throws Throwable {
992     configure()
993     assertStringItems("_bar", "_goo")
994     complete()
995     assertStringItems("_bar", "_goo", "_foo")
996     getLookup().setCurrentItem(getLookup().getItems().get(2))
997     selectItem(lookup.items[2], Lookup.NORMAL_SELECT_CHAR)
998     checkResult()
999   }
1000
1001   void testNoCommonPrefixInsideIdentifier() throws Throwable {
1002     final String path = getTestName(false) + ".java"
1003     configureByFile(path)
1004     checkResultByFile(path)
1005     assertStringItems("fai1", "fai2")
1006   }
1007
1008   @NeedsIndex.Full
1009   void testProtectedInaccessibleOnSecondInvocation() throws Throwable {
1010     myFixture.configureByFile(getTestName(false) + ".java")
1011     myFixture.complete(CompletionType.BASIC, 2)
1012     myFixture.type('\n')
1013     checkResult()
1014   }
1015
1016   void testPropertyReferencePrefix() throws Throwable {
1017     myFixture.addFileToProject("test.properties", "foo.bar=Foo! Bar!").getVirtualFile()
1018     doAntiTest()
1019   }
1020
1021   @NeedsIndex.ForStandardLibrary
1022   void testSecondAnonymousClassParameter() { doTest() }
1023
1024   void testSpaceAfterReturn() throws Throwable {
1025     configure()
1026     type '\n'
1027     checkResult()
1028   }
1029
1030   void testIntersectionTypeMembers() throws Throwable {
1031     configure()
1032     assertStringItems "fooa", "foob"
1033   }
1034
1035   void testNoReturnInTernary() throws Throwable { doTest() }
1036
1037   void testWildcardsInLookup() throws Exception {
1038     configure()
1039     assertNotNull(getLookup())
1040     type('*fz')
1041     assert !lookup
1042   }
1043
1044   void testSmartEnterWrapsConstructorCall() throws Throwable { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
1045
1046   void testSmartEnterNoNewLine() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
1047
1048   void testSmartEnterWithNewLine() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
1049
1050   @NeedsIndex.SmartMode(reason = "MethodCallFixer.apply needs smart mode to count number of parameters")
1051   void testSmartEnterGuessArgumentCount() throws Throwable { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
1052
1053   void testSmartEnterInsideArrayBrackets() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
1054
1055   void testTabReplacesMethodNameWithLocalVariableName() throws Throwable { doTest('\t') }
1056
1057   void testMethodParameterAnnotationClass() throws Throwable { doTest() }
1058
1059   @NeedsIndex.Full
1060   void testInnerAnnotation() {
1061     configure()
1062     assert myFixture.lookupElementStrings == ['Dependency']
1063     type '\t'
1064     checkResult()
1065   }
1066
1067   void testPrimitiveCastOverwrite() throws Throwable { doTest() }
1068
1069   void testClassReferenceInFor() throws Throwable { doTest ' ' }
1070
1071   void testClassReferenceInFor2() throws Throwable { doTest ' ' }
1072
1073   void testClassReferenceInFor3() throws Throwable {
1074     CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE)
1075     doTest ' '
1076   }
1077
1078   void testEnumConstantFromEnumMember() throws Throwable { doTest() }
1079
1080   void testPrimitiveMethodParameter() throws Throwable { doTest() }
1081
1082   void testNewExpectedClassParens() throws Throwable { doTest('\n') }
1083
1084   void testQualifyInnerMembers() throws Throwable { doTest('\n') }
1085
1086   void testDeepInner() throws Throwable {
1087     configure()
1088     assert myFixture.lookupElementStrings == ['ClassInner1', 'ClassInner1.ClassInner2']
1089     selectItem(lookup.items[1])
1090     checkResult()
1091   }
1092
1093   void testSuggestExpectedTypeMembers() throws Throwable { doTest('\n') }
1094
1095   void testSuggestExpectedTypeMembersInCall() throws Throwable { doTest('\n') }
1096
1097   void testSuggestExpectedTypeMembersInAnno() throws Throwable { doTest('\n') }
1098
1099   void testExpectedTypesDotSelectsItem() throws Throwable { doTest('.') }
1100
1101   @NeedsIndex.Full
1102   void testExpectedTypeMembersVersusStaticImports() throws Throwable {
1103     configure()
1104     assertStringItems('XFOO', 'XFOX')
1105   }
1106
1107   @NeedsIndex.Full
1108   void testSuggestExpectedTypeMembersNonImported() throws Throwable {
1109     myFixture.addClass("package foo; public class Super { public static final Super FOO = null; }")
1110     myFixture.addClass("package foo; public class Usage { public static void foo(Super s) {} }")
1111     doTest('\n')
1112   }
1113
1114   @NeedsIndex.Full
1115   void testStaticallyImportedInner() throws Throwable {
1116     configure()
1117     assertStringItems('AIOInner', 'ArrayIndexOutOfBoundsException')
1118   }
1119
1120   void testClassNameInIfBeforeIdentifier() throws Throwable {
1121     myFixture.addClass("public class ABCDEFFFFF {}")
1122     doTest('\n')
1123   }
1124
1125   void testClassNameWithInnersTab() throws Throwable { doTest('\t') }
1126
1127   void testClassNameWithGenericsTab() throws Throwable { doTest('\t') }
1128
1129   void testLiveTemplatePrefixTab() throws Throwable { doTest('\t') }
1130
1131   void testOnlyAnnotationsAfterAt() throws Throwable { doTest() }
1132
1133   @NeedsIndex.ForStandardLibrary
1134   void testOnlyAnnotationsAfterAt2() throws Throwable { doTest('\n') }
1135
1136   void testAnnotationBeforeIdentifier() { doTest('\n') }
1137
1138   void testAnnotationBeforeQualifiedReference() { doTest('\n') }
1139
1140   void testAnnotationBeforeIdentifierFinishWithSpace() { doTest(' ') }
1141
1142   @NeedsIndex.ForStandardLibrary
1143   void testOnlyExceptionsInCatch1() throws Exception { doTest('\n') }
1144
1145   @NeedsIndex.ForStandardLibrary
1146   void testOnlyExceptionsInCatch2() throws Exception { doTest('\n') }
1147
1148   @NeedsIndex.ForStandardLibrary
1149   void testOnlyExceptionsInCatch3() throws Exception { doTest('\n') }
1150
1151   @NeedsIndex.ForStandardLibrary
1152   void testOnlyExceptionsInCatch4() throws Exception { doTest('\n') }
1153
1154   void testCommaAfterVariable() throws Throwable { doTest(',') }
1155
1156   void testClassAngleBracket() throws Throwable { doTest('<') }
1157
1158   void testNoArgsMethodSpace() throws Throwable { doTest(' ') }
1159
1160   void testClassSquareBracket() throws Throwable { doTest('[') }
1161
1162   void testPrimitiveSquareBracket() throws Throwable { doTest('[') }
1163
1164   void testVariableSquareBracket() throws Throwable { doTest('[') }
1165
1166   void testMethodSquareBracket() throws Throwable { doTest('[') }
1167
1168   void testMethodParameterTypeDot() throws Throwable { doAntiTest() }
1169
1170   @NeedsIndex.ForStandardLibrary
1171   void testNewGenericClass() throws Throwable { doTest('\n') }
1172
1173   void testNewGenericInterface() throws Throwable { doTest() }
1174
1175   void testEnumPrivateFinal() throws Throwable { doTest() }
1176
1177   void testNoFieldsInImplements() throws Throwable { doTest() }
1178
1179   void testSwitchConstantsFromReferencedClass() throws Throwable { doTest('\n') }
1180
1181   void testSwitchValueFinishWithColon() throws Throwable { doTest(':') }
1182
1183   void testUnfinishedMethodTypeParameter() throws Throwable {
1184     configure()
1185     assertStringItems("MyParameter", "MySecondParameter")
1186   }
1187
1188   void testUnfinishedMethodTypeParameter2() throws Throwable {
1189     configure()
1190     assertStringItems("MyParameter", "MySecondParameter")
1191   }
1192
1193   @NeedsIndex.Full
1194   void testSuperProtectedMethod() throws Throwable {
1195     myFixture.addClass """package foo;
1196       public class Bar {
1197           protected void foo() { }
1198       }"""
1199     doTest()
1200   }
1201
1202   @NeedsIndex.ForStandardLibrary
1203   void testOuterSuperMethodCall() {
1204     configure()
1205     assert 'Class2.super.put' == renderElement(myItems[0]).itemText
1206     type '\n'
1207     checkResult() }
1208
1209   void testTopLevelClassesFromPackaged() throws Throwable {
1210     myFixture.addClass "public class Fooooo {}"
1211     final text = "package foo; class Bar { Fooo<caret> }"
1212     def file = myFixture.addFileToProject("foo/Bar.java", text)
1213     myFixture.configureFromExistingVirtualFile file.virtualFile
1214     assertEmpty myFixture.completeBasic()
1215     myFixture.checkResult text
1216   }
1217
1218   void testRightShift() throws Throwable {
1219     configure()
1220     assertStringItems("myField1", "myField2")
1221   }
1222
1223   @NeedsIndex.ForStandardLibrary
1224   void testAfterCommonPrefix() throws Throwable {
1225     configure()
1226     type 'eq'
1227     assertFirstStringItems("equals", "equalsIgnoreCase")
1228     complete()
1229     assertFirstStringItems("equals", "equalsIgnoreCase")
1230     type '('
1231     checkResult()
1232   }
1233
1234   @NeedsIndex.ForStandardLibrary
1235   void testClassNameInsideIdentifierInIf() throws Throwable {
1236     configure()
1237     myFixture.complete(CompletionType.BASIC, 2)
1238     type '\n'
1239     checkResult()
1240   }
1241
1242   void testKeywordSmartEnter() {
1243     configure()
1244     myFixture.assertPreferredCompletionItems 0, 'null', 'nullity'
1245     myFixture.performEditorAction(IdeActions.ACTION_CHOOSE_LOOKUP_ITEM_COMPLETE_STATEMENT)
1246     checkResult()
1247   }
1248   void testSynchronizedArgumentSmartEnter() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
1249
1250   @NeedsIndex.Full
1251   void testImportStringValue() throws Throwable {
1252     myFixture.addClass("package foo; public class StringValue {}")
1253     myFixture.addClass("package java.lang; class StringValue {}")
1254     configure()
1255     myFixture.complete(CompletionType.BASIC, 2)
1256     type ' '
1257     checkResult()
1258   }
1259
1260   void testPrimitiveArrayWithRBrace() throws Throwable { doTest '[' }
1261
1262   @NeedsIndex.Full
1263   void testSuggestMembersOfStaticallyImportedClasses() throws Exception {
1264     myFixture.addClass("""package foo;
1265     public class Foo {
1266       public static void foo() {}
1267       public static void bar() {}
1268     }
1269     """)
1270     doTest('\n')
1271   }
1272
1273   @NeedsIndex.Full
1274   void testSuggestMembersOfStaticallyImportedClassesUnqualifiedOnly() throws Exception {
1275     myFixture.addClass("""package foo;
1276     public class Foo {
1277       public static void foo() {}
1278       public static void bar() {}
1279     }
1280     """)
1281     configure()
1282     complete()
1283     assertOneElement(myFixture.getLookupElements())
1284     myFixture.type '\t'
1285     checkResult()
1286   }
1287
1288   @NeedsIndex.Full
1289   void testSuggestMembersOfStaticallyImportedClassesConflictWithLocalMethod() throws Exception {
1290     myFixture.addClass("""package foo;
1291     public class Foo {
1292       public static void foo() {}
1293       public static void bar() {}
1294     }
1295     """)
1296     configure()
1297     myFixture.assertPreferredCompletionItems 0, 'bar', 'bar'
1298     assert renderElement(myFixture.lookupElements[1]).itemText == 'Foo.bar'
1299     myFixture.lookup.currentItem = myFixture.lookupElements[1]
1300     myFixture.type '\t'
1301     checkResult()
1302   }
1303
1304   @NeedsIndex.Full
1305   void testSuggestMembersOfStaticallyImportedClassesConflictWithLocalField() throws Exception {
1306     myFixture.addClass("""package foo;
1307     public class Foo {
1308       public static int foo = 1;
1309       public static int bar = 2;
1310     }
1311     """)
1312     configure()
1313     myFixture.assertPreferredCompletionItems 0, 'bar', 'Foo.bar'
1314     myFixture.lookup.currentItem = myFixture.lookupElements[1]
1315     myFixture.type '\t'
1316     checkResult()
1317   }
1318
1319   void testInstanceMagicMethod() throws Exception { doTest() }
1320
1321   void testNoDotOverwrite() throws Exception { doTest('.') }
1322
1323   void testNoModifierListOverwrite() { doTest('\t') }
1324
1325   void testStaticInnerExtendingOuter() throws Exception { doTest() }
1326
1327   void testPrimitiveClass() throws Exception { doTest() }
1328
1329   void testPrimitiveArrayClass() throws Exception { doTest() }
1330
1331   void testPrimitiveArrayOnlyClass() throws Exception { doAntiTest() }
1332
1333   void testPrimitiveArrayInAnno() throws Exception { doTest() }
1334
1335   void testNewClassAngleBracket() throws Exception { doTest('<') }
1336
1337   void testNewClassAngleBracketExpected() throws Exception { doTest('<') }
1338
1339   void testNewClassSquareBracket() throws Exception { doTest('[') }
1340
1341   void testMethodColon() throws Exception { doTest(':') }
1342
1343   void testVariableColon() throws Exception { doTest(':') }
1344
1345   void testFinishByClosingParenthesis() throws Exception { doTest(')') }
1346
1347   void testNoMethodsInParameterType() {
1348     configure()
1349     assertFirstStringItems "final", "float"
1350   }
1351
1352   @NeedsIndex.Full
1353   void testNonImportedClassInAnnotation() {
1354     myFixture.addClass("package foo; public class XInternalTimerServiceController {}")
1355     myFixture.configureByText "a.java", """
1356 class XInternalError {}
1357
1358 @interface Anno { Class value(); }
1359
1360 @Anno(XInternal<caret>)
1361 """
1362     myFixture.complete(CompletionType.BASIC, 2)
1363     assertFirstStringItems "XInternalError", "XInternalTimerServiceController"
1364   }
1365
1366   @NeedsIndex.Full
1367   void testNonImportedAnnotationClass() {
1368     myFixture.addClass("package foo; public @interface XAnotherAnno {}")
1369     configure()
1370     type('X')
1371     assertFirstStringItems "XAnno", "XAnotherAnno"
1372   }
1373
1374   @NeedsIndex.ForStandardLibrary
1375   void testMetaAnnotation() {
1376     myFixture.configureByText "a.java", "@<caret> @interface Anno {}"
1377     myFixture.complete(CompletionType.BASIC)
1378     assert myFixture.lookup.items.find { it.lookupString == 'Retention' }
1379   }
1380
1381   void testAnnotationClassFromWithinAnnotation() { doTest() }
1382
1383   @NeedsIndex.Full
1384   void testStaticallyImportedFieldsTwice() {
1385     myFixture.addClass("""
1386       class Foo {
1387         public static final int aZOO;
1388       }
1389     """)
1390     myFixture.configureByText("a.java", """
1391       import static Foo.*
1392       class Bar {{
1393         aZ<caret>a
1394       }}
1395     """)
1396     assertOneElement myFixture.completeBasic()
1397   }
1398
1399   void testStaticallyImportedFieldsTwiceSwitch() { doTest() }
1400
1401   void testStatementKeywords() {
1402     myFixture.configureByText("a.java", """
1403       class Bar {{
1404         <caret>xxx
1405       }}
1406     """)
1407     myFixture.completeBasic()
1408     final def strings = myFixture.lookupElementStrings
1409     assertTrue 'if' in strings
1410     assertTrue 'while' in strings
1411     assertTrue 'do' in strings
1412     assertTrue 'new' in strings
1413     assertTrue 'try' in strings
1414
1415     strings.remove 'new'
1416     assertFalse 'new' in strings
1417   }
1418
1419   void testExpressionKeywords() {
1420     myFixture.configureByText("a.java", """
1421       class Bar {{
1422         foo(<caret>xxx)
1423       }}
1424     """)
1425     myFixture.completeBasic()
1426     final def strings = myFixture.lookupElementStrings
1427     assertTrue 'new' in strings
1428   }
1429
1430   void testImportAsterisk() {
1431     myFixture.configureByText "a.java", "import java.lang.<caret>"
1432     myFixture.completeBasic()
1433     myFixture.type '*;'
1434     myFixture.checkResult "import java.lang.*;<caret>"
1435   }
1436
1437   void testDontPreselectCaseInsensitivePrefixMatch() {
1438     CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE)
1439     myFixture.configureByText "a.java", "import java.io.*; class Foo {{ int fileSize; fil<caret>x }}"
1440     myFixture.completeBasic()
1441     assert lookup.currentItem.lookupString == 'fileSize'
1442     myFixture.type('e')
1443
1444     assert lookup.items[0].lookupString == 'File'
1445     assert lookup.items[1].lookupString == 'fileSize'
1446     assert lookup.currentItem == lookup.items[1]
1447   }
1448
1449   @NeedsIndex.ForStandardLibrary
1450   void testNoGenericsWhenChoosingWithParen() { doTest('Ma(') }
1451
1452   @NeedsIndex.ForStandardLibrary
1453   void testNoClosingWhenChoosingWithParenBeforeIdentifier() { doTest '(' }
1454
1455   void testPackageInMemberType() { doTest() }
1456   void testPackageInMemberTypeGeneric() { doTest() }
1457
1458   @NeedsIndex.ForStandardLibrary
1459   void testConstantInAnno() { doTest('\n') }
1460
1461   @NeedsIndex.SmartMode(reason = "Smart mode needed for EncodingReferenceInjector to provide EncodingReference with variants")
1462   void testCharsetName() {
1463     myFixture.addClass("package java.nio.charset; public class Charset { public static Charset forName(String s) {} }")
1464     configureByTestName()
1465     assert myFixture.lookupElementStrings.contains('UTF-8')
1466   }
1467
1468   @NeedsIndex.Full
1469   void testInnerClassInExtendsGenerics() {
1470     def text = "package bar; class Foo extends List<Inne<caret>> { public static class Inner {} }"
1471     myFixture.configureFromExistingVirtualFile(myFixture.addClass(text).containingFile.virtualFile)
1472     myFixture.completeBasic()
1473     myFixture.type('\n')
1474     myFixture.checkResult(text.replace('Inne<caret>', 'Foo.Inner<caret>'))
1475   }
1476
1477   @NeedsIndex.ForStandardLibrary
1478   void testClassNameDot() { doTest('.') }
1479
1480   @NeedsIndex.Full
1481   void testClassNameDotBeforeCall() {
1482     myFixture.addClass("package foo; public class FileInputStreamSmth {}")
1483     myFixture.configureByFile(getTestName(false) + ".java")
1484     PsiDocumentManager.getInstance(project).commitAllDocuments()
1485     type '\b'
1486     PsiDocumentManager.getInstance(project).commitAllDocuments()
1487     myFixture.complete(CompletionType.BASIC, 2)
1488     assert lookup
1489     type '.'
1490     checkResult()
1491   }
1492
1493   void testNoReturnAfterDot() {
1494     configure()
1495     assert !('return' in myFixture.lookupElementStrings)
1496   }
1497
1498   @NeedsIndex.ForStandardLibrary
1499   void testDuplicateExpectedTypeInTypeArgumentList() {
1500     configure()
1501     def items = myFixture.lookupElements.findAll { it.lookupString == 'String' }
1502     assert items.size() == 1
1503     assert renderElement(items[0]).tailText == ' (java.lang)'
1504   }
1505
1506   void testDuplicateInnerClass() {
1507     configure()
1508     def items = myFixture.lookupElements.findAll { it.lookupString == 'Inner' }
1509     assert items.size() == 1
1510   }
1511
1512   void testSameSignature() {
1513     configure()
1514     myFixture.assertPreferredCompletionItems(0, 's', 's, file', 's, file, a')
1515     lookup.setCurrentItem(lookup.items[2])
1516     myFixture.type('\n')
1517     checkResult()
1518   }
1519
1520   @NeedsIndex.ForStandardLibrary
1521   void testNoParenthesesAroundCallQualifier() { doTest() }
1522
1523   @NeedsIndex.Full
1524   void testAllAssertClassesMethods() {
1525     myFixture.addClass 'package foo; public class Assert { public static boolean foo() {} }'
1526     myFixture.addClass 'package bar; public class Assert { public static boolean bar() {} }'
1527     configure()
1528     assert myFixture.lookupElementStrings == ['Assert.bar', 'Assert.foo']
1529     myFixture.type '\n'
1530     checkResult()
1531   }
1532
1533   @NeedsIndex.Full
1534   void testCastVisually() {
1535     configure()
1536     def p = renderElement(myFixture.lookupElements[0])
1537     assert p.itemText == 'getValue'
1538     assert p.itemTextBold
1539     assert p.typeText == 'Foo'
1540   }
1541
1542   @NeedsIndex.ForStandardLibrary
1543   void testSuggestEmptySet() {
1544     configure()
1545     assert 'emptySet' == myFixture.lookupElementStrings[0]
1546     type '\n'
1547     checkResult()
1548   }
1549
1550   @NeedsIndex.ForStandardLibrary
1551   void testSuggestAllTypeArguments() {
1552     configure()
1553     assert 'String, List<String>' == lookup.items[0].lookupString
1554     assert 'String, List<String>' == renderElement(lookup.items[0]).itemText
1555     type '\n'
1556     checkResult()
1557   }
1558
1559   void testNoFinalInAnonymousConstructor() { doTest() }
1560
1561   @NeedsIndex.ForStandardLibrary
1562   void testListArrayListCast() { doTest('\n') }
1563
1564   void testInterfaceImplementationNoCast() { doTest() }
1565
1566   @NeedsIndex.Full
1567   void testStaticallyImportedMethodsBeforeExpression() { doTest() }
1568
1569   @NeedsIndex.Full
1570   void testInnerChainedReturnType() { doTest() }
1571
1572   private CommonCodeStyleSettings getCodeStyleSettings() {
1573     return CodeStyleSettingsManager.getSettings(getProject()).getCommonSettings(JavaLanguage.INSTANCE)
1574   }
1575
1576   void testCompatibleInterfacesCast() {
1577     configure()
1578     assert myFixture.lookupElementStrings.containsAll(['foo', 'bar'])
1579   }
1580
1581   void testDontAutoInsertMiddleMatch() {
1582     configure()
1583     checkResult()
1584     assert lookup.items.size() == 1
1585   }
1586
1587   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for method implementations)")
1588   void testImplementViaCompletion() {
1589     configure()
1590     myFixture.assertPreferredCompletionItems 0, 'private', 'protected', 'public', 'public void run'
1591     def item = lookup.items[3]
1592
1593     def p = renderElement(item)
1594     assert p.itemText == 'public void run'
1595     assert p.tailText == '(String t, int myInt) {...}'
1596     assert p.typeText == 'Foo'
1597
1598     lookup.currentItem = item
1599     myFixture.type('\n')
1600     checkResult()
1601   }
1602
1603   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for implementing methods)")
1604   void testImplementViaCompletionWithGenerics() {
1605     configure()
1606     myFixture.assertPreferredCompletionItems 0, 'public void methodWithGenerics', 'public void methodWithTypeParam'
1607     assert renderElement(lookup.items[0]).tailText == '(List k) {...}'
1608     assert renderElement(lookup.items[1]).tailText == '(K k) {...}'
1609   }
1610
1611   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants provides dialog option in smart mode only")
1612   void testImplementViaOverrideCompletion() {
1613     configure()
1614     myFixture.assertPreferredCompletionItems 0, 'Override/Implement methods...', 'Override', 'public void run'
1615     lookup.currentItem = lookup.items[2]
1616     myFixture.type('\n')
1617     checkResult()
1618   }
1619
1620   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants provides dialog option in smart mode only")
1621   void testSuggestToOverrideMethodsWhenTypingOverrideAnnotation() {
1622     configure()
1623     myFixture.assertPreferredCompletionItems 0, 'Override/Implement methods...', 'Override'
1624     myFixture.type('\n')
1625     checkResult()
1626   }
1627
1628   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants provides dialog option in smart mode only")
1629   void testSuggestToOverrideMethodsWhenTypingOverrideAnnotationBeforeMethod() {
1630     configure()
1631     myFixture.assertPreferredCompletionItems 0, 'Override/Implement methods...', 'Override'
1632     myFixture.type('\n')
1633     checkResult()
1634   }
1635
1636   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for implementing methods)")
1637   void testStrikeOutDeprecatedSuperMethods() {
1638     configure()
1639     myFixture.assertPreferredCompletionItems 0, 'void foo1', 'void foo2'
1640     assert !renderElement(lookup.items[0]).strikeout
1641     assert renderElement(lookup.items[1]).strikeout
1642   }
1643
1644   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for equals() and hashCode())")
1645   void testInvokeGenerateEqualsHashCodeOnOverrideCompletion() { doTest() }
1646   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for 'toString()')")
1647   void testInvokeGenerateToStringOnOverrideCompletion() { doTest() }
1648
1649   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters and setters)")
1650   void testAccessorViaCompletion() {
1651     configure()
1652
1653     def getter = myFixture.lookupElements.find { it.lookupString == 'public int getField' }
1654     def setter = myFixture.lookupElements.find { it.lookupString == 'public void setField' }
1655     assert getter : myFixture.lookupElementStrings
1656     assert setter : myFixture.lookupElementStrings
1657
1658     def p = renderElement(getter)
1659     assert p.itemText == getter.lookupString
1660     assert p.tailText == '() {...}'
1661     assert !p.typeText
1662
1663     p = renderElement(setter)
1664     assert p.itemText == setter.lookupString
1665     assert p.tailText == '(int field) {...}'
1666     assert !p.typeText
1667
1668     lookup.currentItem = getter
1669     myFixture.type('\n')
1670     checkResult()
1671   }
1672
1673   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters and setters)")
1674   void testNoSetterForFinalField() {
1675     configure()
1676     myFixture.assertPreferredCompletionItems 0, 'public', 'public int getFinalField'
1677     assert !myFixture.lookupElements.find { it.lookupString == 'public void setFinalField' }
1678     assert !myFixture.lookupElements.find { it.lookupString == 'public int getCONSTANT' }
1679   }
1680
1681   void testBraceOnNextLine() {
1682     codeStyleSettings.BRACE_STYLE = CommonCodeStyleSettings.NEXT_LINE
1683     doTest()
1684   }
1685
1686   void testDoForceBraces() {
1687     codeStyleSettings.DOWHILE_BRACE_FORCE = CommonCodeStyleSettings.FORCE_BRACES_ALWAYS
1688     doTest('\n')
1689   }
1690
1691   void testMulticaretSingleItemInsertion() {
1692     doTest()
1693   }
1694
1695   @NeedsIndex.ForStandardLibrary
1696   void testMulticaretMethodWithParen() {
1697     doTest()
1698   }
1699
1700   @NeedsIndex.ForStandardLibrary
1701   void testMulticaretTyping() {
1702     configure()
1703     assert lookup
1704     type('p')
1705     assert lookup
1706     type('\n')
1707     checkResult()
1708   }
1709
1710   @NeedsIndex.ForStandardLibrary
1711   void testMulticaretCompletionFromNonPrimaryCaret() {
1712     configure()
1713     myFixture.assertPreferredCompletionItems(0, "arraycopy")
1714   }
1715
1716   void testMulticaretCompletionFromNonPrimaryCaretWithTab() {
1717     doTest '\t'
1718   }
1719
1720   @NeedsIndex.Full
1721   void "test complete lowercase class name"() {
1722     myFixture.addClass("package foo; public class myClass {}")
1723     myFixture.configureByText "a.java", """
1724 class Foo extends my<caret>
1725 """
1726     myFixture.complete(CompletionType.BASIC, 2)
1727     myFixture.checkResult '''import foo.myClass;
1728
1729 class Foo extends myClass
1730 '''
1731   }
1732
1733   void testNoClassesWithDollar() {
1734     myFixture.addClass('package some; public class $WithDollarNonImported {}')
1735     myFixture.addClass('package imported; public class $WithDollarImported {}')
1736     doAntiTest()
1737   }
1738
1739   @NeedsIndex.ForStandardLibrary
1740   void "test don't show static inner class after instance qualifier"() {
1741     myFixture.configureByText "a.java", """
1742 class Foo {
1743   static class Inner {}
1744 }
1745 class Bar {
1746   void foo(Foo f) {
1747     f.<caret>
1748   }
1749 }  
1750 """
1751     myFixture.completeBasic()
1752     assert !('Inner' in myFixture.lookupElementStrings)
1753   }
1754
1755   @NeedsIndex.ForStandardLibrary
1756   void "test show static member after instance qualifier when nothing matches"() {
1757     myFixture.configureByText "a.java", "class Foo{{ \"\".<caret> }}"
1758     myFixture.completeBasic()
1759     assert !('valueOf' in myFixture.lookupElementStrings)
1760     ((LookupImpl)myFixture.lookup).hide()
1761     myFixture.type 'val'
1762     myFixture.completeBasic()
1763     assert ('valueOf' in myFixture.lookupElementStrings)
1764   }
1765
1766   void testNoMathTargetMethods() { doAntiTest() }
1767
1768   @NeedsIndex.Full
1769   void testNoLowercaseClasses() {
1770     myFixture.addClass("package foo; public class abcdefgXxx {}")
1771     doAntiTest()
1772     myFixture.complete(CompletionType.BASIC, 2)
1773     assertStringItems('abcdefgXxx')
1774   }
1775
1776   @NeedsIndex.Full
1777   void testProtectedFieldInAnotherPackage() {
1778     myFixture.addClass("package foo; public class Super { protected String myString; }")
1779     doTest()
1780   }
1781
1782   @NeedsIndex.Full
1783   void testUnimportedStaticInnerClass() {
1784     myFixture.addClass("package foo; public class Super { public static class Inner {} }")
1785     doTest()
1786   }
1787
1788   void testNoJavaLangPackagesInImport() { doAntiTest() }
1789
1790   @NeedsIndex.Full
1791   void testNoStaticDuplicatesFromExpectedMemberFactories() {
1792     configure()
1793     myFixture.complete(CompletionType.BASIC, 2)
1794     myFixture.assertPreferredCompletionItems(0, "xcreateZoo", "xcreateElephant")
1795   }
1796
1797   void testNoInaccessibleCompiledElements() {
1798     configure()
1799     myFixture.complete(CompletionType.BASIC, 2)
1800     checkResultByFile(getTestName(false) + ".java")
1801     assertEmpty(myItems)
1802     assertNull(getLookup())
1803   }
1804
1805   @NeedsIndex.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters)")
1806   void "test code cleanup during completion generation"() {
1807     myFixture.configureByText "a.java", "class Foo {int i; ge<caret>}"
1808     myFixture.enableInspections(new UnqualifiedFieldAccessInspection())
1809     myFixture.complete(CompletionType.BASIC)
1810     UIUtil.dispatchAllInvocationEvents()
1811     myFixture.checkResult '''class Foo {int i;
1812
1813     public int getI() {
1814         return this.i;
1815     }
1816 }'''
1817   }
1818
1819   void testIndentingForSwitchCase() { doTest() }
1820
1821   void testShowMostSpecificOverride() {
1822     configure()
1823     assert 'B' == renderElement(myFixture.lookup.items[0]).typeText
1824   }
1825
1826   @NeedsIndex.ForStandardLibrary
1827   void testShowMostSpecificOverrideOnlyFromClass() {
1828     configure()
1829     assert 'Door' == renderElement(myFixture.lookup.items[0]).typeText
1830   }
1831
1832   void testNoOverrideWithMiddleMatchedName() {
1833     configure()
1834     assert !('public void removeTemporaryEditorNode' in myFixture.lookupElementStrings)
1835   }
1836
1837   void testShowVarInitializers() {
1838     configure()
1839     myFixture.assertPreferredCompletionItems 0, 'FIELD1', 'FIELD2', 'FIELD3', 'FIELD4'
1840     def items = myFixture.lookup.items
1841     assert items.collect { renderElement(it).tailText } == ['( "x")', '("y") {...}', null, ' ( = 42)']
1842     assert renderElement(items[3]).tailFragments[0].italic
1843   }
1844
1845   @NeedsIndex.Full
1846   void testShowNonImportedVarInitializers() {
1847     configure()
1848     myFixture.assertPreferredCompletionItems 1, 'Field', 'FIELD1', 'FIELD2', 'FIELD3', 'FIELD4'
1849     def fieldItems = myFixture.lookup.items[1..4]
1850     assert fieldItems.collect { renderElement(it).tailText } == ['( "x") in E', '("y") {...} in E', null, ' ( = 42) in E']
1851     assert renderElement(fieldItems[3]).tailFragments[0].italic
1852     assert !renderElement(fieldItems[3]).tailFragments[1].italic
1853   }
1854
1855   @NeedsIndex.ForStandardLibrary
1856   void testSuggestInterfaceArrayWhenObjectIsExpected() {
1857     configure()
1858     assert renderElement(myFixture.lookup.items[0]).tailText.contains('{...}')
1859     assert renderElement(myFixture.lookup.items[1]).tailText.contains('[]')
1860   }
1861
1862   @NeedsIndex.ForStandardLibrary
1863   void testSuggestInterfaceArrayWhenObjectArrayIsExpected() {
1864     configure()
1865     assert renderElement(myFixture.lookup.items[0]).tailText.contains('{...}')
1866     assert renderElement(myFixture.lookup.items[1]).tailText.contains('[]')
1867   }
1868
1869   void testDispreferPrimitiveTypesInCallArgs() throws Throwable {
1870     CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE)
1871     configure()
1872     myFixture.assertPreferredCompletionItems 0, "dx", "doo", "Doo", "double"
1873   }
1874
1875   @NeedsIndex.ForStandardLibrary
1876   void testCopyConstructor() { doTest('\n') }
1877
1878   @NeedsIndex.ForStandardLibrary
1879   void testGetClassType() {
1880     configure()
1881     assert 'Class<? extends Number>' == renderElement(myFixture.lookupElements[0]).typeText
1882   }
1883
1884   @NeedsIndex.Full
1885   void testNonImportedClassAfterNew() {
1886     def uClass = myFixture.addClass('package foo; public class U {}')
1887     myFixture.configureByText('a.java', 'class X {{ new U<caret>x }}')
1888     myFixture.completeBasic()
1889     assert myFixture.lookupElements[0].object == uClass
1890   }
1891
1892   void testSuggestClassNamesForLambdaParameterTypes() { doTest('\n') }
1893
1894   void testOnlyExtendsSuperInWildcard() {
1895     CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE)
1896
1897     configure()
1898     assert myFixture.lookupElementStrings == ['extends', 'super']
1899     LookupManager.getInstance(project).hideActiveLookup()
1900
1901     myFixture.type('n')
1902     assert !myFixture.completeBasic()
1903     myFixture.type('\b')
1904     checkResultByFile(getTestName(false) + ".java")
1905   }
1906
1907   @NeedsIndex.Full
1908   void testChainInLambdaBinary() {
1909     codeStyleSettings.ALIGN_MULTILINE_BINARY_OPERATION = true
1910     myFixture.addClass("package pkg; public class PathUtil { public static String toSystemDependentName() {} }")
1911     doTest('\n')
1912   }
1913
1914   @NeedsIndex.ForStandardLibrary
1915   void testPairAngleBracketDisabled() {
1916     CodeInsightSettings.instance.AUTOINSERT_PAIR_BRACKET = false
1917     doTest('<')
1918   }
1919
1920   void testDuplicateGenericMethodSuggestionWhenInheritingFromRawType() {
1921     configure()
1922     assert myFixture.lookupElementStrings == ['indexOf']
1923   }
1924
1925   @NeedsIndex.ForStandardLibrary
1926   void testDuplicateEnumValueOf() {
1927     configure()
1928     assert myFixture.lookupElements.collect { renderElement((LookupElement)it).itemText } == ['Bar.valueOf', 'Foo.valueOf', 'Enum.valueOf']
1929   }
1930
1931   void testTypeArgumentInCast() {
1932     configure()
1933     myFixture.assertPreferredCompletionItems 0, 'String'
1934   }
1935
1936   void testNoCallsInPackageStatement() { doAntiTest() }
1937
1938   @NeedsIndex.Full
1939   void testTypeParameterShadowingClass() {
1940     configure()
1941     myFixture.assertPreferredCompletionItems 0, 'Tttt', 'Tttt'
1942     assert myFixture.lookupElements[0].object instanceof PsiTypeParameter
1943     assert !(myFixture.lookupElements[1].object instanceof PsiTypeParameter)
1944     selectItem(myFixture.lookupElements[1])
1945     checkResult()
1946   }
1947
1948   void testLowercaseDoesNotMatchUnderscore() {
1949     configure()
1950     assert myFixture.lookupElementStrings == ['web']
1951   }
1952
1953   void testLocalClassPresentation() {
1954     def cls = myFixture.addFileToProject('foo/Bar.java', """package foo; 
1955 class Bar {{
1956     class Local {}
1957     Lo<caret>x
1958 }}""")
1959     myFixture.configureFromExistingVirtualFile(cls.containingFile.virtualFile)
1960     def item = myFixture.completeBasic()[0]
1961     assert renderElement(item).tailText.contains('local class')
1962   }
1963
1964   void testNoDuplicateInCast() {
1965     configure()
1966     assert myFixture.lookupElementStrings == null
1967   }
1968
1969   void testNoNonAnnotationMethods() { doAntiTest() }
1970
1971   @NeedsIndex.ForStandardLibrary
1972   void testPreferBigDecimalToJavaUtilInner() {
1973     configure()
1974     myFixture.assertPreferredCompletionItems 0, 'BigDecimal', 'BigDecimalLayoutForm'
1975   }
1976
1977   @NeedsIndex.ForStandardLibrary
1978   void testOnlyExceptionsInMultiCatch1() { doTest('\n') }
1979
1980   @NeedsIndex.ForStandardLibrary
1981   void testOnlyExceptionsInMultiCatch2() { doTest('\n') }
1982
1983   @NeedsIndex.ForStandardLibrary
1984   void testOnlyResourcesInResourceList1() { doTest('\n') }
1985
1986   @NeedsIndex.ForStandardLibrary
1987   void testOnlyResourcesInResourceList2() { doTest('\n') }
1988
1989   @NeedsIndex.ForStandardLibrary
1990   void testOnlyResourcesInResourceList3() { doTest('\n') }
1991
1992   @NeedsIndex.ForStandardLibrary
1993   void testOnlyResourcesInResourceList4() { doTest('\n') }
1994
1995   void testOnlyResourcesInResourceList5() { doTest('\n') }
1996
1997   @NeedsIndex.ForStandardLibrary
1998   void testMethodReferenceNoStatic() { doTest('\n') }
1999
2000   void testMethodReferenceCallContext() { doTest('\n') }
2001
2002   @NeedsIndex.Full
2003   void testDestroyingCompletedClassDeclaration() { doTest('\n') }
2004
2005   @NeedsIndex.ForStandardLibrary
2006   void testResourceParentInResourceList() {
2007     configureByTestName()
2008     assert 'MyOuterResource' == myFixture.lookupElementStrings[0]
2009     assert 'MyClass' in myFixture.lookupElementStrings
2010     myFixture.type('C\n')
2011     checkResultByFile(getTestName(false) + "_after.java")
2012   }
2013
2014   void testAfterTryWithResources() {
2015     configureByTestName()
2016     def strings = myFixture.lookupElementStrings
2017     assert strings.containsAll(['final', 'finally', 'int', 'Util'])
2018   }
2019
2020   void testNewObjectHashMapWithSmartEnter() {
2021     configureByTestName()
2022     myFixture.performEditorAction(IdeActions.ACTION_CHOOSE_LOOKUP_ITEM_COMPLETE_STATEMENT)
2023     checkResultByFile(getTestName(false) + "_after.java")
2024   }
2025
2026   @NeedsIndex.Full
2027   void testCompletingClassWithSameNameAsPackage() {
2028     myFixture.addClass("package Apple; public class Apple {}")
2029     doTest('\n')
2030   }
2031
2032   void testSuggestGetInstanceMethodName() { doTest() }
2033
2034   @NeedsIndex.Full(reason = "AllClassesSearchExecutor.processClassNames from JavaNoVariantsDelegator.suggestNonImportedClasses uses stub indices to provide completion, so matching Scratch class is ignored, ant so is its inner class")
2035   void testTabOnNewInnerClass() {
2036     configureByTestName()
2037     lookup.currentItem = myFixture.lookupElements.find { it.lookupString.contains('Inner') }
2038     myFixture.type('\t')
2039     checkResult()
2040   }
2041
2042   @NeedsIndex.Full
2043   void testRemoveUnusedImportOfSameName() {
2044     myFixture.addClass("package foo; public class List {}")
2045     configureByTestName()
2046     lookup.currentItem = myFixture.lookupElements.find { it.object instanceof PsiClass && ((PsiClass)it.object).qualifiedName == 'java.util.List' }
2047     myFixture.type('\n')
2048     checkResult()
2049   }
2050
2051   void "test no duplication after new with expected type parameter"() {
2052     myFixture.configureByText 'a.java', 'class Foo<T> { T t = new <caret> }'
2053     complete()
2054     assert myFixture.lookupElements.findAll { it.allLookupStrings.contains('T') }.size() < 2
2055   }
2056
2057   void "test no duplication for inner class on second invocation"() {
2058     myFixture.configureByText 'a.java', '''
2059 class Abc {
2060     class FooBar {}
2061     void foo() {
2062         FooBar<caret>x
2063     }
2064 }'''
2065     myFixture.complete(CompletionType.BASIC, 2)
2066     assert myFixture.lookupElements.size() == 1
2067   }
2068
2069   void "test smart enter wraps type arguments"() {
2070     myFixture.configureByText 'a.java', 'class Foo<T> { F<caret>List<String> }'
2071     myFixture.completeBasic()
2072     myFixture.type(Lookup.COMPLETE_STATEMENT_SELECT_CHAR)
2073     myFixture.checkResult 'class Foo<T> { Foo<List<String>><caret> }'
2074   }
2075
2076   void testNoSuggestionsAfterEnumConstant() { doAntiTest() }
2077
2078   void testPutCaretInsideParensInFixedPlusVarargOverloads() { doTest('\n') }
2079
2080   void testSuggestCurrentClassInSecondSuperGenericParameter() { doTest('\n') }
2081
2082   @NeedsIndex.Full
2083   void "test after new editing prefix back and forth when sometimes there are expected type suggestions and sometimes not"() {
2084     myFixture.addClass("class Super {}")
2085     myFixture.addClass("class Sub extends Super {}")
2086     myFixture.addClass("package foo; public class SubOther {}")
2087     myFixture.configureByText('a.java', "class C { Super s = new SubO<caret>x }")
2088
2089     myFixture.completeBasic()
2090     myFixture.assertPreferredCompletionItems 0, 'SubOther'
2091     myFixture.type('\b')
2092     myFixture.assertPreferredCompletionItems 0, 'Sub'
2093     myFixture.type('O')
2094     myFixture.assertPreferredCompletionItems 0, 'SubOther'
2095   }
2096
2097   void "test correct typos"() {
2098     myFixture.configureByText("a.java", "class MyClass { MyCals<caret> }")
2099     myFixture.completeBasic()
2100     myFixture.type('\n')
2101     myFixture.checkResult("class MyClass { MyClass<caret> }")
2102   }
2103
2104   void testRemoveParenthesesWhenReplacingEmptyCallWithConstant() {
2105     doTest('\t')
2106   }
2107
2108   void testNoCallsAfterAnnotationInCodeBlock() { doTest() }
2109   
2110   void testExtendsAfterEnum() {
2111     myFixture.configureByText("a.java", "enum X ex<caret>") // should not complete
2112     myFixture.completeBasic()
2113     myFixture.checkResult("enum X ex")
2114   }
2115
2116   @NeedsIndex.Full
2117   void testAddImportWhenCompletingInnerAfterNew() {
2118     myFixture.addClass("package p; public class Outer { public static class Inner {} }")
2119     configureByTestName()
2120     selectItem(myItems.find { it.lookupString.contains('Inner') })
2121     checkResult()
2122   }
2123
2124   void "test completing qualified class name"() {
2125     myFixture.configureByText("a.java", "class C implements java.util.Li<caret>")
2126     myFixture.completeBasic()
2127     myFixture.assertPreferredCompletionItems(0, 'List')
2128     myFixture.type('\n')
2129     myFixture.checkResult("class C implements java.util.List<caret>")
2130   }
2131
2132   @NeedsIndex.ForStandardLibrary
2133   void "test suggest Object methods when super is unresolved"() {
2134     def checkGetClassPresent = { String text ->
2135       myFixture.configureByText("a.java", text)
2136       myFixture.completeBasic()
2137       myFixture.assertPreferredCompletionItems 0, 'getClass'
2138     }
2139     checkGetClassPresent("class C extends Unresolved {{ getCl<caret>x }}")
2140     checkGetClassPresent("class C implements Unresolved {{ getCl<caret>x }}")
2141     checkGetClassPresent("class C extends Unresolved implements Runnable {{ getCl<caret>x }}")
2142     checkGetClassPresent("class C extends Unresolved1 implements Unresolved2 {{ getCl<caret>x }}")
2143   }
2144
2145   void testSuggestInverseOfDefaultAnnoParamValueForBoolean() {
2146     configureByTestName()
2147     myFixture.assertPreferredCompletionItems(0, 'smth = true', 'value = false')
2148
2149     def smthDefault = myItems.find { it.lookupString == 'smth = false' }
2150     def presentation = renderElement(smthDefault)
2151     assert presentation.tailText == ' (default)'
2152     assert presentation.tailFragments[0].grayed
2153
2154     myFixture.type('\n')
2155     checkResult()
2156   }
2157
2158   void testCaseColonAfterStringConstant() { doTest() }
2159
2160   void testOneElementArray() {
2161     configureByTestName()
2162     myFixture.assertPreferredCompletionItems 0, 'aaa', 'aaa[0]'
2163     selectItem(myItems[1])
2164     checkResult()
2165   }
2166
2167   void testSuggestChainsOfExpectedType() {
2168     configure()
2169     myFixture.assertPreferredCompletionItems 0, 'bar', 'bar().getGoo'
2170     selectItem(myItems[1])
2171     checkResult()
2172   }
2173
2174   void testTopLevelPublicClass() { doTest() }
2175   void testTopLevelPublicClassIdentifierExists() { doTest() }
2176   void testTopLevelPublicClassBraceExists() { doTest() }
2177
2178   void testPerformanceWithManyNonMatchingDeclarations() {
2179     def importedNumbers = 0..<10
2180     for (i in (importedNumbers)) {
2181       myFixture.addClass("class Foo$i {\n" +
2182                          (0..100).collect { "static int FOO$it = 3;\n" }.join("") +
2183                          "}")
2184     }
2185     String text = importedNumbers.collect { "import static Foo${it}.*;\n" }.join("") +
2186                   "class C {\n" +
2187                   (0..100).collect { "String method$it() {}\n" } +
2188                   "{ " +
2189                   "int localVariable = 2;\n" +
2190                   "localV<caret>x }" +
2191                   "}"
2192     myFixture.configureByText("a.java", text)
2193     PlatformTestUtil.startPerformanceTest(name, 300, {
2194       assert myFixture.completeBasic().length == 1
2195     }).setup {
2196       lookup?.hideLookup(true)
2197       myFixture.type("\bV")
2198       psiManager.dropPsiCaches()
2199       assert !lookup
2200     }.assertTiming()
2201   }
2202
2203   void "test performance with many matching statically-imported declarations"() {
2204     def fieldCount = 7000
2205
2206     myFixture.addClass("interface Constants {" +
2207             (0..<fieldCount).collect { "String field$it = \"x\";\n" } +
2208     "}")
2209     myFixture.configureByText("a.java", "import static Constants.*; class C { { field<caret>x } }")
2210     PlatformTestUtil.startPerformanceTest(name, 10_000, {
2211       assert myFixture.completeBasic().length > 100
2212     }).setup {
2213       lookup?.hideLookup(true)
2214       myFixture.type("\bd")
2215       psiManager.dropPsiCaches()
2216       assert !lookup
2217     }.assertTiming()
2218   }
2219 }