PY-17002 Suggest types inside unclosed parentheses in Google docstrings
[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   // PY-17002
488   public void testParamTypeInGoogleDocstringWithoutClosingParenthesis() {
489     runWithDocStringFormat(DocStringFormat.GOOGLE, new Runnable() {
490       @Override
491       public void run() {
492         final List<String> variants = doTestByFile();
493         assertNotNull(variants);
494         assertSameElements(variants, "str", "basestring");
495       }
496     });
497   }
498
499   public void testPep328Completion() {  // PY-3409
500     myFixture.copyDirectoryToProject("pep328", "pep328");
501     myFixture.configureByFile("pep328/package/subpackage1/moduleX.py");
502     myFixture.completeBasic();
503     myFixture.checkResultByFile("pep328/package/subpackage1/moduleX.after.py");
504   }
505
506   public void testImportedSubmoduleCompletion() {  // PY-3227
507     myFixture.copyDirectoryToProject("submodules", "submodules");
508     myFixture.configureByFile("submodules/foo.py");
509     myFixture.completeBasic();
510     myFixture.checkResultByFile("submodules/foo.after.py");
511   }
512
513   public void testFromImportedModuleCompletion() {  // PY-3595
514     myFixture.copyDirectoryToProject("py3595", "");
515     myFixture.configureByFile("moduleX.py");
516     myFixture.completeBasic();
517     myFixture.checkResultByFile("py3595/moduleX.after.py");
518   }
519
520   public void testExportedConstants() {  // PY-3658
521     myFixture.copyDirectoryToProject("exportedConstants", "");
522     myFixture.configureByFile("a.py");
523     myFixture.completeBasic();
524     myFixture.checkResultByFile("exportedConstants/a.after.py");
525   }
526
527   public void testAlias() {  // PY-3672
528     doTest();
529   }
530
531   public void testDuplicateColon() {  // PY-2652
532     doTest();
533   }
534
535   public void testMro() {  // PY-3989
536     doTest();
537   }
538
539   public void testPrivateMemberType() {  // PY-4589
540     doTest();
541   }
542
543   public void testCompleteBeforeSyntaxError() { // PY-3792
544     doTest();
545   }
546
547   // PY-4279
548   public void testFieldReassignment() {
549     doTest();
550   }
551
552   public void testSuperInit() {  // PY-5066
553     doTest();
554   }
555
556   public void testAssignedNearby() {
557     doTest();
558   }
559
560   public void testDunderAll() {
561     doMultiFileTest();
562   }
563
564   public void testAsName() {
565     doMultiFileTest();
566   }
567
568   public void testKeywordArgumentsForImplicitCall() {
569     doTest();
570   }
571
572   public void testTypeMembers() {  // PY-5311
573     assertFalse(doTestByText("a = 'string'\n" +
574                              "a.<caret>").contains("mro"));
575   }
576
577   public void testDunderAllReference() {  // PY-5502
578     doTest();
579   }
580
581   public void testDunderAllReferenceImport() {  // PY-6306
582     doTest();
583   }
584
585   public void testOldStyleClassAttributes() {
586     doTest();
587   }
588
589   // PY-5821
590   public void testGlobalName() {
591     doTest();
592   }
593
594   // PY-6037
595   public void testExceptName() {
596     doTest();
597   }
598
599   public void testQualifiedAssignment() {  // PY-6121
600     doTest();
601   }
602
603   public void testRelativeImportExcludeToplevel() {  // PY-6304
604     runWithLanguageLevel(LanguageLevel.PYTHON27, new Runnable() {
605       @Override
606       public void run() {
607         myFixture.copyDirectoryToProject("relativeImportExcludeToplevel", "");
608         myFixture.configureByFile("pack/subpack/modX.py");
609         myFixture.completeBasic();
610         assertNull(myFixture.getLookupElementStrings());
611         myFixture.checkResult("from ...subpack import");
612       }
613     });
614   }
615
616   // PY-2813
617   public void testFromNamespacePackageImport() {
618     doMultiFileTest();
619   }
620
621   // PY-6829
622   public void testFakeNameInQualifiedReference() {
623     doTest();
624   }
625
626   // PY-6603
627   public void testNoInitForSubmodules() {
628     doMultiFileTest();
629   }
630
631   public void testUnknownNewReturnType() {  // PY-6671
632     doTest();
633   }
634
635   public void testDunderClass() {  // PY-7327
636     doTest();
637   }
638
639   public void testArgs() {  // PY-7208
640     doTestByText("def foo(*<caret>)");
641     myFixture.checkResult("def foo(*args)");
642   }
643
644   public void testKwArgs() {  // PY-7208
645     doTestByText("def foo(**<caret>)");
646     myFixture.checkResult("def foo(**kwargs)");
647   }
648
649   public void testLocalImportedModule() {  // PY-3668
650     myFixture.copyDirectoryToProject("py3668", "");
651     myFixture.configureByFile("py3668.py");
652     myFixture.completeBasic();
653     myFixture.checkResultByFile("py3668/py3668.after.py");
654   }
655
656   public void testDuplicateDunderAll() {  // PY-6483
657     doTestByText("VAR = 1\nVAR = 2\n__all__ = ['<caret>']");
658     myFixture.checkResult("VAR = 1\n" +
659                           "VAR = 2\n" +
660                           "__all__ = ['VAR']");
661   }
662
663   // PY-7805
664   public void testNoUnderscoredBuiltin() {
665     doTest();
666   }
667
668   public void testParameterFromUsages() {
669     doTest();
670   }
671
672   // PY-1219
673   public void testReCompileMatch() {
674     doTest();
675   }
676
677   public void testReturnTypeOfCallFromUsages() {
678     final List<String> results = doTestByText("def f(x):\n" +
679                                               "    return x\n" +
680                                               "\n" +
681                                               "f('foo').<caret>\n");
682     assertTrue(results.contains("lower"));
683   }
684
685   public void testOverwriteEqualsSign() {  // PY-1337
686     doTestByText("def foo(school=None, kiga=None): pass\n" +
687                  "foo(<caret>school=None)");
688     myFixture.type("sch");
689     myFixture.finishLookup(Lookup.REPLACE_SELECT_CHAR);
690     myFixture.checkResult("def foo(school=None, kiga=None): pass\n" +
691                           "foo(school=None)");
692   }
693
694   public void testOverwriteBracket() {  // PY-6095
695     doTestByText("bar = {'a': '1'}\n" +
696                  "print ba<caret>['a']");
697     myFixture.finishLookup(Lookup.REPLACE_SELECT_CHAR);
698     myFixture.checkResult("bar = {'a': '1'}\n" +
699                           "print bar<caret>['a']");
700   }
701
702   // PY-1860
703   public void testDunderMetaClass() {
704     doTestByText("class C(object):\n" +
705                  "    __meta<caret>\n");
706     myFixture.checkResult("class C(object):\n" +
707                           "    __metaclass__ = \n");
708   }
709
710   // PY-13140
711   public void testModulePrivateNamesCompletedInsideImport() {
712     myFixture.copyDirectoryToProject(getTestName(true), "");
713     myFixture.configureByFile("a.py");
714     myFixture.completeBasic();
715     List<String> suggested = myFixture.getLookupElementStrings();
716     assertNotNull(suggested);
717     assertContainsElements(suggested, "normal_name", "_private_name", "__magic_name__");
718   }
719
720   // PY-4073
721   public void testFunctionSpecialAttributes() {
722     runWithLanguageLevel(LanguageLevel.PYTHON27, new Runnable() {
723       @Override
724       public void run() {
725         List<String> suggested = doTestByText("def func(): pass; func.func_<caret>");
726         assertNotNull(suggested);
727         assertContainsElements(suggested, PyNames.LEGACY_FUNCTION_SPECIAL_ATTRIBUTES);
728
729         suggested = doTestByText("def func(): pass; func.__<caret>");
730         assertNotNull(suggested);
731         assertContainsElements(suggested, PyNames.FUNCTION_SPECIAL_ATTRIBUTES);
732         assertDoesntContain(suggested, PyNames.PY3_ONLY_FUNCTION_SPECIAL_ATTRIBUTES);
733       }
734     });
735   }
736
737   // PY-9342
738   public void testBoundMethodSpecialAttributes() {
739     List<String>  suggested = doTestByText("{}.update.im_<caret>");
740     assertNotNull(suggested);
741     assertContainsElements(suggested, PyNames.LEGACY_METHOD_SPECIAL_ATTRIBUTES);
742
743     suggested = doTestByText("{}.update.__<caret>");
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 testWeakQualifierBoundMethodAttributes() {
751     assertUnderscoredMethodSpecialAttributesSuggested();
752   }
753
754   private void assertUnderscoredMethodSpecialAttributesSuggested() {
755     final List<String> suggested = doTestByFile();
756     assertNotNull(suggested);
757     assertContainsElements(suggested, PyNames.METHOD_SPECIAL_ATTRIBUTES);
758     assertDoesntContain(suggested, PyNames.FUNCTION_SPECIAL_ATTRIBUTES);
759   }
760
761   // PY-9342
762   public void testUnboundMethodSpecialAttributes() {
763     runWithLanguageLevel(LanguageLevel.PYTHON27, new Runnable() {
764       @Override
765       public void run() {
766         assertUnderscoredMethodSpecialAttributesSuggested();
767       }
768     });
769     runWithLanguageLevel(LanguageLevel.PYTHON32, new Runnable() {
770       @Override
771       public void run() {
772         assertUnderscoredFunctionAttributesSuggested();
773       }
774     });
775   }
776
777   // PY-9342
778   public void testStaticMethodSpecialAttributes() {
779     assertUnderscoredFunctionAttributesSuggested();
780   }
781
782   // PY-9342
783   public void testLambdaSpecialAttributes() {
784     assertUnderscoredFunctionAttributesSuggested();
785   }
786
787   // PY-9342
788   public void testReassignedMethodSpecialAttributes() {
789     assertUnderscoredMethodSpecialAttributesSuggested();
790   }
791
792   private void assertUnderscoredFunctionAttributesSuggested() {
793     final List<String> suggested = doTestByFile();
794     assertNotNull(suggested);
795     assertContainsElements(suggested, PyNames.FUNCTION_SPECIAL_ATTRIBUTES);
796     assertDoesntContain(suggested, PyNames.METHOD_SPECIAL_ATTRIBUTES);
797   }
798
799   public void testSmartFromUsedMethodsOfString() {
800     final List<String> suggested = doTestSmartByFile();
801     assertNotNull(suggested);
802     // Remove duplicates for assertContainsElements(), "append" comes from bytearray
803     assertContainsElements(new HashSet<String>(suggested), "lower", "capitalize", "join", "append");
804   }
805
806   public void testSmartFromUsedAttributesOfClass() {
807     final List<String> suggested = doTestSmartByFile();
808     assertNotNull(suggested);
809     assertContainsElements(suggested, "other_method", "name", "unique_method");
810   }
811
812   // PY-14388
813   public void testAttributeOfIndirectlyImportedPackage() {
814     doMultiFileTest();
815   }
816
817   // PY-14387
818   public void testSubmoduleOfIndirectlyImportedPackage() {
819     myFixture.copyDirectoryToProject(getTestName(true), "");
820     myFixture.configureByFile("a.py");
821     myFixture.completeBasic();
822     final List<String> suggested = myFixture.getLookupElementStrings();
823     assertNotNull(suggested);
824     assertSameElements(suggested, "VAR", "subpkg1");
825   }
826
827   // PY-14519
828   public void testOsPath() {
829     myFixture.copyDirectoryToProject(getTestName(true), "");
830     myFixture.configureByFile("a.py");
831     myFixture.completeBasic();
832     final List<String> suggested = myFixture.getLookupElementStrings();
833     assertNotNull(suggested);
834     assertContainsElements(suggested, "path");
835   }
836
837   // PY-14331
838   public void testExcludedTopLevelPackage() {
839     myFixture.copyDirectoryToProject(getTestName(true), "");
840     myFixture.configureByFile("a.py");
841     PsiTestUtil.addExcludedRoot(myFixture.getModule(), myFixture.findFileInTempDir("pkg1"));
842     final LookupElement[] variants = myFixture.completeBasic();
843     assertNotNull(variants);
844     assertEmpty(variants);
845   }
846
847   // PY-14331
848   public void testExcludedSubPackage() {
849     myFixture.copyDirectoryToProject(getTestName(true), "");
850     myFixture.configureByFile("a.py");
851     PsiTestUtil.addExcludedRoot(myFixture.getModule(), myFixture.findFileInTempDir("pkg1/subpkg1"));
852     final LookupElement[] variants = myFixture.completeBasic();
853     assertNotNull(variants);
854     assertEmpty(variants);
855   }
856
857   // PY-15119
858   public void testRelativeFromImportWhitespacesAfterDot() {
859     myFixture.copyDirectoryToProject(getTestName(true), "");
860     myFixture.configureByFile("pkg/subpkg1/a.py");
861     myFixture.completeBasic();
862     assertSameElements(myFixture.getLookupElementStrings(), "import", "subpkg1", "subpkg2", "m");
863   }
864
865   // PY-15197
866   public void testKeywordArgumentEqualsSignSurroundedWithSpaces() {
867     getPythonCodeStyleSettings().SPACE_AROUND_EQ_IN_KEYWORD_ARGUMENT = true;
868     doTest();
869   }
870
871   public void testStructuralType() {
872     doTest();
873   }
874
875   // PY-11214
876   public void testNext() {
877     doTest();
878   }
879
880   @Override
881   protected String getTestDataPath() {
882     return super.getTestDataPath() + "/completion";
883   }
884 }