autopopup completion in javadoc local reference (IDEA-131899)
[idea/community.git] / java / java-tests / testSrc / com / intellij / codeInsight / completion / JavaAutoPopupTest.groovy
1 /*
2  * Copyright 2000-2014 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.codeInsight.completion
17
18 import com.intellij.codeInsight.CodeInsightSettings
19 import com.intellij.codeInsight.TargetElementUtil
20 import com.intellij.codeInsight.completion.impl.CompletionServiceImpl
21 import com.intellij.codeInsight.editorActions.CompletionAutoPopupHandler
22 import com.intellij.codeInsight.lookup.Lookup
23 import com.intellij.codeInsight.lookup.LookupElementPresentation
24 import com.intellij.codeInsight.lookup.LookupManager
25 import com.intellij.codeInsight.lookup.PsiTypeLookupItem
26 import com.intellij.codeInsight.lookup.impl.LookupImpl
27 import com.intellij.codeInsight.template.*
28 import com.intellij.codeInsight.template.impl.*
29 import com.intellij.ide.DataManager
30 import com.intellij.ide.ui.UISettings
31 import com.intellij.openapi.Disposable
32 import com.intellij.openapi.actionSystem.IdeActions
33 import com.intellij.openapi.application.ApplicationManager
34 import com.intellij.openapi.command.CommandProcessor
35 import com.intellij.openapi.command.WriteCommandAction
36 import com.intellij.openapi.command.impl.CurrentEditorProvider
37 import com.intellij.openapi.command.impl.UndoManagerImpl
38 import com.intellij.openapi.command.undo.UndoManager
39 import com.intellij.openapi.editor.Editor
40 import com.intellij.openapi.editor.EditorFactory
41 import com.intellij.openapi.editor.LogicalPosition
42 import com.intellij.openapi.editor.actionSystem.EditorActionManager
43 import com.intellij.openapi.editor.ex.EditorEx
44 import com.intellij.openapi.extensions.Extensions
45 import com.intellij.openapi.extensions.LoadingOrder
46 import com.intellij.openapi.fileEditor.FileEditor
47 import com.intellij.openapi.fileEditor.FileEditorManager
48 import com.intellij.openapi.progress.ProgressManager
49 import com.intellij.openapi.util.Computable
50 import com.intellij.openapi.util.Disposer
51 import com.intellij.psi.PsiClass
52 import com.intellij.psi.PsiFile
53 import com.intellij.psi.PsiJavaFile
54 import com.intellij.psi.PsiMethod
55 import com.intellij.psi.statistics.StatisticsManager
56 import com.intellij.psi.statistics.impl.StatisticsManagerImpl
57 import com.intellij.testFramework.EditorTestUtil
58 import com.intellij.util.containers.ContainerUtil
59 import org.jetbrains.annotations.NotNull
60
61 import java.awt.event.KeyEvent
62
63 /**
64  * @author peter
65  */
66 class JavaAutoPopupTest extends CompletionAutoPopupTestCase {
67
68   public void testNewItemsOnLongerPrefix() {
69     myFixture.configureByText("a.java", """
70       class Foo {
71         void foo(String iterable) {
72           <caret>
73         }
74       }
75     """)
76     type('i')
77     def les = myFixture.lookupElementStrings
78     assert 'iterable' in les
79     assert 'if' in les
80     assert 'int' in les
81
82     type('t')
83     assertContains "iterable"
84     assertEquals 'iterable', lookup.currentItem.lookupString
85
86     type('er')
87     les = myFixture.lookupElementStrings
88     assert 'iterable' in les
89     assert 'iter' in les
90     assertEquals 'iter', lookup.currentItem.lookupString
91     assert lookup.focused
92
93     type 'a'
94     assert lookup.focused
95   }
96
97   public void testAfterDblColon() {
98     myFixture.configureByText("a.java", """
99       class Foo {
100         void foo() {
101           Runnable::<caret>
102         }
103       }
104     """)
105     type('r')
106     def les = myFixture.lookupElementStrings
107     assert 'run' in les
108     assert lookup.focused
109   }
110
111   def assertContains(String... items) {
112     myFixture.assertPreferredCompletionItems(0, items)
113   }
114
115   public void testRecalculateItemsOnBackspace() {
116     myFixture.configureByText("a.java", """
117       class Foo {
118         void foo(String iterable) {
119           int itaa;
120           ite<caret>
121         }
122       }
123     """)
124     type "r"
125     myFixture.assertPreferredCompletionItems 0, "iter", "iterable"
126
127     type '\b'
128     assertContains "iterable"
129
130     type '\b'
131     assertContains "itaa", "iterable"
132     type "a"
133     assertContains "itaa"
134     type '\b'
135     assertContains "itaa", "iterable"
136     type "e"
137     assertContains "iterable"
138
139     type "r"
140     myFixture.assertPreferredCompletionItems 0, "iter", "iterable"
141   }
142
143   public void testExplicitSelectionShouldSurvive() {
144     myFixture.configureByText("a.java", """
145       class Foo {
146         void foo(String iterable) {
147           int iterable2;
148           it<caret>
149         }
150       }
151     """)
152     type "e"
153     assertContains "iterable", "iterable2"
154
155     assertEquals 'iterable', lookup.currentItem.lookupString
156     edt { myFixture.performEditorAction IdeActions.ACTION_EDITOR_MOVE_CARET_DOWN }
157     assertEquals 'iterable2', lookup.currentItem.lookupString
158
159     type "r"
160     myFixture.assertPreferredCompletionItems 2, "iter", "iterable", 'iterable2'
161
162   }
163
164   public void testExplicitMouseSelectionShouldSurvive() {
165     myFixture.configureByText("a.java", """
166       class Foo {
167         void foo(String iterable) {
168           int iterable2;
169           it<caret>
170         }
171       }
172     """)
173     type "e"
174     assertContains "iterable", "iterable2"
175
176     assertEquals 'iterable', lookup.currentItem.lookupString
177     edt { lookup.currentItem = lookup.items[1] }
178     assertEquals 'iterable2', lookup.currentItem.lookupString
179
180     type "r"
181     myFixture.assertPreferredCompletionItems 2, "iter", "iterable", 'iterable2'
182
183   }
184
185   public void testGenerallyFocusLookupInJavaMethod() {
186     myFixture.configureByText("a.java", """
187       class Foo {
188         String foo(String iterable) {
189           return it<caret>;
190         }
191       }
192     """)
193     type 'e'
194     assertTrue lookup.focused
195   }
196
197   public void testNoLookupFocusInJavaVariable() {
198     myFixture.configureByText("a.java", """
199       class Foo {
200         String foo(String st<caret>) {
201         }
202       }
203     """)
204     type 'r'
205     assertFalse lookup.focused
206   }
207
208   public void testNoStupidNameSuggestions() {
209     myFixture.configureByText("a.java", """
210       class Foo {
211         String foo(String <caret>) {
212         }
213       }
214     """)
215     type 'x'
216     assert !myFixture.lookupElementStrings
217   }
218
219   public void testExplicitSelectionShouldBeHonoredFocused() {
220     myFixture.configureByText("a.java", """
221       class Foo {
222         String foo() {
223           int abcd;
224           int abce;
225           a<caret>
226         }
227       }
228     """)
229     type 'b'
230     assert lookup.focused
231     type 'c'
232
233     assertContains 'abcd', 'abce'
234     assertEquals 'abcd', lookup.currentItem.lookupString
235     edt { lookup.currentItem = lookup.items[1] }
236     assertEquals 'abce', lookup.currentItem.lookupString
237
238     type '\t'
239     myFixture.checkResult """
240       class Foo {
241         String foo() {
242           int abcd;
243           int abce;
244           abce<caret>
245         }
246       }
247     """
248   }
249
250
251   public void "test popup in javadoc reference"() {
252     myFixture.configureByText("a.java", """
253     /**
254     * {@link AIO<caret>}
255     */
256       class Foo {}
257     """)
258     type 'O'
259     assert lookup
260   }
261
262   public void "test popup in javadoc local reference"() {
263     myFixture.configureByText("a.java", """
264     /**
265     * {@link #<caret>}
266     */
267       class Foo {
268         void foo() {}
269       }
270     """)
271     type 'f'
272     assert lookup
273   }
274
275   public void "test autopopup in javadoc tag name"() {
276     myFixture.configureByText("a.java", """
277     /**
278     * @a<caret>
279     */
280       class Foo {}
281     """)
282     type 'u'
283     assert lookup
284   }
285
286   public void "test no autopopup in javadoc parameter descriptions"() {
287     myFixture.configureByText("a.java", """
288 class Foo {
289   /**
290   * @param o some sentence
291   */
292   void foo(Object o) {}
293
294   /**
295   * @param o s<caret>
296   */
297   void foo2(Object o) {}
298 }
299     """)
300     type 'o'
301     assert !lookup
302   }
303
304   public void testPrefixLengthDependentSorting() {
305     myFixture.addClass("package foo; public class PsiJavaCodeReferenceElement {}")
306     myFixture.configureByText("a.java", """
307     import foo.PsiJavaCodeReferenceElement;
308
309     class PsiJavaCodeReferenceElementImpl {
310       { <caret> }
311     }
312     """)
313     type 'PJCR'
314     assertContains 'PsiJavaCodeReferenceElement', 'PsiJavaCodeReferenceElementImpl'
315
316   }
317
318   public void testQuickSelectAfterReuse() {
319     myFixture.configureByText("a.java", """
320     class A { Iterable iterable;
321       { <caret> }
322     }
323     """)
324     type 'ite'
325     edt {
326       myFixture.type 'r'
327       lookup.markReused()
328       lookup.currentItem = lookup.items[0]
329       CommandProcessor.instance.executeCommand project, {lookup.finishLookup Lookup.NORMAL_SELECT_CHAR}, null, null
330
331     }
332     myFixture.checkResult """
333     class A { Iterable iterable;
334       { iterable<caret> }
335     }
336     """
337   }
338
339   public void testQuickSelectAfterReuseAndBackspace() {
340     myFixture.configureByText("a.java", """
341     class A { Iterable iterable;
342       { <caret> }
343     }
344     """)
345     type 'ite'
346     edt {
347       myFixture.type 'r'
348       lookup.markReused()
349       myFixture.type '\b\b'
350       lookup.currentItem = lookup.items[0]
351       CommandProcessor.instance.executeCommand project, ({lookup.finishLookup Lookup.NORMAL_SELECT_CHAR} as Runnable), null, null
352     }
353     myFixture.checkResult """
354     class A { Iterable iterable;
355       { iterable<caret> }
356     }
357     """
358   }
359
360   public void testQuickSelectLiveTemplate() {
361     myFixture.configureByText("a.java", """
362     class A {
363       { <caret> }
364     }
365     """)
366     type 'th'
367     edt { myFixture.type 'r\t'}
368     myFixture.checkResult """
369     class A {
370       { throw new <caret> }
371     }
372     """
373   }
374
375   public void testTwoQuickRestartsAfterHiding() {
376     for (i in 0..10) {
377       myFixture.configureByText("a${i}.java", """
378       class A {
379         { <caret> }
380       }
381       """)
382       edt { myFixture.type 'A' }
383       joinAutopopup() // completion started
384       boolean tooQuick = false
385       edt {
386         tooQuick = lookup == null
387         myFixture.type 'IO'
388       }
389       joinAutopopup() //I
390       joinAutopopup() //O
391       joinCompletion()
392       assert lookup
393       assert 'ArrayIndexOutOfBoundsException' in myFixture.lookupElementStrings
394       if (!tooQuick) {
395         return
396       }
397       edt {
398         LookupManager.getInstance(project).hideActiveLookup()
399         CompletionProgressIndicator.cleanupForNextTest()
400       }
401     }
402     fail "too many too quick attempts"
403   }
404
405   public void testTypingDuringExplicitCompletion() {
406     myFixture.configureByText("a.java", """
407     class A {
408       { Runnable r = new <caret> }
409     }
410     """)
411     myFixture.complete CompletionType.SMART
412     edt { myFixture.type 'Thr' }
413     joinCompletion()
414     assert lookup
415     assert 'Thread' in myFixture.lookupElementStrings
416   }
417
418   public void testDotAfterVariable() {
419     myFixture.configureByText("a.java", """
420     class A {
421       { Object ooo; <caret> }
422     }
423     """)
424     type 'o.'
425     assert myFixture.file.text.contains("ooo.")
426     assert lookup
427   }
428
429   public void testDotAfterCall() {
430     myFixture.configureByText("a.java", """
431     class A {
432       { <caret> }
433     }
434     """)
435     type 'tos.'
436     assert myFixture.file.text.contains("toString().")
437     assert lookup
438   }
439
440   public void testDotAfterClassName() {
441     myFixture.configureByText("a.java", """
442     class A {
443       { <caret> }
444     }
445     """)
446     type 'AIOO.'
447     assert myFixture.file.text.contains("ArrayIndexOutOfBoundsException.")
448     assert lookup
449   }
450
451   public void testDotAfterClassNameInParameter() {
452     myFixture.configureByText("a.java", """
453     class A {
454       void foo(<caret>) {}
455     }
456     """)
457     type 'AIOO...'
458     assert myFixture.editor.document.text.contains("ArrayIndexOutOfBoundsException...")
459     assert !lookup
460   }
461
462   void testArrows(String toType, int indexDown, int indexUp) {
463     Closure checkArrow = { String action, int expectedIndex ->
464       myFixture.configureByText("a.java", """
465       class A {
466         void foo() {}
467         void farObject() {}
468         void fzrObject() {}
469         { <caret> }
470       }
471       """)
472
473       type toType
474       assert lookup
475       assert !lookup.focused
476
477       edt { myFixture.performEditorAction(action) }
478       if (lookup) {
479         assert lookup.focused
480         assert expectedIndex >= 0
481         assert lookup.items[expectedIndex] == lookup.currentItem
482         edt { lookup.hide() }
483       } else {
484         assert expectedIndex == -1
485       }
486       type '\b'
487     }
488
489     checkArrow(IdeActions.ACTION_EDITOR_MOVE_CARET_UP, indexUp)
490     checkArrow(IdeActions.ACTION_EDITOR_MOVE_CARET_DOWN, indexDown)
491   }
492
493   public void "test vertical arrows in non-focused lookup"() {
494     String toType = "ArrayIndexOutOfBoundsException ind"
495     testArrows toType, 0, 1
496
497     UISettings.instance.CYCLE_SCROLLING = false
498     try {
499       testArrows toType, 0, -1
500     }
501     finally {
502       UISettings.instance.CYCLE_SCROLLING = true
503     }
504   }
505
506   public void "test vertical arrows in semi-focused lookup"() {
507     CodeInsightSettings.instance.SELECT_AUTOPOPUP_SUGGESTIONS_BY_CHARS = false
508     UISettings.getInstance().SORT_LOOKUP_ELEMENTS_LEXICOGRAPHICALLY = true
509
510     String toType = "fo"
511     testArrows toType, 2, 0
512
513     UISettings.instance.CYCLE_SCROLLING = false
514     try {
515       testArrows toType, 2, 0
516     }
517     finally {
518       UISettings.instance.CYCLE_SCROLLING = true
519     }
520   }
521
522   public void testHideOnOnePrefixVariant() {
523     myFixture.configureByText("a.java", """
524     class A {
525       Object foo() { return nu<caret> }
526     }
527     """)
528     type 'll'
529     assert !lookup
530   }
531
532   public void testResumeAfterBackspace() {
533     myFixture.configureByText("a.java", """
534     class A {
535       Object foo() { this<caret> }
536     }
537     """)
538     type '.'
539     assert lookup
540     type 'x'
541     assert !lookup
542     type '\b'
543     assert !lookup
544     type 'c'
545     assert lookup
546   }
547
548   public void testHideOnInvalidSymbolAfterBackspace() {
549     myFixture.configureByText("a.java", """
550     class A {
551       Object foo() { this<caret> }
552     }
553     """)
554     type '.'
555     assert lookup
556     type 'c'
557     assert lookup
558     type '\b'
559     assert lookup
560     type 'x'
561     assert !lookup
562   }
563
564   public void testDoubleLiteralInField() {
565     myFixture.configureByText "a.java", """
566 public interface Test {
567   double FULL = 1.0<caret>
568 }"""
569     type 'd'
570     assert !lookup
571   }
572
573   public void testCancellingDuringCalculation() {
574     myFixture.configureByText "a.java", """
575 class Aaaaaaa {}
576 public interface Test {
577   <caret>
578 }"""
579     edt { myFixture.type 'A' }
580     joinAutopopup()
581     def first = lookup
582     assert first
583     edt {
584       assert first == lookup
585       lookup.hide()
586       myFixture.type 'a'
587     }
588     joinAutopopup()
589     joinAutopopup()
590     joinAutopopup()
591     assert lookup != first
592   }
593
594   static class LongReplacementOffsetContributor extends CompletionContributor {
595     @Override
596     void duringCompletion(@NotNull CompletionInitializationContext cxt) {
597       Thread.sleep 500
598       ProgressManager.checkCanceled()
599       cxt.replacementOffset--;
600     }
601   }
602
603   static class LongContributor extends CompletionContributor {
604
605     @Override
606     void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull CompletionResultSet result) {
607       result.runRemainingContributors(parameters, true)
608       Thread.sleep 500
609     }
610   }
611
612   public void testDuringCompletionMustFinish() {
613     registerContributor(LongReplacementOffsetContributor)
614
615     edt { myFixture.addFileToProject 'directory/foo.txt', '' }
616     myFixture.configureByText "a.java", 'public interface Test { RuntiExce<caret>xxx }'
617     myFixture.completeBasic()
618     while (!lookup.items) {
619       Thread.sleep(10)
620       edt { lookup.refreshUi(false, false) }
621     }
622     edt { myFixture.type '\t' }
623     myFixture.checkResult 'public interface Test { RuntimeException<caret>x }'
624  }
625
626   private def registerContributor(final Class contributor, LoadingOrder order = LoadingOrder.LAST) {
627     registerCompletionContributor(contributor, testRootDisposable, order)
628   }
629   static def registerCompletionContributor(final Class contributor, Disposable parentDisposable, LoadingOrder order) {
630     def ep = Extensions.rootArea.getExtensionPoint("com.intellij.completion.contributor")
631     def bean = new CompletionContributorEP(language: 'JAVA', implementationClass: contributor.name)
632     ep.registerExtension(bean, order)
633     Disposer.register(parentDisposable, { ep.unregisterExtension(bean) } as Disposable)
634   }
635
636   public void testLeftRightMovements() {
637     myFixture.configureByText("a.java", """
638       class Foo {
639         void foo(String iterable) {
640           <caret>ter   x
641         }
642       }
643     """)
644     type('i')
645     def offset = myFixture.editor.caretModel.offset
646     assertContains "iterable", "if", "int"
647
648     edt { myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_RIGHT) }
649     assert myFixture.editor.caretModel.offset == offset + 1
650     joinAutopopup()
651     joinCompletion()
652     assert !lookup.calculating
653     assertContains "iterable"
654     assertEquals 'iterable', lookup.currentItem.lookupString
655
656     edt { myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_LEFT) }
657     assert myFixture.editor.caretModel.offset == offset
658     joinAutopopup()
659     joinCompletion()
660     assert !lookup.calculating
661     assertContains "iterable", "if", "int"
662     assertEquals 'iterable', lookup.currentItem.lookupString
663
664     edt { myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_LEFT) }
665     joinAutopopup()
666     joinCompletion()
667     assert !lookup.calculating
668     assert lookup.items.size() > 3
669
670     for (i in 0.."iter".size()) {
671       edt { myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_RIGHT) }
672     }
673     assert !lookup
674   }
675
676   public void testMulticaretLeftRightMovements() {
677     myFixture.configureByText("a.java", """
678       class Foo {
679         void foo(String iterable) {
680           <caret>ter   x
681           <caret>ter   x
682         }
683       }
684     """)
685     type('i')
686     assert lookup
687
688     edt { myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_RIGHT) }
689     myFixture.checkResult """
690       class Foo {
691         void foo(String iterable) {
692           it<caret>er   x
693           it<caret>er   x
694         }
695       }
696     """
697     joinAutopopup()
698     joinCompletion()
699     assert lookup
700     assert !lookup.calculating
701
702     edt { myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_LEFT) }
703     myFixture.checkResult """
704       class Foo {
705         void foo(String iterable) {
706           i<caret>ter   x
707           i<caret>ter   x
708         }
709       }
710     """
711     joinAutopopup()
712     joinCompletion()
713     assert lookup
714     assert !lookup.calculating
715   }
716
717   public void testTypingInAnotherEditor() {
718     myFixture.configureByText("a.java", "")
719     type 'c'
720     assert lookup
721
722     Editor another = null
723     def wca = new WriteCommandAction.Simple(getProject(), new PsiFile[0]) {
724       @Override
725       protected void run() {
726         EditorActionManager.instance.getTypedAction().handler.execute(another, (char) 'x', DataManager.instance.dataContext)
727       }
728     }
729
730     try {
731       edt {
732         assert !lookup.calculating
733         lookup.hide()
734         def file = myFixture.addFileToProject("b.java", "")
735         another = EditorFactory.instance.createEditor(file.viewProvider.document, project)
736         wca.execute()
737         assert 'x' == another.document.text
738       }
739       joinAutopopup()
740       joinCompletion()
741       LookupImpl l1 = LookupManager.getActiveLookup(another)
742       if (l1) {
743         printThreadDump()
744         println l1.items
745         println l1.calculating
746         println myFixture.editor
747         println another
748         println CompletionServiceImpl.completionPhase
749         assert false : l1.items
750       }
751       type 'l'
752       assert lookup
753     }
754     finally {
755       edt { EditorFactory.instance.releaseEditor(another) }
756     }
757
758   }
759
760   public void testExplicitCompletionOnEmptyAutopopup() {
761     myFixture.configureByText("a.java", "<caret>")
762     type 'cccccc'
763     myFixture.completeBasic()
764     joinCompletion()
765     assert !lookup
766   }
767
768   public void testNoSingleTemplateLookup() {
769     myFixture.configureByText 'a.java', 'class Foo { psv<caret> }'
770     type 'm'
771     assert !lookup : myFixture.lookupElementStrings
772   }
773
774   public void testTemplatesWithNonImportedClasses() {
775     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
776     myFixture.addClass("package foo.bar; public class ToArray {}")
777     try {
778       myFixture.configureByText 'a.java', 'class Foo {{ foo(<caret>) }}'
779       type 'toar'
780       assert lookup
781       assert 'toar' in myFixture.lookupElementStrings
782       assert 'ToArray' in myFixture.lookupElementStrings
783     }
784     finally {
785       CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.FIRST_LETTER
786     }
787   }
788
789   public void testTemplateSelectionBySpace() {
790     myFixture.configureByText("a.java", """
791 class Foo {
792     int ITER = 2;
793     int itea = 2;
794
795     {
796         it<caret>
797     }
798 }
799 """)
800     type 'er '
801     assert !myFixture.editor.document.text.contains('for ')
802   }
803
804   public void testNewClassParenthesis() {
805     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
806     try {
807       myFixture.configureByText("a.java", """ class Foo { { new <caret> } } """)
808       type 'aioo('
809       assert myFixture.editor.document.text.contains('new ArrayIndexOutOfBoundsException()')
810     }
811     finally {
812       CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.FIRST_LETTER
813     }
814   }
815
816   public void testUnknownMethodParenthesis() {
817     myFixture.configureByText("a.java", """ class Foo { { <caret> } } """)
818     type 'filinpstr('
819     assert myFixture.editor.document.text.contains('filinpstr()')
820   }
821
822   public void testNoAutopopupAfterSpace() {
823     myFixture.configureByText("a.java", """ class Foo { { int newa; <caret> } } """)
824     edt { myFixture.type('new ') }
825     joinAutopopup()
826     joinCompletion()
827     assert !lookup
828   }
829
830   public void testRestartAndTypingDuringCopyCommit() {
831     registerContributor(LongReplacementOffsetContributor)
832
833     myFixture.configureByText("a.java", """ class Foo { { int newa; <caret> } } """)
834     myFixture.type 'n'
835     joinAutopopup()
836     myFixture.type 'e'
837     joinCommit() // original commit
838     myFixture.type 'w'
839     joinAutopopup()
840     joinCompletion()
841     myFixture.type '\n'
842     myFixture.checkResult(" class Foo { { int newa; new <caret> } } ")
843     assert !lookup
844   }
845
846   public void testAutoRestartAndTypingDuringCopyCommit() {
847     registerContributor(LongReplacementOffsetContributor)
848
849     myFixture.configureByText("a.java", """ class Foo { { int iteraaa; <caret> } } """)
850     type 'ite'
851     assert !('iter' in myFixture.lookupElementStrings)
852     myFixture.type 'r'
853     joinCommit()
854     myFixture.type 'a'
855     joinAutopopup()
856     joinCompletion()
857     myFixture.type '\n'
858     myFixture.checkResult(" class Foo { { int iteraaa; iteraaa<caret> } } ")
859     assert !lookup
860   }
861
862   public void testChoosingItemDuringCopyCommit() {
863     registerContributor(LongReplacementOffsetContributor)
864
865     myFixture.configureByText("a.java", """ class Foo { { int iteraaa; <caret> } } """)
866     type 'ite'
867     assert !('iter' in myFixture.lookupElementStrings)
868     assert 'iteraaa' in myFixture.lookupElementStrings
869     myFixture.type 'r'
870     joinCommit()
871     myFixture.type 'a.'
872     myFixture.checkResult(" class Foo { { int iteraaa; iteraaa.<caret> } } ")
873   }
874
875   public void testRestartWithInvisibleLookup() {
876     registerContributor(LongReplacementOffsetContributor)
877
878     myFixture.configureByText("a.java", """ class Foo { { int abcdef; <caret> } } """)
879     myFixture.type 'a'
880     joinAutopopup()
881     assert lookup
882     edt { myFixture.type 'bc' }
883     joinAutopopup()
884     joinAutopopup()
885     joinCompletion()
886     assert lookup
887     assert lookup.shown
888   }
889
890   public void testRestartWithVisibleLookup() {
891     registerContributor(LongContributor, LoadingOrder.FIRST)
892
893     myFixture.configureByText("a.java", """ class Foo { { int abcdef, abcdefg; ab<caret> } } """)
894     myFixture.completeBasic()
895     while (!lookup.shown) {
896       Thread.sleep(1)
897     }
898     def l = lookup
899     edt {
900       if (!lookup.calculating) println "testRestartWithVisibleLookup couldn't be faster than LongContributor"
901       myFixture.type 'c'
902     }
903     joinCommit {
904       myFixture.type 'd'
905     }
906     joinAutopopup()
907     joinCompletion()
908     assert lookup == l
909     assert !lookup.calculating
910     assert lookup.shown
911   }
912
913   private void joinSomething(int degree) {
914     if (degree == 0) return
915     joinCommit()
916     if (degree == 1) return
917     joinCommit()
918     if (degree == 2) return
919     edt {}
920     if (degree == 3) return
921     joinCompletion()
922   }
923
924   public void testEveryPossibleWayToTypeIf() {
925     def src = "class Foo { { int ifa; <caret> } }"
926     def result = "class Foo { { int ifa; if <caret> } }"
927     int actions = 4
928
929     for (a1 in 0..actions) {
930       for (a2 in 0..actions) {
931         myFixture.configureByText("$a1 $a2 .java", src)
932         myFixture.type 'i'
933         joinSomething(a1)
934         myFixture.type 'f'
935         joinSomething(a2)
936         myFixture.type ' '
937
938         joinAutopopup()
939         joinCompletion()
940         myFixture.checkResult(result)
941         assert !lookup
942       }
943     }
944
945     for (a1 in 0..actions) {
946       myFixture.configureByText("$a1 if .java", src)
947       edt { myFixture.type 'if' }
948       joinSomething(a1)
949
950       myFixture.type ' '
951
952       joinAutopopup()
953       joinCompletion()
954       myFixture.checkResult(result)
955       assert !lookup
956     }
957
958     for (a1 in 0..actions) {
959       myFixture.configureByText("$a1 if .java", src)
960       myFixture.type 'i'
961       joinSomething(a1)
962
963       edt { myFixture.type 'f ' }
964
965       joinAutopopup()
966       joinCompletion()
967       myFixture.checkResult(result)
968       assert !lookup
969     }
970
971   }
972
973   public void testNonFinishedParameterComma() {
974     myFixture.configureByText("a.java", """
975 class Foo {
976   void foo(int aaa, int aaaaa) { }
977   void bar(int aaa, int aaaaa) { foo(<caret>) }
978 } """)
979     type 'a'
980     type 'a'
981     type ','
982     assert myFixture.editor.document.text.contains('foo(aaa, )')
983   }
984
985   public void testFinishedParameterComma() {
986     myFixture.configureByText("a.java", """ class Foo { void foo(int aaa, int aaaaa) { foo(<caret>) } } """)
987     type 'aaa,'
988     assert myFixture.editor.document.text.contains('foo(aaa,)')
989   }
990
991   public void testNonFinishedVariableEq() {
992     myFixture.configureByText("a.java", """ class Foo { void foo(int aaa, int aaaaa) { <caret> } } """)
993     type 'a='
994     assert myFixture.editor.document.text.contains('aaa = ')
995   }
996
997   public void testFinishedVariableEq() {
998     myFixture.configureByText("a.java", """ class Foo { void foo(int aaa, int aaaaa) { <caret> } } """)
999     type 'aaa='
1000     assert myFixture.editor.document.text.contains('aaa=')
1001   }
1002
1003   public void testCompletionWhenLiveTemplateAreNotSufficient() {
1004     TemplateManagerImpl.setTemplateTesting(getProject(), getTestRootDisposable());
1005     myFixture.configureByText("a.java", """
1006 class Foo {
1007     {
1008         Iterable<String> l1 = null;
1009         Iterable<String> l2 = null;
1010         Object asdf = null;
1011         iter<caret>
1012     }
1013 }
1014 """)
1015     type '\t'
1016     assert myFixture.lookupElementStrings == ['l2', 'l1']
1017     type 'as'
1018     assert lookup
1019     assertContains 'asdf', 'assert'
1020     type '\n.'
1021     assert lookup
1022     assert 'hashCode' in myFixture.lookupElementStrings
1023     assert myFixture.file.text.contains('asdf.')
1024   }
1025
1026   public void testNoWordCompletionAutoPopup() {
1027     myFixture.configureByText "a.java", 'class Bar { void foo() { "f<caret>" }}'
1028     type 'o'
1029     assert !lookup
1030   }
1031
1032   public void testMethodNameRestart() {
1033     myFixture.configureByText "a.java", '''
1034 public class Bar {
1035     private static List<java.io.File> getS<caret>
1036
1037 }
1038 '''
1039     type 'ta'
1040     assert !lookup
1041   }
1042
1043   public void testTargetElementInLookup() {
1044     myFixture.configureByText 'a.java', '''
1045 class Foo {
1046   void x__foo() {}
1047   void bar() {
1048     <caret>
1049   }
1050   void x__goo() {}
1051 }
1052 '''
1053     PsiClass cls = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() {
1054           @Override
1055           public PsiClass compute() {
1056             return ((PsiJavaFile)myFixture.file).getClasses()[0];
1057           }
1058     });
1059
1060     PsiMethod[] methods = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod[]>() {
1061               @Override
1062               public PsiMethod[] compute() {
1063                 return cls.methods;
1064               }
1065         })
1066     def foo = methods[0]
1067     def goo = methods[2]
1068     type('x')
1069     assertContains 'x__foo', 'x__goo'
1070     edt {
1071       assert foo == TargetElementUtil.instance.findTargetElement(myFixture.editor, TargetElementUtil.LOOKUP_ITEM_ACCEPTED)
1072       myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_DOWN)
1073       assert goo == TargetElementUtil.instance.findTargetElement(myFixture.editor, TargetElementUtil.LOOKUP_ITEM_ACCEPTED)
1074     }
1075
1076     type('_')
1077     myFixture.assertPreferredCompletionItems 1, 'x__foo', 'x__goo'
1078     edt {
1079       assert goo == TargetElementUtil.instance.findTargetElement(myFixture.editor, TargetElementUtil.LOOKUP_ITEM_ACCEPTED)
1080       myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_UP)
1081       assert foo == TargetElementUtil.instance.findTargetElement(myFixture.editor, TargetElementUtil.LOOKUP_ITEM_ACCEPTED)
1082     }
1083   }
1084
1085   public void testExplicitAutocompletionAfterAutoPopup() {
1086     myFixture.configureByText 'a.java', 'class Foo <caret>'
1087     type 'ext'
1088
1089     CompletionAutoPopupHandler.ourTestingAutopopup = false
1090     edt {
1091       myFixture.completeBasic()
1092     }
1093     assert !lookup : myFixture.lookupElementStrings
1094     myFixture.checkResult 'class Foo extends <caret>'
1095   }
1096
1097   public void testExplicitMultipleVariantCompletionAfterAutoPopup() {
1098     myFixture.configureByText 'a.java', 'class Foo {<caret>}'
1099     type 'pr'
1100
1101     CompletionAutoPopupHandler.ourTestingAutopopup = false
1102     edt {
1103       myFixture.completeBasic()
1104     }
1105     myFixture.checkResult 'class Foo {pr<caret>}'
1106
1107     ApplicationManager.getApplication().runReadAction(new Runnable() {
1108       @Override
1109       void run() {
1110         getLookup().items.each {
1111           getLookup().list.cellRenderer.getListCellRendererComponent(getLookup().list, it, 0, false, false)
1112         }
1113       }
1114     });
1115     assert myFixture.lookupElementStrings.containsAll(['private', 'protected'])
1116   }
1117
1118   public void testExactMatchesFirst() {
1119     myFixture.configureByText("a.java", """
1120 public class UTest {
1121     void nextWord() {}
1122
1123     void foo() {
1124         n<caret>
1125     }
1126 }""")
1127     type 'ew'
1128     assert myFixture.lookupElementStrings == ['new', 'nextWord']
1129   }
1130
1131   public void testExactMatchesTemplateFirst() {
1132     LiveTemplateCompletionContributor.setShowTemplatesInTests(true, getTestRootDisposable())
1133     myFixture.configureByText("a.java", """
1134 public class Test {
1135     void itar() {}
1136
1137     void foo() {
1138         ita<caret>
1139     }
1140 }""")
1141     type 'r'
1142     assert myFixture.lookupElementStrings == ['itar', 'itar']
1143     assert myFixture.lookup.currentItem instanceof LiveTemplateLookupElement
1144   }
1145
1146   public void testUpdatePrefixMatchingOnTyping() {
1147     myFixture.addClass("class CertificateEncodingException {}")
1148     myFixture.addClass("class CertificateException {}")
1149     myFixture.configureByText 'a.java', 'class Foo {<caret>}'
1150     type 'CertificateExce'
1151     assert myFixture.lookupElementStrings == ['CertificateException', 'CertificateEncodingException']
1152   }
1153
1154   public void testNoClassesInUnqualifiedImports() {
1155     myFixture.addClass("package xxxxx; public class Xxxxxxxxx {}")
1156     myFixture.configureByText 'a.java', 'package foo; import <caret>'
1157     type 'xxx'
1158     assert !lookup
1159   }
1160
1161   public void testPopupAfterDotAfterPackage() {
1162     myFixture.configureByText 'a.java', '<caret>'
1163     type 'import jav'
1164     assert lookup
1165     type '.'
1166     assert lookup
1167   }
1168
1169   public void testSamePrefixIgnoreCase() {
1170     myFixture.addClass("package xxxxx; public class SYSTEM_EXCEPTION {}")
1171     myFixture.configureByText "a.java", "import xxxxx.*; class Foo { S<caret> }"
1172     type 'Ystem'
1173     myFixture.assertPreferredCompletionItems 1, 'System', 'SYSTEM_EXCEPTION'
1174   }
1175
1176   public void testSamePrefixIgnoreCase2() {
1177     myFixture.addClass("package xxxxx; public class SYSTEM_EXCEPTION {}")
1178     myFixture.addClass("package xxxxx; public class SYstem {}")
1179     myFixture.configureByText "a.java", "import xxxxx.*; class Foo { S<caret> }"
1180     type 'Ystem'
1181     myFixture.assertPreferredCompletionItems 0, 'SYstem', 'System', 'SYSTEM_EXCEPTION'
1182   }
1183
1184   private FileEditor openEditorForUndo() {
1185     FileEditor editor;
1186     edt { editor = FileEditorManager.getInstance(project).openFile(myFixture.file.virtualFile, false)[0] }
1187     def manager = (UndoManagerImpl) UndoManager.getInstance(project)
1188     def old = manager.editorProvider
1189     manager.editorProvider = new CurrentEditorProvider() {
1190       @Override
1191       public FileEditor getCurrentEditor() {
1192         return editor;
1193       }
1194     };
1195     disposeOnTearDown ({ manager.editorProvider = old } as Disposable)
1196     return editor
1197   }
1198
1199   public void testAutopopupTypingUndo() {
1200     myFixture.configureByText "a.java", "class Foo {{ <caret> }}"
1201     def editor = openEditorForUndo();
1202     type 'aioobeeee'
1203     edt { UndoManager.getInstance(project).undo(editor) }
1204     assert !myFixture.editor.document.text.contains('aioo')
1205   }
1206
1207   public void testNoLiveTemplatesAfterDot() {
1208     myFixture.configureByText "a.java", "class Foo {{ Iterable t; t.<caret> }}"
1209     type 'iter'
1210     assert myFixture.lookupElementStrings == ['iterator']
1211   }
1212
1213   public void testTypingFirstVarargDot() {
1214     myFixture.configureByText "a.java", "class Foo { void foo(Foo<caret>[] a) { }; class Bar {}}"
1215     type '.'
1216     assert !lookup
1217   }
1218
1219   public void testBlockSelection() {
1220     doTestBlockSelection """
1221 class Foo {{
1222   <caret>tx;
1223   tx;
1224 }}""", '\n', '''
1225 class Foo {{
1226   toString()x;
1227   toString()<caret>x;
1228 }}'''
1229   }
1230
1231   public void testBlockSelectionTab() {
1232     doTestBlockSelection """
1233 class Foo {{
1234   <caret>tx;
1235   tx;
1236 }}""", '\t', '''
1237 class Foo {{
1238   toString();
1239   toString()<caret>;
1240 }}'''
1241   }
1242
1243   public void testBlockSelectionBackspace() {
1244     doTestBlockSelection """
1245 class Foo {{
1246   <caret>t;
1247   t;
1248 }}""", '\b\t', '''
1249 class Foo {{
1250   toString();
1251   toString()<caret>;
1252 }}'''
1253   }
1254
1255   public void testMulticaret() {
1256     doTestMulticaret """
1257 class Foo {{
1258   <selection>t<caret></selection>x;
1259   <selection>t<caret></selection>x;
1260 }}""", '\n', '''
1261 class Foo {{
1262   toString()<caret>x;
1263   toString()<caret>x;
1264 }}'''
1265   }
1266
1267   public void testMulticaretTab() {
1268     doTestMulticaret """
1269 class Foo {{
1270   <selection>t<caret></selection>x;
1271   <selection>t<caret></selection>x;
1272 }}""", '\t', '''
1273 class Foo {{
1274   toString()<caret>;
1275   toString()<caret>;
1276 }}'''
1277   }
1278
1279   public void testMulticaretBackspace() {
1280     doTestMulticaret """
1281 class Foo {{
1282   <selection>t<caret></selection>;
1283   <selection>t<caret></selection>;
1284 }}""", '\b\t', '''
1285 class Foo {{
1286   toString()<caret>;
1287   toString()<caret>;
1288 }}'''
1289   }
1290
1291   private doTestMulticaret(final String textBefore, final String toType, final String textAfter) {
1292     myFixture.configureByText "a.java", textBefore
1293     type 'toStr'
1294     assert lookup
1295     type toType
1296     myFixture.checkResult textAfter
1297   }
1298
1299   private doTestBlockSelection(final String textBefore, final String toType, final String textAfter) {
1300     EditorTestUtil.disableMultipleCarets()
1301     try {
1302       myFixture.configureByText "a.java", textBefore
1303       edt {
1304         def caret = myFixture.editor.offsetToLogicalPosition(myFixture.editor.caretModel.offset)
1305         myFixture.editor.selectionModel.setBlockSelection(caret, new LogicalPosition(caret.line + 1, caret.column + 1))
1306       }
1307       type 'toStr'
1308       assert lookup
1309       type toType
1310       myFixture.checkResult textAfter
1311       def start = myFixture.editor.selectionModel.blockStart
1312       def end = myFixture.editor.selectionModel.blockEnd
1313       assert start.line == end.line - 1
1314       assert start.column == end.column
1315       assert end == myFixture.editor.caretModel.logicalPosition
1316     }
1317     finally {
1318       EditorTestUtil.enableMultipleCarets()
1319     }
1320   }
1321
1322   public void "test two non-imported classes when space selects first autopopup item"() {
1323     myFixture.addClass("package foo; public class Abcdefg {}")
1324     myFixture.configureByText 'a.java', 'class Foo extends <caret>'
1325     type 'Abcde '
1326     myFixture.checkResult 'import foo.Abcdefg;\n\nclass Foo extends Abcdefg <caret>'
1327   }
1328
1329   public void "test two non-imported classes when space does not select first autopopup item"() {
1330     CodeInsightSettings.instance.SELECT_AUTOPOPUP_SUGGESTIONS_BY_CHARS = false
1331
1332     myFixture.addClass("package foo; public class Abcdefg {}")
1333     myFixture.addClass("package bar; public class Abcdefg {}")
1334     myFixture.configureByText 'a.java', 'class Foo extends <caret>'
1335     type 'Abcde'
1336     assert lookup.items.size() == 2
1337     edt { myFixture.performEditorAction(IdeActions.ACTION_EDITOR_MOVE_CARET_DOWN) }
1338     type ' '
1339     myFixture.checkResult '''import foo.Abcdefg;
1340
1341 class Foo extends Abcdefg <caret>'''
1342   }
1343
1344   public void testTwoNonImportedClasses_() {
1345     myFixture.addClass("package foo; public class Abcdefg {}")
1346     myFixture.addClass("package bar; public class Abcdefg {}")
1347     myFixture.configureByText 'a.java', 'class Foo extends <caret>'
1348     type 'Abcde'
1349     assert lookup.items.size() == 2
1350   }
1351
1352   public void testClassNameInProperties() {
1353     myFixture.addClass("package java.langa; public class Abcdefg {}")
1354     myFixture.configureByText 'a.properties', 'key.11=java<caret>'
1355     type '.'
1356     assert lookup
1357     type 'lang'
1358     assert myFixture.lookupElementStrings.size() >= 2
1359     type '.'
1360     assert lookup
1361     edt { myFixture.editor.caretModel.moveToOffset(myFixture.editor.document.text.indexOf('lang')) }
1362     assert !lookup
1363     type 'i'
1364     assert 'io' in myFixture.lookupElementStrings
1365   }
1366
1367   public void testEnteringLabel() {
1368     myFixture.configureByText 'a.java', '''class Foo {{
1369   <caret>
1370 }}
1371 '''
1372     type 'FIS:'
1373     assert myFixture.file.text.contains('FIS:')
1374   }
1375
1376   public void testSoutvTemplate() {
1377     TemplateManagerImpl.setTemplateTesting(getProject(), getTestRootDisposable());
1378     myFixture.configureByText 'a.java', 'class Foo {{ <caret> }}'
1379     type 'soutv\tgetcl.'
1380     myFixture.checkResult '''\
1381 class Foo {{
1382     System.out.println("getClass(). = " + getClass().<caret>);
1383 }}'''
1384   }
1385
1386   public void testReturnLParen() {
1387     myFixture.configureByText 'a.java', 'class Foo { int foo() { <caret> }}'
1388     type 're('
1389     myFixture.checkResult 'class Foo { int foo() { re(<caret>) }}'
1390   }
1391
1392   public void testAmbiguousClassQualifier() {
1393     myFixture.addClass("package foo; public class Util<T> { public static void foo() {}; public static final int CONSTANT = 2; }")
1394     myFixture.addClass("package bar; public class Util { public static void bar() {} }")
1395     myFixture.configureByText 'a.java', 'class Foo {{ Util<caret> }}'
1396     type '.'
1397     assert myFixture.lookupElementStrings == ['Util.bar', 'Util.CONSTANT', 'Util.foo']
1398
1399     def p = ApplicationManager.application.runReadAction ({ LookupElementPresentation.renderElement(myFixture.lookupElements[1]) } as Computable)
1400     assert p.itemText == 'Util.CONSTANT'
1401     assert p.tailText == ' (foo)'
1402     assert p.typeText == 'int'
1403
1404     type 'fo\n'
1405     myFixture.checkResult '''import foo.Util;
1406
1407 class Foo {{
1408     Util.foo();<caret> }}'''
1409   }
1410
1411   public void testPackageQualifier() {
1412     CodeInsightSettings.instance.SELECT_AUTOPOPUP_SUGGESTIONS_BY_CHARS = false
1413
1414     myFixture.addClass("package com.too; public class Util {}")
1415     myFixture.configureByText 'a.java', 'class Foo { void foo(Object command) { <caret> }}'
1416     type 'com.t'
1417     assert myFixture.lookupElementStrings.containsAll(['too', 'command.toString'])
1418   }
1419
1420   public void testUnfinishedString() {
1421     myFixture.configureByText 'a.java', '''
1422 // Date
1423 class Foo {
1424   String s = "<caret>
1425   String s2 = s;
1426 }
1427 '''
1428     type 'D'
1429     assert !lookup
1430   }
1431
1432   public void testVarargParenthesis() {
1433     myFixture.configureByText 'a.java', '''
1434 class Foo {
1435   void foo(File... files) { }
1436   { foo(new <caret>) }
1437 }
1438 '''
1439     type 'File('
1440     assert myFixture.editor.document.text.contains('new File()')
1441   }
1442
1443   public void "test inaccessible class in another package shouldn't prevent choosing by space"() {
1444     myFixture.addClass("package foo; class b {}")
1445     myFixture.configureByText 'a.java', 'class Foo {{ <caret> }}'
1446     type 'b'
1447     assert lookup?.currentItem?.lookupString == 'boolean'
1448     type ' '
1449     myFixture.checkResult 'class Foo {{ boolean <caret> }}'
1450   }
1451
1452   @Override
1453   protected void setUp() {
1454     super.setUp()
1455     CodeInsightSettings.instance.SELECT_AUTOPOPUP_SUGGESTIONS_BY_CHARS = true
1456   }
1457
1458   @Override
1459   protected void tearDown() {
1460     CodeInsightSettings.instance.SELECT_AUTOPOPUP_SUGGESTIONS_BY_CHARS = false
1461     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.FIRST_LETTER
1462     UISettings.getInstance().SORT_LOOKUP_ELEMENTS_LEXICOGRAPHICALLY = false
1463
1464     super.tearDown()
1465   }
1466
1467   public void testBackspaceShouldShowPreviousVariants() {
1468     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
1469     myFixture.configureByText 'a.java', 'class Foo{ void foo(int itera, int itex) { it<caret> }}'
1470     type 'e'
1471     myFixture.assertPreferredCompletionItems 0, 'itera', 'itex'
1472     type 'r'
1473     myFixture.assertPreferredCompletionItems 0, 'iter', 'itera'
1474     type '\b'
1475     myFixture.assertPreferredCompletionItems 0, 'itera', 'itex'
1476   }
1477
1478   public void testBackspaceUntilDot() {
1479     myFixture.configureByText 'a.java', 'class Foo{ void foo(String s) { s<caret> }}'
1480     type '.sub'
1481     assert myFixture.lookupElementStrings
1482     type '\b\b\b'
1483     assert lookup
1484     type '\b'
1485     assert !lookup
1486   }
1487
1488   public void testReplaceTypedPrefixPart() {
1489     ((StatisticsManagerImpl)StatisticsManager.getInstance()).enableStatistics(getTestRootDisposable());
1490     myFixture.configureByText 'a.java', 'class Foo{ { <caret> }}'
1491     for (i in 0..StatisticsManager.OBLIVION_THRESHOLD) {
1492       type 'System.out.printl\n\n'
1493     }
1494     type 'System.out.pr'
1495     assert lookup.currentItem.lookupString == 'println'
1496     type '\n2'
1497     assert myFixture.editor.document.text.contains('.println();2')
1498   }
1499
1500   public void testQuickBackspaceEnter() {
1501     myFixture.configureByText 'a.java', '<caret>'
1502     type 'cl'
1503     assert myFixture.lookupElementStrings == ['class']
1504     myFixture.type('\b\n')
1505     myFixture.checkResult('class <caret>')
1506   }
1507
1508   void joinCompletion() {
1509     myTester.joinCompletion()
1510   }
1511
1512   protected def joinCommit(Closure c1={}) {
1513     myTester.joinCommit(c1)
1514   }
1515
1516   protected void joinAutopopup() {
1517     myTester.joinAutopopup()
1518   }
1519
1520   public void "test new primitive array in Object variable"() {
1521     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
1522     myFixture.configureByText 'a.java', '''
1523 class Foo {
1524   void foo() {
1525     Object o = new <caret>
1526   }
1527 }
1528 '''
1529     type 'int'
1530     myFixture.assertPreferredCompletionItems 0, 'int', 'Integer'
1531     assert ((PsiTypeLookupItem) myFixture.lookupElements[0]).bracketsCount == 1
1532     type '['
1533     myFixture.checkResult '''
1534 class Foo {
1535   void foo() {
1536     Object o = new int[<caret>]
1537   }
1538 }
1539 '''
1540   }
1541
1542   public void "test no focus in variable name"() {
1543     myFixture.configureByText 'a.java', '''
1544 class FooBar {
1545   void foo() {
1546     FooBar <caret>
1547   }
1548 }
1549 '''
1550     type 'f'
1551     assert lookup
1552     assert !lookup.focused
1553     type '\n'
1554     assert !myFixture.editor.document.text.contains('fooBar')
1555   }
1556
1557   public void "test middle matching and overwrite"() {
1558     myFixture.configureByText 'a.java', '''
1559 class ListConfigKey {
1560   void foo() {
1561     <caret>
1562   }
1563 }
1564 '''
1565     type 'CK\t'
1566     myFixture.checkResult '''
1567 class ListConfigKey {
1568   void foo() {
1569     ListConfigKey<caret>
1570   }
1571 }
1572 '''
1573
1574   }
1575
1576   public void testPreselectMostRelevantInTheMiddleAlpha() {
1577     UISettings.getInstance().SORT_LOOKUP_ELEMENTS_LEXICOGRAPHICALLY = true;
1578     CodeInsightSettings.instance.SELECT_AUTOPOPUP_SUGGESTIONS_BY_CHARS = false
1579
1580     myFixture.configureByText 'a.java', '''
1581 class Foo {
1582   void setText() {}
1583   void setHorizontalText() {}
1584   void foo() {
1585     <caret>
1586   }
1587
1588 }
1589 '''
1590     type 'sette'
1591     myFixture.assertPreferredCompletionItems 1, 'setHorizontalText', 'setText'
1592     edt { myFixture.performEditorAction IdeActions.ACTION_EDITOR_MOVE_CARET_UP }
1593     myFixture.assertPreferredCompletionItems 0, 'setHorizontalText', 'setText'
1594   }
1595
1596   public void "test pressing enter while autopopup is calculating variants should cancel autopopup"() {
1597     registerContributor(LongContributor, LoadingOrder.FIRST)
1598     myFixture.configureByText "a.java", "class Foo {{ <caret> }}"
1599     myFixture.type('a')
1600     joinAutopopup()
1601     type('\n')
1602     assert !lookup
1603   }
1604
1605   public void "test pressing enter and a letter while autopopup is calculating variants should restart autopopup"() {
1606     registerContributor(LongContributor, LoadingOrder.FIRST)
1607     myFixture.configureByText "a.java", "class Foo {{ <caret> }}"
1608     myFixture.type('a')
1609     joinAutopopup()
1610     myFixture.type('\na')
1611     joinCompletion()
1612     assert lookup
1613   }
1614
1615   public void "test a random write action shouldn't cancel autopopup"() {
1616     registerContributor(LongContributor, LoadingOrder.FIRST)
1617     myFixture.configureByText "a.java", "class Foo {{ <caret> }}"
1618     myFixture.type('a')
1619     joinAutopopup()
1620     edt { ApplicationManager.application.runWriteAction {} }
1621     joinCompletion()
1622     assert lookup
1623   }
1624
1625   public void "test typing during restart commit document"() {
1626     def longText = "\nfoo(); bar();" * 100
1627     myFixture.configureByText "a.java", "class Foo { void foo(int ab, int abde) { <caret>; $longText }}"
1628     myFixture.type('a')
1629     joinAutopopup()
1630     myFixture.type('b')
1631     myTester.joinCommit()
1632     myFixture.type('c')
1633     joinCompletion()
1634     assert !lookup
1635   }
1636
1637   public void "test no name autopopup in live template"() {
1638     TemplateManagerImpl.setTemplateTesting(getProject(), getTestRootDisposable());
1639     myFixture.configureByText 'a.java', '''class F {
1640   String nameContainingIdentifier;
1641 <caret>
1642 }'''
1643
1644     final TemplateManager manager = TemplateManager.getInstance(getProject());
1645     final Template template = manager.createTemplate("m", "user", 'void foo(String $V1$) {}');
1646     template.addVariable("V1", "", '"s"', true);
1647
1648     edt {
1649       CommandProcessor.instance.executeCommand project, {manager.startTemplate(myFixture.editor, template)}, null, null
1650     }
1651
1652     type('name')
1653     assert !myFixture.lookupElementStrings
1654     assert !lookup
1655   }
1656
1657   public void "test template prefix is better than middle matches"() {
1658     myFixture.configureByText "a.java", """
1659 class Cls {
1660   void foo() {
1661     <caret>
1662   }
1663   void mySout() {}
1664 }
1665 """ 
1666     type('sout')
1667     myFixture.assertPreferredCompletionItems 0, 'sout', 'mySout'
1668   }
1669
1670   public void "test single overriding getter"() {
1671     myFixture.configureByText "a.java", """
1672 public class Foo {
1673     public int getField() {}
1674 }
1675
1676 class X extends Foo {
1677     int field;
1678
1679     <caret>
1680 }
1681 """
1682     type 'getf'
1683     assert myFixture.lookupElementStrings == ['public int getField']
1684   }
1685
1686   public void "test live template quick doc"() {
1687     myFixture.configureByText "a.java", """
1688 class Cls {
1689   void foo() {
1690     <caret>
1691   }
1692   void mySout() {}
1693 }
1694 """ 
1695     type('sout')
1696     assert lookup
1697     assert 'sout' in myFixture.lookupElementStrings
1698
1699     def docProvider = new LiveTemplateDocumentationProvider()
1700     def docElement = docProvider.getDocumentationElementForLookupItem(myFixture.psiManager, lookup.currentItem, null)
1701     assert docElement.presentation.presentableText == 'sout'
1702     assert docProvider.generateDoc(docElement, docElement).contains('System.out')
1703   }
1704
1705   public void "test finishing class reference property value completion with dot opens autopopup"() {
1706     myFixture.configureByText "a.properties", "myprop=ja<caret>"
1707     type 'v'
1708     myFixture.assertPreferredCompletionItems 0, 'java'
1709     lookup.focusDegree = LookupImpl.FocusDegree.FOCUSED
1710     type '.'
1711     myFixture.checkResult 'myprop=java.<caret>'
1712     assert lookup
1713   }
1714
1715   public void "test live template without description"() {
1716     final TemplateManager manager = TemplateManager.getInstance(getProject());
1717     final Template template = manager.createTemplate("tpl", "user", null);
1718     final JavaCodeContextType contextType =
1719       ContainerUtil.findInstance(TemplateContextType.EP_NAME.getExtensions(), JavaCodeContextType.Statement);
1720     ((TemplateImpl)template).getTemplateContext().setEnabled(contextType, true);
1721     LiveTemplateTest.addTemplate(template, testRootDisposable)
1722     
1723     myFixture.configureByText 'a.java', '''
1724 class Foo {
1725  int tplMn;
1726  
1727  { <caret> }
1728 }
1729 '''
1730     type 'tpl'
1731     myFixture.assertPreferredCompletionItems 0, 'tpl', 'tplMn'
1732
1733     LookupElementPresentation p = LookupElementPresentation.renderElement(myFixture.lookupElements[0])
1734     assert p.itemText == 'tpl'
1735     assert !p.tailText
1736     def tabKeyPresentation = KeyEvent.getKeyText(TemplateSettings.TAB_CHAR as int)
1737     assert p.typeText == "  [$tabKeyPresentation] "
1738   }
1739
1740   public void "test autopopup after package completion"() {
1741     myFixture.addClass("package foo.bar.goo; class Foo {}")
1742     myFixture.configureByText "a.java", "class Foo { { foo.b<caret> } }"
1743     myFixture.completeBasic()
1744     assert myFixture.editor.document.text.contains('foo.bar. ')
1745     joinAutopopup()
1746     joinCompletion()
1747     assert lookup
1748     assert myFixture.lookupElementStrings == ['goo']
1749   }
1750
1751   public void "test in column selection mode"() {
1752     myFixture.configureByText "a.java", """
1753 class Foo {{
1754   <caret>
1755 }}"""
1756     edt { ((EditorEx)myFixture.editor).setColumnMode(true) }
1757     type 'toStr'
1758     assert lookup
1759   }
1760   
1761   public void "test show popup with single live template if show_live_tempate_in_completion option is enabled"() {
1762     LiveTemplateCompletionContributor.setShowTemplatesInTests(false, getTestRootDisposable())
1763     myFixture.configureByText "a.java", """
1764 class Foo {{
1765 ita<caret>
1766 """
1767     type 'r'
1768     assert lookup == null
1769     
1770     LiveTemplateCompletionContributor.setShowTemplatesInTests(true, getTestRootDisposable())
1771     type '\br'
1772     assert lookup
1773     assert myFixture.lookupElementStrings == ['itar']
1774   }
1775 }