PY-20805 PY-8219 Detect usages of local variables inside f-strings
[idea/community.git] / python / testSrc / com / jetbrains / python / PythonInspectionsTest.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.intellij.codeInspection.InspectionProfileEntry;
19 import com.intellij.codeInspection.LocalInspectionTool;
20 import com.intellij.codeInspection.ex.LocalInspectionToolWrapper;
21 import com.jetbrains.python.documentation.docstrings.DocStringFormat;
22 import com.jetbrains.python.fixtures.PyTestCase;
23 import com.jetbrains.python.inspections.*;
24 import com.jetbrains.python.psi.LanguageLevel;
25
26 /**
27  * @author yole
28  */
29 public class PythonInspectionsTest extends PyTestCase {
30   public void testReturnValueFromInit() {
31     LocalInspectionTool inspection = new PyReturnFromInitInspection();
32     doTest(getTestName(true), inspection);
33   }
34
35   private void doTest(String testName, LocalInspectionTool localInspectionTool) {
36     myFixture.testInspection("inspections/" + testName, new LocalInspectionToolWrapper(localInspectionTool));
37   }
38
39   private void doTestWithPy3k(String testName, LocalInspectionTool localInspectionTool) {
40     doTestWithLanguageLevel(testName, localInspectionTool, LanguageLevel.PYTHON30);
41   }
42
43   private void doTestWithLanguageLevel(String testName,
44                                        LocalInspectionTool localInspectionTool,
45                                        LanguageLevel languageLevel) {
46     setLanguageLevel(languageLevel);
47     try {
48       doTest(testName, localInspectionTool);
49     }
50     finally {
51       setLanguageLevel(null);
52     }
53   }
54
55   public void testPyMethodFirstArgAssignmentInspection() {
56     LocalInspectionTool inspection = new PyMethodFirstArgAssignmentInspection();
57     doTest(getTestName(false), inspection);
58   }
59
60   public void testPyMethodParametersInspection() {
61     doHighlightingTest(PyMethodParametersInspection.class);
62   }
63
64   public void testPyMethodParametersInspectionMetacls() {
65     PyMethodParametersInspection inspection = new PyMethodParametersInspection();
66     inspection.MCS = "metacls";
67     myFixture.configureByFile("inspections/" + getTestName(false) + "/test.py");
68     myFixture.enableInspections(inspection);
69     myFixture.checkHighlighting(true, false, true);
70   }
71
72   public void testPyMethodParametersInspectionInitSubclass() {
73     doHighlightingTest(PyMethodParametersInspection.class, LanguageLevel.PYTHON36);
74   }
75
76   public void testPyNestedDecoratorsInspection() {
77     LocalInspectionTool inspection = new PyNestedDecoratorsInspection();
78     doTest(getTestName(false), inspection);
79   }
80
81   public void testPyRedeclarationInspection() {
82     doHighlightingTest(PyRedeclarationInspection.class);
83   }
84
85   public void testPyTrailingSemicolonInspection() {
86     LocalInspectionTool inspection = new PyTrailingSemicolonInspection();
87     doTest(getTestName(false), inspection);
88   }
89
90   public void testPyUnusedLocalVariableInspection() {
91     PyUnusedLocalInspection inspection = new PyUnusedLocalInspection();
92     inspection.ignoreTupleUnpacking = false;
93     inspection.ignoreLambdaParameters = false;
94     doHighlightingTest(inspection, LanguageLevel.PYTHON27);
95   }
96
97   public void testPyUnusedLocalVariableInspection3K() {
98     doHighlightingTest(PyUnusedLocalInspection.class, LanguageLevel.PYTHON30);
99   }
100
101   public void testPyUnusedVariableTupleUnpacking() {
102     doHighlightingTest(PyUnusedLocalInspection.class, LanguageLevel.PYTHON26);
103   }
104
105   public void testPyUnusedLocalFunctionInspection() {
106     PyUnusedLocalInspection inspection = new PyUnusedLocalInspection();
107     doTest(getTestName(false), inspection);
108   }
109
110   // PY-9778
111   public void testPyUnusedLocalCoroutine() {
112     myFixture.copyDirectoryToProject("inspections/" + getTestName(false), "");
113     doHighlightingTest(PyUnusedLocalInspection.class, LanguageLevel.PYTHON34);
114   }
115
116   // PY-20805
117   public void testUnusedLocalFStringReferences() {
118     doHighlightingTest(PyUnusedLocalInspection.class, LanguageLevel.PYTHON36);
119   }
120
121   // PY-8219
122   public void testUnusedLocalDoctestReference() {
123     doHighlightingTest(PyUnusedLocalInspection.class);
124   }
125
126   public void testPyDictCreationInspection() {
127     doHighlightingTest(PyDictCreationInspection.class, LanguageLevel.PYTHON26);
128   }
129
130   public void testPyTupleAssignmentBalanceInspection() {
131     LocalInspectionTool inspection = new PyTupleAssignmentBalanceInspection();
132     doTest(getTestName(false), inspection);
133   }
134
135   public void testPyTupleAssignmentBalanceInspection2() {
136     LocalInspectionTool inspection = new PyTupleAssignmentBalanceInspection();
137     doTestWithPy3k(getTestName(false), inspection);
138   }
139
140   public void testPyClassicStyleClassInspection() {
141     doHighlightingTest(PyClassicStyleClassInspection.class);
142   }
143
144   public void testPyExceptClausesOrderInspection() {
145     doHighlightingTest(PyExceptClausesOrderInspection.class, LanguageLevel.PYTHON26);
146   }
147
148   public void testPyExceptionInheritInspection() {
149     doHighlightingTest(PyExceptionInheritInspection.class);
150   }
151
152   public void testPyDefaultArgumentInspection() {
153     LocalInspectionTool inspection = new PyDefaultArgumentInspection();
154     doTest(getTestName(false), inspection);
155   }
156
157   public void testPyRaisingNewStyleClassInspection() {
158     LocalInspectionTool inspection = new PyRaisingNewStyleClassInspection();
159     doTestWithLanguageLevel(getTestName(false), inspection, LanguageLevel.PYTHON24);
160   }
161
162   public void testPyDocstringInspection() {
163     LocalInspectionTool inspection = new PyMissingOrEmptyDocstringInspection();
164     doTest(getTestName(false), inspection);
165   }
166
167   //PY-3373
168   public void testPyDocstringParametersInspection() {     
169     runWithDocStringFormat(DocStringFormat.EPYTEXT, () -> doHighlightingTest(PyIncorrectDocstringInspection.class, LanguageLevel.PYTHON33));
170   }
171   
172   // PY-9795
173   public void testGoogleDocstringParametersInspection() {     
174     runWithDocStringFormat(DocStringFormat.GOOGLE, () -> doHighlightingTest(PyIncorrectDocstringInspection.class, LanguageLevel.PYTHON33));
175   }
176
177   public void testPySimplifyBooleanCheckInspection() {
178     doHighlightingTest(PySimplifyBooleanCheckInspection.class, LanguageLevel.PYTHON26);
179   }
180
181   public void testPyFromFutureImportInspection() {
182     doHighlightingTest(PyFromFutureImportInspection.class, LanguageLevel.PYTHON26);
183   }
184
185   public void testPyFromFutureImportInspectionDocString() {
186     myFixture.configureByFile("inspections/PyFromFutureImportInspection/module_docstring.py");
187     myFixture.enableInspections(PyFromFutureImportInspection.class);
188     myFixture.checkHighlighting(true, false, false);
189   }
190
191   public void testPyComparisonWithNoneInspection() {
192     LocalInspectionTool inspection = new PyComparisonWithNoneInspection();
193     doTest(getTestName(false), inspection);
194   }
195
196   public void testPyStringExceptionInspection() {
197     LocalInspectionTool inspection = new PyStringExceptionInspection();
198     doTest(getTestName(false), inspection);
199   }
200
201   public void testPySuperArgumentsInspection() {
202     LocalInspectionTool inspection = new PySuperArgumentsInspection();
203     doTest(getTestName(false), inspection);
204   }
205
206   public void testPyByteLiteralInspection() {
207     doHighlightingTest(PyByteLiteralInspection.class);
208   }
209
210   public void testPyTupleItemAssignmentInspection() {
211     LocalInspectionTool inspection = new PyTupleItemAssignmentInspection();
212     doTest(getTestName(false), inspection);
213   }
214
215   public void testPyInitNewSignatureInspection() {
216     LocalInspectionTool inspection = new PyInitNewSignatureInspection();
217     doTest(getTestName(false), inspection);
218   }
219
220   public void testPyCallByClassInspection() {
221     doHighlightingTest(PyCallByClassInspection.class); // ok, we can handle insanely long lines :)
222   }
223
224   private void doHighlightingTest(final Class<? extends PyInspection> inspectionClass) {
225     myFixture.configureByFile("inspections/" + getTestName(false) + "/test.py");
226     myFixture.enableInspections(inspectionClass);
227     myFixture.checkHighlighting(true, false, true);
228   }
229
230   private void doHighlightingTest(final Class<? extends PyInspection> inspectionClass, final LanguageLevel languageLevel) {
231     setLanguageLevel(languageLevel);
232     try {
233       doHighlightingTest(inspectionClass);
234     }
235     finally {
236       setLanguageLevel(null);
237     }
238   }
239
240   private void doHighlightingTest(InspectionProfileEntry entry, final LanguageLevel languageLevel) {
241     setLanguageLevel(languageLevel);
242     try {
243       doHighlightingTest(entry);
244     }
245     finally {
246       setLanguageLevel(null);
247     }
248   }
249
250   private void doHighlightingTest(InspectionProfileEntry entry) {
251     myFixture.configureByFile("inspections/" + getTestName(false) + "/test.py");
252     myFixture.enableInspections(entry);
253     myFixture.checkHighlighting(true, false, true);
254   }
255
256   public void testPyPropertyDefinitionInspection25() {
257     doHighlightingTest(PyPropertyDefinitionInspection.class, LanguageLevel.PYTHON25);
258   }
259
260   public void testPyPropertyDefinitionInspection26() {
261     doHighlightingTest(PyPropertyDefinitionInspection.class, LanguageLevel.PYTHON26);
262   }
263
264   // PY-11426
265   public void testPyPropertyDefinitionInspection33() {
266     doHighlightingTest(PyPropertyDefinitionInspection.class, LanguageLevel.PYTHON33);
267   }
268
269   public void testInconsistentIndentation() {
270     doHighlightingTest(PyInconsistentIndentationInspection.class, LanguageLevel.PYTHON26);
271   }
272
273   public void testPyChainedComparisonsInspection() {
274     doHighlightingTest(PyChainedComparisonsInspection.class);
275   }
276
277   public void testPyChainedComparisonsInspectionWithConstantInTheMiddle() {
278     myFixture.configureByFile("inspections/" + getTestName(false) + "/test.py");
279     PyChainedComparisonsInspection inspection = new PyChainedComparisonsInspection();
280     myFixture.enableInspections(inspection);
281     inspection.ignoreConstantInTheMiddle = true;
282     myFixture.checkHighlighting(true, false, true);
283   }
284
285   public void testPyBroadExceptionInspection() {
286     doHighlightingTest(PyBroadExceptionInspection.class);
287   }
288
289   public void testPyDictDuplicateKeysInspection() {
290     doHighlightingTest(PyDictDuplicateKeysInspection.class);
291   }
292
293
294   public void testPyTupleAssignmentBalanceInspection3() {
295     try {
296       setLanguageLevel(LanguageLevel.PYTHON27);
297       doHighlightingTest(PyTupleAssignmentBalanceInspection.class);
298     } finally {
299       setLanguageLevel(null);
300     }
301   }
302
303   public void testPyListCreationInspection() {         //PY-2823
304     doHighlightingTest(PyListCreationInspection.class);
305   }
306
307   public void testPyUnnecessaryBackslashInspection() {    //PY-2952
308     setLanguageLevel(LanguageLevel.PYTHON27);
309     doHighlightingTest(PyUnnecessaryBackslashInspection.class);
310   }
311
312   public void testPySingleQuotedDocstringInspection() {    //PY-1445
313     doHighlightingTest(PySingleQuotedDocstringInspection.class);
314   }
315
316   public void testPyArgumentEqualDefaultInspection() {    //PY-3125
317     doHighlightingTest(PyArgumentEqualDefaultInspection.class);
318   }
319
320   public void testPyNonAsciiCharInspection() {    //PY-5868
321     doHighlightingTest(PyNonAsciiCharInspection.class);
322   }
323
324   public void testPyNonAsciiCharReferenceInspection() {
325     doHighlightingTest(PyNonAsciiCharInspection.class);
326   }
327
328   public void testPySetFunctionToLiteralInspection() {    //PY-3120
329     setLanguageLevel(LanguageLevel.PYTHON27);
330     doHighlightingTest(PySetFunctionToLiteralInspection.class);
331   }
332
333   public void testPyDecoratorInspection() {    //PY-3348
334     doHighlightingTest(PyDecoratorInspection.class);
335   }
336
337   // PY-5807
338   public void testPyShadowingBuiltinsInspection() {
339     doHighlightingTest(PyShadowingBuiltinsInspection.class);
340   }
341
342   public void testPyShadowingNamesInspection() {
343     doHighlightingTest(PyShadowingNamesInspection.class);
344   }
345
346   public void testPyDunderSlotsInspection() {
347     runWithLanguageLevel(LanguageLevel.PYTHON30, () -> doHighlightingTest(PyDunderSlotsInspection.class));
348   }
349 }