ad48594360a60489e42b8e88c32d5efc411d8c71
[idea/community.git] / python / testSrc / com / jetbrains / python / PythonCompletionTest.java
1 /*
2  * Copyright 2000-2013 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.jetbrains.python;
17
18 import com.google.common.collect.Lists;
19 import com.intellij.codeInsight.completion.CompletionType;
20 import com.intellij.codeInsight.completion.impl.CamelHumpMatcher;
21 import com.intellij.codeInsight.lookup.AutoCompletionPolicy;
22 import com.intellij.codeInsight.lookup.Lookup;
23 import com.intellij.codeInsight.lookup.LookupElement;
24 import com.intellij.codeInsight.lookup.LookupElementBuilder;
25 import com.intellij.testFramework.PsiTestUtil;
26 import com.jetbrains.python.documentation.PyDocumentationSettings;
27 import com.jetbrains.python.documentation.docstrings.DocStringFormat;
28 import com.jetbrains.python.fixtures.PyTestCase;
29 import com.jetbrains.python.psi.LanguageLevel;
30 import org.jetbrains.annotations.Nullable;
31
32 import java.util.Arrays;
33 import java.util.HashSet;
34 import java.util.List;
35
36 public class PythonCompletionTest extends PyTestCase {
37
38   private void doTest() {
39     CamelHumpMatcher.forceStartMatching(getTestRootDisposable());
40     final String testName = getTestName(true);
41     myFixture.configureByFile(testName + ".py");
42     myFixture.completeBasic();
43     myFixture.checkResultByFile(testName + ".after.py");
44   }
45
46   private void doMultiFileTest() {
47     myFixture.copyDirectoryToProject(getTestName(true), "");
48     myFixture.configureByFile("a.py");
49     myFixture.completeBasic();
50     myFixture.checkResultByFile(getTestName(true) + "/a.after.py");
51   }
52
53   private List<String> doTestByText(String text) {
54     myFixture.configureByText(PythonFileType.INSTANCE, text);
55     myFixture.completeBasic();
56     return myFixture.getLookupElementStrings();
57   }
58
59   @Nullable
60   private List<String> doTestByFile() {
61     myFixture.configureByFile(getTestName(true) + ".py");
62     myFixture.completeBasic();
63     return myFixture.getLookupElementStrings();
64   }
65
66   @Nullable
67   private List<String> doTestSmartByFile() {
68     myFixture.configureByFile(getTestName(true) + ".py");
69     myFixture.complete(CompletionType.SMART);
70     return myFixture.getLookupElementStrings();
71   }
72
73   public void testLocalVar() {
74     doTest();
75   }
76
77   public void testSelfMethod() {
78     doTest();
79   }
80
81   public void testSelfField() {
82     doTest();
83   }
84
85   public void testFuncParams() {
86     doTest();
87   }
88
89   public void testFuncParamsStar() {
90     doTest();
91   }
92
93   public void testInitParams() {
94     doTest();
95   }
96
97   public void testSuperInitParams() {      // PY-505
98     doTest();
99   }
100
101   public void testSuperInitKwParams() {      // PY-778
102     doTest();
103   }
104
105   public void testPredefinedMethodName() {
106     doTest();
107   }
108
109   public void testPredefinedMethodNot() {
110     doTest();
111   }
112
113   public void testClassPrivate() {
114     doTest();
115   }
116
117   public void testClassPrivateNotInherited() {
118     doTest();
119   }
120
121   public void testClassPrivateNotPublic() {
122     doTest();
123   }
124
125   public void testTwoUnderscores() {
126     doTest();
127   }
128
129   public void testOneUnderscore() {
130     final String testName = getTestName(true);
131     myFixture.configureByFile(testName + ".py");
132     myFixture.completeBasic();
133     myFixture.type('\n');
134     myFixture.checkResultByFile(testName + ".after.py");
135   }
136
137   public void testKwParamsInCodeUsage() { //PY-1002
138     doTest();
139   }
140
141   public void testKwParamsInCodeGetUsage() { //PY-1002
142     doTest();
143   }
144
145   public void testSuperInitKwParamsNotOnlySelfAndKwArgs() { //PY-1050
146     doTest();
147   }
148
149   public void testSuperInitKwParamsNoCompletion() {
150     doTest();
151   }
152
153   public void testIsInstance() {
154     doTest();
155   }
156
157   public void testIsInstanceAssert() {
158     doTest();
159   }
160
161   public void testIsInstanceTuple() {
162     doTest();
163   }
164
165   public void testPropertyParens() {  // PY-1037
166     doTest();
167   }
168
169   public void testClassNameFromVarName() {
170     doTest();
171   }
172
173   public void testClassNameFromVarNameChained() {  // PY-5629
174     doTest();
175   }
176
177   public void testPropertyType() {
178     doTest();
179   }
180
181   public void testSeenMembers() {  // PY-1181
182     final String testName = getTestName(true);
183     myFixture.configureByFile(testName + ".py");
184     final LookupElement[] elements = myFixture.completeBasic();
185     assertNotNull(elements);
186     assertEquals(1, elements.length);
187     assertEquals("children", elements[0].getLookupString());
188   }
189
190   public void testImportModule() {
191     final String testName = getTestName(true);
192     myFixture.configureByFiles(testName + ".py", "someModule.py");
193     myFixture.completeBasic();
194     myFixture.checkResultByFile(testName + ".after.py");
195   }
196
197   public void testPy255() {
198     final String dirName = getTestName(true);
199     myFixture.copyDirectoryToProject(dirName, "");
200     myFixture.configureByFiles("moduleClass.py");
201     myFixture.completeBasic();
202     myFixture.checkResultByFile(dirName + "/moduleClass.after.py");
203   }
204
205   public void testPy874() {
206     final String testName = "py874";
207     myFixture.configureByFile(testName + ".py");
208     myFixture.copyDirectoryToProject("root", "root");
209     myFixture.completeBasic();
210     myFixture.checkResultByFile(testName + ".after.py");
211   }
212
213   public void testClassMethod() {  // PY-833
214     doTest();
215   }
216
217   public void testStarImport() {
218     myFixture.configureByFiles("starImport/starImport.py", "starImport/importSource.py");
219     myFixture.completeBasic();
220     assertSameElements(myFixture.getLookupElementStrings(), Arrays.asList("my_foo", "my_bar"));
221   }
222
223   public void testSlots() {  // PY-1211
224     doTest();
225   }
226
227   public void testReturnType() {
228     doTest();
229   }
230
231   public void testWithType() { // PY-4198
232     setLanguageLevel(LanguageLevel.PYTHON26);
233     doTest();
234   }
235
236   public void testChainedCall() {  // PY-1565
237     doTest();
238   }
239
240   public void testFromImportBinary() {
241     myFixture.copyFileToProject("root/binary_mod.pyd");
242     myFixture.copyFileToProject("root/binary_mod.so");
243     myFixture.configureByFiles("fromImportBinary.py", "root/__init__.py");
244     myFixture.completeBasic();
245     myFixture.checkResultByFile("fromImportBinary.after.py");
246   }
247
248   public void testNonExistingProperty() {  // PY-1748
249     doTest();
250   }
251
252   public void testImportItself() {  // PY-1895
253     myFixture.copyDirectoryToProject("importItself/package1", "package1");
254     myFixture.configureFromTempProjectFile("package1/submodule1.py");
255     myFixture.completeBasic();
256     myFixture.checkResultByFile("importItself.after.py");
257   }
258
259   public void testImportedFile() { // PY-1955
260     myFixture.copyDirectoryToProject("root", "root");
261     myFixture.configureByFile("importedFile.py");
262     myFixture.completeBasic();
263     myFixture.checkResultByFile("importedFile.after.py");
264   }
265
266   public void testImportedModule() {  // PY-1956
267     myFixture.copyDirectoryToProject("root", "root");
268     myFixture.configureByFile("importedModule.py");
269     myFixture.completeBasic();
270     myFixture.checkResultByFile("importedModule.after.py");
271   }
272
273   public void testDictKeys() {  // PY-2245
274     doTest();
275   }
276
277   public void testDictKeys2() { //PY-4181
278     doTest();
279   }
280
281   public void testDictKeys3() { //PY-5546
282     doTest();
283   }
284
285   public void testNoParensForDecorator() {  // PY-2210
286     doTest();
287   }
288
289   public void testSuperMethod() {  // PY-170
290     doTest();
291   }
292
293   public void testLocalVarInDictKey() {  // PY-2558
294     doTest();
295   }
296
297   public void testDictKeyPrefix() {
298     doTest();
299   }
300
301   public void testDictKeyPrefix2() {      //PY-3683
302     doTest();
303   }
304
305   public void testNoIdentifiersInImport() {
306     doTest();
307   }
308
309   public void testSuperClassAttributes() {
310     doTest();
311   }
312
313   public void testSuperClassAttributesNoCompletionInFunc() {
314     doTest();
315   }
316
317   public void testRelativeImport() {  // PY-2816
318     myFixture.copyDirectoryToProject("relativeImport", "relativeImport");
319     myFixture.configureByFile("relativeImport/pkg/main.py");
320     myFixture.completeBasic();
321     myFixture.checkResultByFile("relativeImport/pkg/main.after.py");
322   }
323
324   public void testRelativeImportNameFromInitPy() {  // PY-2816
325     myFixture.copyDirectoryToProject("relativeImport", "relativeImport");
326     myFixture.configureByFile("relativeImport/pkg/name.py");
327     myFixture.completeBasic();
328     myFixture.checkResultByFile("relativeImport/pkg/name.after.py");
329   }
330
331   public void testImport() {
332     doTest();
333   }
334
335   public void testDuplicateImportKeyword() {  // PY-3034
336     doMultiFileTest();
337   }
338
339   public void testImportInMiddleOfHierarchy() {  // PY-3016
340     doMultiFileTest();
341   }
342
343   public void testVeryPrivate() {  // PY-3246
344     doTest();
345   }
346
347   public void testReexportModules() {  // PY-2385
348     doMultiFileTest();
349   }
350
351   public void testModuleDotPy() {  // PY-5813
352     doMultiFileTest();
353   }
354
355   public void testHasAttr() {  // PY-4423
356     doTest();
357   }
358
359   public void testEpydocParamTag() {
360     final PyDocumentationSettings settings = PyDocumentationSettings.getInstance(myFixture.getModule());
361     settings.setFormat(DocStringFormat.EPYTEXT);
362     try {
363       doTest();
364     }
365     finally {
366       settings.setFormat(DocStringFormat.PLAIN);
367     }
368   }
369
370   public void testEpydocTags() {
371     final PyDocumentationSettings settings = PyDocumentationSettings.getInstance(myFixture.getModule());
372     settings.setFormat(DocStringFormat.EPYTEXT);
373     try {
374       myFixture.configureByFile("epydocTags.py");
375       myFixture.completeBasic();
376       final List<String> lookupElementStrings = myFixture.getLookupElementStrings();
377       assertNotNull(lookupElementStrings);
378       assertTrue(lookupElementStrings.contains("@param"));
379     }
380     finally {
381       settings.setFormat(DocStringFormat.PLAIN);
382     }
383   }
384
385   public void testEpydocTagsMiddle() {
386     final PyDocumentationSettings settings = PyDocumentationSettings.getInstance(myFixture.getModule());
387     settings.setFormat(DocStringFormat.EPYTEXT);
388     try {
389       myFixture.configureByFile("epydocTagsMiddle.py");
390       myFixture.completeBasic();
391       myFixture.checkResultByFile("epydocTagsMiddle.after.py");
392     }
393     finally {
394       settings.setFormat(DocStringFormat.PLAIN);
395     }
396   }
397
398   public void testIdentifiersInPlainDocstring() {
399     final PyDocumentationSettings settings = PyDocumentationSettings.getInstance(myFixture.getModule());
400     settings.setFormat(DocStringFormat.PLAIN);
401     myFixture.configureByFile("identifiersInPlainDocstring.py");
402     final LookupElement[] elements = myFixture.completeBasic();
403     assertNotNull(elements);
404     assertContainsElements(Lists.newArrayList(elements),
405                            LookupElementBuilder.create("bar").withAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE));
406   }
407
408   // PY-16877
409   public void testSectionNamesInGoogleDocstring() {
410     runWithDocStringFormat(DocStringFormat.GOOGLE, new Runnable() {
411       public void run() {
412         final List<String> variants = doTestByFile();
413         assertNotNull(variants);
414         assertContainsElements(variants, "Args", "Parameters", "Keyword arguments", "Returns");
415       }
416     });
417   }
418
419   // PY-16991
420   public void testSecondSectionNameInGoogleDocstring() {
421     runWithDocStringFormat(DocStringFormat.GOOGLE, new Runnable() {
422       @Override
423       public void run() {
424         final List<String> variants = doTestByFile();
425         assertNotNull(variants);
426         assertContainsElements(variants, "Return", "Returns");
427       }
428     });
429   }
430
431   // PY-16877
432   public void testTwoWordsSectionNameInGoogleDocstring() throws Exception {
433     runWithDocStringFormat(DocStringFormat.GOOGLE, new Runnable() {
434       @Override
435       public void run() {
436         doTest();
437       }
438     });
439   }
440
441   // PY-16870
442   public void testParamNameInGoogleDocstring() {
443     runWithDocStringFormat(DocStringFormat.GOOGLE, new Runnable() {
444       @Override
445       public void run() {
446         final List<String> variants = doTestByFile();
447         assertNotNull(variants);
448         assertSameElements(variants, "param1", "param2");
449       }
450     });
451   }
452
453   // PY-16870
454   public void testOverrideParamNameInGoogleDocstring() {
455     runWithDocStringFormat(DocStringFormat.GOOGLE, new Runnable() {
456       @Override
457       public void run() {
458         final List<String> variants = doTestByFile();
459         assertNotNull(variants);
460         assertSameElements(variants, "param2");
461       }
462     });
463   }
464
465   // PY-16870
466   public void testOverrideParamNameInRestDocstring() {
467     runWithDocStringFormat(DocStringFormat.REST, new Runnable() {
468       @Override
469       public void run() {
470         final List<String> variants = doTestByFile();
471         assertNotNull(variants);
472         assertSameElements(variants, "param2");
473       }
474     });
475   }
476
477   // PY-16870, PY-16972
478   public void testClassNameInDocstring() {
479     runWithDocStringFormat(DocStringFormat.EPYTEXT, new Runnable() {
480       @Override
481       public void run() {
482         doTest();
483       }
484     });
485   }
486
487   public void testPep328Completion() {  // PY-3409
488     myFixture.copyDirectoryToProject("pep328", "pep328");
489     myFixture.configureByFile("pep328/package/subpackage1/moduleX.py");
490     myFixture.completeBasic();
491     myFixture.checkResultByFile("pep328/package/subpackage1/moduleX.after.py");
492   }
493
494   public void testImportedSubmoduleCompletion() {  // PY-3227
495     myFixture.copyDirectoryToProject("submodules", "submodules");
496     myFixture.configureByFile("submodules/foo.py");
497     myFixture.completeBasic();
498     myFixture.checkResultByFile("submodules/foo.after.py");
499   }
500
501   public void testFromImportedModuleCompletion() {  // PY-3595
502     myFixture.copyDirectoryToProject("py3595", "");
503     myFixture.configureByFile("moduleX.py");
504     myFixture.completeBasic();
505     myFixture.checkResultByFile("py3595/moduleX.after.py");
506   }
507
508   public void testExportedConstants() {  // PY-3658
509     myFixture.copyDirectoryToProject("exportedConstants", "");
510     myFixture.configureByFile("a.py");
511     myFixture.completeBasic();
512     myFixture.checkResultByFile("exportedConstants/a.after.py");
513   }
514
515   public void testAlias() {  // PY-3672
516     doTest();
517   }
518
519   public void testDuplicateColon() {  // PY-2652
520     doTest();
521   }
522
523   public void testMro() {  // PY-3989
524     doTest();
525   }
526
527   public void testPrivateMemberType() {  // PY-4589
528     doTest();
529   }
530
531   public void testCompleteBeforeSyntaxError() { // PY-3792
532     doTest();
533   }
534
535   // PY-4279
536   public void testFieldReassignment() {
537     doTest();
538   }
539
540   public void testSuperInit() {  // PY-5066
541     doTest();
542   }
543
544   public void testAssignedNearby() {
545     doTest();
546   }
547
548   public void testDunderAll() {
549     doMultiFileTest();
550   }
551
552   public void testAsName() {
553     doMultiFileTest();
554   }
555
556   public void testKeywordArgumentsForImplicitCall() {
557     doTest();
558   }
559
560   public void testTypeMembers() {  // PY-5311
561     assertFalse(doTestByText("a = 'string'\n" +
562                              "a.<caret>").contains("mro"));
563   }
564
565   public void testDunderAllReference() {  // PY-5502
566     doTest();
567   }
568
569   public void testDunderAllReferenceImport() {  // PY-6306
570     doTest();
571   }
572
573   public void testOldStyleClassAttributes() {
574     doTest();
575   }
576
577   // PY-5821
578   public void testGlobalName() {
579     doTest();
580   }
581
582   // PY-6037
583   public void testExceptName() {
584     doTest();
585   }
586
587   public void testQualifiedAssignment() {  // PY-6121
588     doTest();
589   }
590
591   public void testRelativeImportExcludeToplevel() {  // PY-6304
592     runWithLanguageLevel(LanguageLevel.PYTHON27, new Runnable() {
593       @Override
594       public void run() {
595         myFixture.copyDirectoryToProject("relativeImportExcludeToplevel", "");
596         myFixture.configureByFile("pack/subpack/modX.py");
597         myFixture.completeBasic();
598         assertNull(myFixture.getLookupElementStrings());
599         myFixture.checkResult("from ...subpack import");
600       }
601     });
602   }
603
604   // PY-2813
605   public void testFromNamespacePackageImport() {
606     doMultiFileTest();
607   }
608
609   // PY-6829
610   public void testFakeNameInQualifiedReference() {
611     doTest();
612   }
613
614   // PY-6603
615   public void testNoInitForSubmodules() {
616     doMultiFileTest();
617   }
618
619   public void testUnknownNewReturnType() {  // PY-6671
620     doTest();
621   }
622
623   public void testDunderClass() {  // PY-7327
624     doTest();
625   }
626
627   public void testArgs() {  // PY-7208
628     doTestByText("def foo(*<caret>)");
629     myFixture.checkResult("def foo(*args)");
630   }
631
632   public void testKwArgs() {  // PY-7208
633     doTestByText("def foo(**<caret>)");
634     myFixture.checkResult("def foo(**kwargs)");
635   }
636
637   public void testLocalImportedModule() {  // PY-3668
638     myFixture.copyDirectoryToProject("py3668", "");
639     myFixture.configureByFile("py3668.py");
640     myFixture.completeBasic();
641     myFixture.checkResultByFile("py3668/py3668.after.py");
642   }
643
644   public void testDuplicateDunderAll() {  // PY-6483
645     doTestByText("VAR = 1\nVAR = 2\n__all__ = ['<caret>']");
646     myFixture.checkResult("VAR = 1\n" +
647                           "VAR = 2\n" +
648                           "__all__ = ['VAR']");
649   }
650
651   // PY-7805
652   public void testNoUnderscoredBuiltin() {
653     doTest();
654   }
655
656   public void testParameterFromUsages() {
657     doTest();
658   }
659
660   // PY-1219
661   public void testReCompileMatch() {
662     doTest();
663   }
664
665   public void testReturnTypeOfCallFromUsages() {
666     final List<String> results = doTestByText("def f(x):\n" +
667                                               "    return x\n" +
668                                               "\n" +
669                                               "f('foo').<caret>\n");
670     assertTrue(results.contains("lower"));
671   }
672
673   public void testOverwriteEqualsSign() {  // PY-1337
674     doTestByText("def foo(school=None, kiga=None): pass\n" +
675                  "foo(<caret>school=None)");
676     myFixture.type("sch");
677     myFixture.finishLookup(Lookup.REPLACE_SELECT_CHAR);
678     myFixture.checkResult("def foo(school=None, kiga=None): pass\n" +
679                           "foo(school=None)");
680   }
681
682   public void testOverwriteBracket() {  // PY-6095
683     doTestByText("bar = {'a': '1'}\n" +
684                  "print ba<caret>['a']");
685     myFixture.finishLookup(Lookup.REPLACE_SELECT_CHAR);
686     myFixture.checkResult("bar = {'a': '1'}\n" +
687                           "print bar<caret>['a']");
688   }
689
690   // PY-1860
691   public void testDunderMetaClass() {
692     doTestByText("class C(object):\n" +
693                  "    __meta<caret>\n");
694     myFixture.checkResult("class C(object):\n" +
695                           "    __metaclass__ = \n");
696   }
697
698   // PY-13140
699   public void testModulePrivateNamesCompletedInsideImport() {
700     myFixture.copyDirectoryToProject(getTestName(true), "");
701     myFixture.configureByFile("a.py");
702     myFixture.completeBasic();
703     List<String> suggested = myFixture.getLookupElementStrings();
704     assertNotNull(suggested);
705     assertContainsElements(suggested, "normal_name", "_private_name", "__magic_name__");
706   }
707
708   // PY-4073
709   public void testFunctionSpecialAttributes() {
710     runWithLanguageLevel(LanguageLevel.PYTHON27, new Runnable() {
711       @Override
712       public void run() {
713         List<String> suggested = doTestByText("def func(): pass; func.func_<caret>");
714         assertNotNull(suggested);
715         assertContainsElements(suggested, PyNames.LEGACY_FUNCTION_SPECIAL_ATTRIBUTES);
716
717         suggested = doTestByText("def func(): pass; func.__<caret>");
718         assertNotNull(suggested);
719         assertContainsElements(suggested, PyNames.FUNCTION_SPECIAL_ATTRIBUTES);
720         assertDoesntContain(suggested, PyNames.PY3_ONLY_FUNCTION_SPECIAL_ATTRIBUTES);
721       }
722     });
723   }
724
725   // PY-9342
726   public void testBoundMethodSpecialAttributes() {
727     List<String>  suggested = doTestByText("{}.update.im_<caret>");
728     assertNotNull(suggested);
729     assertContainsElements(suggested, PyNames.LEGACY_METHOD_SPECIAL_ATTRIBUTES);
730
731     suggested = doTestByText("{}.update.__<caret>");
732     assertNotNull(suggested);
733     assertContainsElements(suggested, PyNames.METHOD_SPECIAL_ATTRIBUTES);
734     assertDoesntContain(suggested, PyNames.FUNCTION_SPECIAL_ATTRIBUTES);
735   }
736
737   // PY-9342
738   public void testWeakQualifierBoundMethodAttributes() {
739     assertUnderscoredMethodSpecialAttributesSuggested();
740   }
741
742   private void assertUnderscoredMethodSpecialAttributesSuggested() {
743     final List<String> suggested = doTestByFile();
744     assertNotNull(suggested);
745     assertContainsElements(suggested, PyNames.METHOD_SPECIAL_ATTRIBUTES);
746     assertDoesntContain(suggested, PyNames.FUNCTION_SPECIAL_ATTRIBUTES);
747   }
748
749   // PY-9342
750   public void testUnboundMethodSpecialAttributes() {
751     runWithLanguageLevel(LanguageLevel.PYTHON27, new Runnable() {
752       @Override
753       public void run() {
754         assertUnderscoredMethodSpecialAttributesSuggested();
755       }
756     });
757     runWithLanguageLevel(LanguageLevel.PYTHON32, new Runnable() {
758       @Override
759       public void run() {
760         assertUnderscoredFunctionAttributesSuggested();
761       }
762     });
763   }
764
765   // PY-9342
766   public void testStaticMethodSpecialAttributes() {
767     assertUnderscoredFunctionAttributesSuggested();
768   }
769
770   // PY-9342
771   public void testLambdaSpecialAttributes() {
772     assertUnderscoredFunctionAttributesSuggested();
773   }
774
775   // PY-9342
776   public void testReassignedMethodSpecialAttributes() {
777     assertUnderscoredMethodSpecialAttributesSuggested();
778   }
779
780   private void assertUnderscoredFunctionAttributesSuggested() {
781     final List<String> suggested = doTestByFile();
782     assertNotNull(suggested);
783     assertContainsElements(suggested, PyNames.FUNCTION_SPECIAL_ATTRIBUTES);
784     assertDoesntContain(suggested, PyNames.METHOD_SPECIAL_ATTRIBUTES);
785   }
786
787   public void testSmartFromUsedMethodsOfString() {
788     final List<String> suggested = doTestSmartByFile();
789     assertNotNull(suggested);
790     // Remove duplicates for assertContainsElements(), "append" comes from bytearray
791     assertContainsElements(new HashSet<String>(suggested), "lower", "capitalize", "join", "append");
792   }
793
794   public void testSmartFromUsedAttributesOfClass() {
795     final List<String> suggested = doTestSmartByFile();
796     assertNotNull(suggested);
797     assertContainsElements(suggested, "other_method", "name", "unique_method");
798   }
799
800   // PY-14388
801   public void testAttributeOfIndirectlyImportedPackage() {
802     doMultiFileTest();
803   }
804
805   // PY-14387
806   public void testSubmoduleOfIndirectlyImportedPackage() {
807     myFixture.copyDirectoryToProject(getTestName(true), "");
808     myFixture.configureByFile("a.py");
809     myFixture.completeBasic();
810     final List<String> suggested = myFixture.getLookupElementStrings();
811     assertNotNull(suggested);
812     assertSameElements(suggested, "VAR", "subpkg1");
813   }
814
815   // PY-14519
816   public void testOsPath() {
817     myFixture.copyDirectoryToProject(getTestName(true), "");
818     myFixture.configureByFile("a.py");
819     myFixture.completeBasic();
820     final List<String> suggested = myFixture.getLookupElementStrings();
821     assertNotNull(suggested);
822     assertContainsElements(suggested, "path");
823   }
824
825   // PY-14331
826   public void testExcludedTopLevelPackage() {
827     myFixture.copyDirectoryToProject(getTestName(true), "");
828     myFixture.configureByFile("a.py");
829     PsiTestUtil.addExcludedRoot(myFixture.getModule(), myFixture.findFileInTempDir("pkg1"));
830     final LookupElement[] variants = myFixture.completeBasic();
831     assertNotNull(variants);
832     assertEmpty(variants);
833   }
834
835   // PY-14331
836   public void testExcludedSubPackage() {
837     myFixture.copyDirectoryToProject(getTestName(true), "");
838     myFixture.configureByFile("a.py");
839     PsiTestUtil.addExcludedRoot(myFixture.getModule(), myFixture.findFileInTempDir("pkg1/subpkg1"));
840     final LookupElement[] variants = myFixture.completeBasic();
841     assertNotNull(variants);
842     assertEmpty(variants);
843   }
844
845   // PY-15119
846   public void testRelativeFromImportWhitespacesAfterDot() {
847     myFixture.copyDirectoryToProject(getTestName(true), "");
848     myFixture.configureByFile("pkg/subpkg1/a.py");
849     myFixture.completeBasic();
850     assertSameElements(myFixture.getLookupElementStrings(), "import", "subpkg1", "subpkg2", "m");
851   }
852
853   // PY-15197
854   public void testKeywordArgumentEqualsSignSurroundedWithSpaces() {
855     getPythonCodeStyleSettings().SPACE_AROUND_EQ_IN_KEYWORD_ARGUMENT = true;
856     doTest();
857   }
858
859   public void testStructuralType() {
860     doTest();
861   }
862
863   // PY-11214
864   public void testNext() {
865     doTest();
866   }
867
868   @Override
869   protected String getTestDataPath() {
870     return super.getTestDataPath() + "/completion";
871   }
872 }