9646906b89d9dddee12f1e053a9dfd35ff0047a2
[idea/community.git] / python / testSrc / com / jetbrains / env / python / PythonDebuggerTest.java
1 package com.jetbrains.env.python;
2
3 import com.google.common.collect.ImmutableSet;
4 import com.google.common.collect.Lists;
5 import com.google.common.collect.Sets;
6 import com.intellij.openapi.util.SystemInfo;
7 import com.intellij.openapi.util.io.FileUtil;
8 import com.intellij.openapi.vfs.LocalFileSystem;
9 import com.intellij.testFramework.UsefulTestCase;
10 import com.intellij.testFramework.fixtures.IdeaProjectTestFixture;
11 import com.intellij.xdebugger.XDebuggerTestUtil;
12 import com.intellij.xdebugger.breakpoints.SuspendPolicy;
13 import com.jetbrains.TestEnv;
14 import com.jetbrains.env.PyEnvTestCase;
15 import com.jetbrains.env.PyProcessWithConsoleTestTask;
16 import com.jetbrains.env.Staging;
17 import com.jetbrains.env.StagingOn;
18 import com.jetbrains.env.python.debug.PyDebuggerTask;
19 import com.jetbrains.env.ut.PyUnitTestProcessRunner;
20 import com.jetbrains.python.PythonHelpersLocator;
21 import com.jetbrains.python.console.pydev.PydevCompletionVariant;
22 import com.jetbrains.python.debugger.PyDebugValue;
23 import com.jetbrains.python.debugger.PyDebuggerException;
24 import com.jetbrains.python.debugger.PyExceptionBreakpointProperties;
25 import com.jetbrains.python.debugger.PyExceptionBreakpointType;
26 import com.jetbrains.python.debugger.pydev.PyDebugCallback;
27 import com.jetbrains.python.debugger.settings.PyDebuggerSettings;
28 import com.jetbrains.python.debugger.settings.PySteppingFilter;
29 import com.jetbrains.python.sdk.flavors.PythonSdkFlavor;
30 import com.jetbrains.python.sdkTools.SdkCreationType;
31 import org.jetbrains.annotations.NotNull;
32 import org.junit.Test;
33
34 import java.io.File;
35 import java.util.ArrayList;
36 import java.util.List;
37 import java.util.Set;
38
39 import static org.junit.Assert.assertEquals;
40 import static org.junit.Assert.assertNull;
41
42 /**
43  * @author traff
44  */
45
46 public class PythonDebuggerTest extends PyEnvTestCase {
47   @Test
48   public void testBreakpointStopAndEval() throws Exception {
49     runPythonTest(new PyDebuggerTask("/debug", "test1.py") {
50       @Override
51       public void before() throws Exception {
52         toggleBreakpoint(getFilePath(getScriptName()), 3);
53       }
54
55       @Override
56       public void testing() throws Exception {
57         waitForPause();
58
59         eval("i").hasValue("0");
60
61         resume();
62
63         waitForPause();
64
65         eval("i").hasValue("1");
66
67         resume();
68
69         waitForPause();
70
71         eval("i").hasValue("2");
72       }
73     });
74   }
75
76   @Test
77   @Staging
78   public void testPydevTests_Debugger() {
79     unittests("tests_pydevd_python/test_debugger.py");
80   }
81
82   @Test
83   @Staging
84   public void testPydevMonkey() {
85     unittests("tests_pydevd_python/test_pydev_monkey.py");
86   }
87
88   private void unittests(final String script) {
89     runPythonTest(new PyProcessWithConsoleTestTask<PyUnitTestProcessRunner>("/helpers/pydev", SdkCreationType.SDK_PACKAGES_ONLY) {
90
91       @NotNull
92       @Override
93       protected PyUnitTestProcessRunner createProcessRunner() throws Exception {
94         return new PyUnitTestProcessRunner(script, 0);
95       }
96
97       @NotNull
98       @Override
99       public String getTestDataPath() {
100         return PythonHelpersLocator.getPythonCommunityPath();
101       }
102
103       @Override
104       protected void checkTestResults(@NotNull final PyUnitTestProcessRunner runner,
105                                       @NotNull final String stdout,
106                                       @NotNull final String stderr,
107                                       @NotNull final String all) {
108         runner.assertAllTestsPassed();
109       }
110     });
111   }
112
113   @Test
114   public void testConditionalBreakpoint() throws Exception {
115     runPythonTest(new PyDebuggerTask("/debug", "test1.py") {
116       @Override
117       public void before() throws Exception {
118         toggleBreakpoint(getFilePath(getScriptName()), 3);
119         XDebuggerTestUtil.setBreakpointCondition(getProject(), 3, "i == 1 or i == 11 or i == 111");
120       }
121
122       @Override
123       public void testing() throws Exception {
124         waitForPause();
125
126         eval("i").hasValue("1");
127
128         resume();
129
130         waitForPause();
131
132         eval("i").hasValue("11");
133
134         resume();
135
136         waitForPause();
137
138         eval("i").hasValue("111");
139       }
140     });
141   }
142
143   @Test
144   public void testDebugConsole() throws Exception {
145     runPythonTest(new PyDebuggerTask("/debug", "test1.py") {
146       @Override
147       public void before() throws Exception {
148         toggleBreakpoint(getFilePath(getScriptName()), 3);
149       }
150
151       @Override
152       public void testing() throws Exception {
153         waitForPause();
154
155         eval("i").hasValue("0");
156
157         resume();
158
159         waitForPause();
160
161         consoleExec("'i=%d'%i");
162
163         waitForOutput("'i=1'");
164
165         consoleExec("x");
166
167         waitForOutput("name 'x' is not defined");
168
169         consoleExec("1-;");
170
171         waitForOutput("SyntaxError");
172
173         resume();
174       }
175
176       private void consoleExec(String command) {
177         myDebugProcess.consoleExec(command, new PyDebugCallback<String>() {
178           @Override
179           public void ok(String value) {
180
181           }
182
183           @Override
184           public void error(PyDebuggerException exception) {
185           }
186         });
187       }
188     });
189   }
190
191   @Test
192   public void testDebugCompletion() throws Exception {
193     runPythonTest(new PyDebuggerTask("/debug", "test4.py") {
194       @Override
195       public void before() throws Exception {
196         toggleBreakpoint(getScriptName(), 3);
197       }
198
199       @Override
200       public void testing() throws Exception {
201         waitForPause();
202
203         List<PydevCompletionVariant> list = myDebugProcess.getCompletions("xvalu");
204         assertEquals(2, list.size());
205       }
206     });
207   }
208
209   @Test
210   public void testBreakpointLogExpression() throws Exception {
211     runPythonTest(new PyDebuggerTask("/debug", "test1.py") {
212       @Override
213       public void before() throws Exception {
214         toggleBreakpoint(getFilePath(getScriptName()), 3);
215         XDebuggerTestUtil.setBreakpointLogExpression(getProject(), 3, "'i = %d'%i");
216       }
217
218       @Override
219       public void testing() throws Exception {
220         waitForPause();
221         resume();
222         waitForOutput("i = 1");
223       }
224     });
225   }
226
227   @Test
228   public void testStepOver() throws Exception {
229     runPythonTest(new PyDebuggerTask("/debug", "test2.py") {
230       @Override
231       public void before() throws Exception {
232         toggleBreakpoint(getFilePath(getScriptName()), 5);
233       }
234
235       @Override
236       public void testing() throws Exception {
237         waitForPause();
238         stepOver();
239         waitForPause();
240         stepOver();
241         waitForPause();
242         eval("z").hasValue("2");
243       }
244     });
245   }
246
247   @Test
248   @StagingOn(os = TestEnv.WINDOWS)
249   public void testStepInto() throws Exception {
250     runPythonTest(new PyDebuggerTask("/debug", "test2.py") {
251       @Override
252       public void before() throws Exception {
253         toggleBreakpoint(getFilePath(getScriptName()), 5);
254       }
255
256       @Override
257       public void testing() throws Exception {
258         waitForPause();
259         stepInto();
260         waitForPause();
261         eval("x").hasValue("1");
262         stepOver();
263         waitForPause();
264         eval("y").hasValue("3");
265         stepOver();
266         waitForPause();
267         eval("z").hasValue("1");
268       }
269     });
270   }
271
272   @Test
273   public void testStepIntoMyCode() throws Exception {
274     runPythonTest(new PyDebuggerTask("/debug", "test_my_code.py") {
275
276       @Override
277       public void before() throws Exception {
278         toggleBreakpoint(getFilePath(getScriptName()), 5);
279         toggleBreakpoint(getFilePath(getScriptName()), 7);
280       }
281
282       @Override
283       public void testing() throws Exception {
284         waitForPause();
285         stepIntoMyCode();
286         waitForPause();
287         eval("x").hasValue("2");
288         resume();
289         waitForPause();
290         eval("x").hasValue("3");
291         stepIntoMyCode();
292         waitForPause();
293         eval("stopped_in_user_file").hasValue("True");
294       }
295     });
296   }
297
298   @Test
299   public void testSmartStepInto() throws Exception {
300     runPythonTest(new PyDebuggerTask("/debug", "test3.py") {
301       @Override
302       public void before() throws Exception {
303         toggleBreakpoint(getFilePath(getScriptName()), 14);
304       }
305
306       @Override
307       public void testing() throws Exception {
308         waitForPause();
309         smartStepInto("foo");
310         waitForPause();
311         stepOver();
312         waitForPause();
313         eval("y").hasValue("4");
314       }
315     });
316   }
317
318   @Test
319   public void testSmartStepInto2() throws Exception {
320     runPythonTest(new PyDebuggerTask("/debug", "test3.py") {
321       @Override
322       public void before() throws Exception {
323         toggleBreakpoint(getFilePath(getScriptName()), 18);
324         toggleBreakpoint(getFilePath(getScriptName()), 25);
325       }
326
327       @Override
328       public void testing() throws Exception {
329         waitForPause();
330         toggleBreakpoint(getFilePath(getScriptName()), 18);
331         smartStepInto("foo");
332         waitForPause();
333         eval("a.z").hasValue("1");
334       }
335     });
336   }
337
338   @Test
339   public void testInput() throws Exception {
340     runPythonTest(new PyDebuggerTask("/debug", "test_input.py") {
341
342       @Override
343       public void testing() throws Exception {
344         waitForOutput("print command >");
345         input("GO!");
346         waitForOutput("command was GO!");
347       }
348
349       @NotNull
350       @Override
351       public Set<String> getTags() {
352         return ImmutableSet.of("-jython"); //can't run on jython
353       }
354     });
355   }
356
357   @Test
358   @StagingOn(os = TestEnv.WINDOWS)
359   public void testRunToLine() throws Exception {
360     runPythonTest(new PyDebuggerTask("/debug", "test_runtoline.py") {
361       @Override
362       public void before() throws Exception {
363         toggleBreakpoint(getFilePath(getScriptName()), 3);
364         toggleBreakpoint(getFilePath(getScriptName()), 9);
365       }
366
367       @Override
368       public void testing() throws Exception {
369         waitForPause();
370         eval("x").hasValue("0");
371         runToLine(6);
372         eval("x").hasValue("1");
373         resume();
374         waitForPause();
375         eval("x").hasValue("12");
376         resume();
377
378         waitForOutput("x = 12");
379       }
380     });
381   }
382
383   private static void addExceptionBreakpoint(IdeaProjectTestFixture fixture, PyExceptionBreakpointProperties properties) {
384     XDebuggerTestUtil.addBreakpoint(fixture.getProject(), PyExceptionBreakpointType.class, properties);
385   }
386
387   @Test
388   public void testExceptionBreakpointOnTerminate() throws Exception {
389     runPythonTest(new PyDebuggerTask("/debug", "test_exceptbreak.py") {
390       @Override
391       public void before() throws Exception {
392         createExceptionBreakZeroDivisionError(myFixture, true, false, false);
393       }
394
395       @Override
396       public void testing() throws Exception {
397         waitForPause();
398         eval("__exception__[0].__name__").hasValue("'ZeroDivisionError'");
399         resume();
400         waitForTerminate();
401       }
402
403       @NotNull
404       @Override
405       public Set<String> getTags() {
406         return ImmutableSet.of("-iron");
407       }
408     });
409   }
410
411   private static void createExceptionBreakZeroDivisionError(IdeaProjectTestFixture fixture,
412                                                             boolean notifyOnTerminate,
413                                                             boolean notifyOnFirst,
414                                                             boolean ignoreLibraries) {
415     XDebuggerTestUtil.removeAllBreakpoints(fixture.getProject());
416     XDebuggerTestUtil.setDefaultBreakpointEnabled(fixture.getProject(), PyExceptionBreakpointType.class, false);
417
418     PyExceptionBreakpointProperties properties = new PyExceptionBreakpointProperties("exceptions.ZeroDivisionError");
419     properties.setNotifyOnTerminate(notifyOnTerminate);
420     properties.setNotifyOnlyOnFirst(notifyOnFirst);
421     properties.setIgnoreLibraries(ignoreLibraries);
422     addExceptionBreakpoint(fixture, properties);
423     properties = new PyExceptionBreakpointProperties("builtins.ZeroDivisionError"); //for python 3
424     properties.setNotifyOnTerminate(notifyOnTerminate);
425     properties.setNotifyOnlyOnFirst(notifyOnFirst);
426     properties.setIgnoreLibraries(ignoreLibraries);
427     addExceptionBreakpoint(fixture, properties);
428   }
429
430   @Test
431   public void testExceptionBreakpointOnFirstRaise() throws Exception {
432     runPythonTest(new PyDebuggerTask("/debug", "test_exceptbreak.py") {
433       @Override
434       public void before() throws Exception {
435         createExceptionBreakZeroDivisionError(myFixture, false, true, false);
436       }
437
438       @Override
439       public void testing() throws Exception {
440         waitForPause();
441         eval("__exception__[0].__name__").hasValue("'ZeroDivisionError'");
442         resume();
443         waitForTerminate();
444       }
445
446       @NotNull
447       @Override
448       public Set<String> getTags() {
449         return ImmutableSet.of("-iron");
450       }
451     });
452   }
453
454   public static void createExceptionBreak(IdeaProjectTestFixture fixture,
455                                           boolean notifyOnTerminate,
456                                           boolean notifyOnFirst,
457                                           boolean ignoreLibraries) {
458     XDebuggerTestUtil.removeAllBreakpoints(fixture.getProject());
459     XDebuggerTestUtil.setDefaultBreakpointEnabled(fixture.getProject(), PyExceptionBreakpointType.class, false);
460
461     PyExceptionBreakpointProperties properties = new PyExceptionBreakpointProperties("BaseException");
462     properties.setNotifyOnTerminate(notifyOnTerminate);
463     properties.setNotifyOnlyOnFirst(notifyOnFirst);
464     properties.setIgnoreLibraries(ignoreLibraries);
465     addExceptionBreakpoint(fixture, properties);
466   }
467
468   @Test
469   public void testExceptionBreakpointIgnoreLibrariesOnRaise() throws Exception {
470     runPythonTest(new PyDebuggerTask("/debug", "test_ignore_lib.py") {
471
472       @Override
473       public void before() throws Exception {
474         createExceptionBreak(myFixture, false, true, true);
475       }
476
477       @Override
478       public void testing() throws Exception {
479         waitForPause();
480         eval("stopped_in_user_file").hasValue("True");
481         resume();
482         waitForTerminate();
483       }
484
485       @NotNull
486       @Override
487       public Set<String> getTags() {
488         return ImmutableSet.of("-jython");
489       }
490     });
491   }
492
493   @Test
494   public void testExceptionBreakpointIgnoreLibrariesOnTerminate() throws Exception {
495     runPythonTest(new PyDebuggerTask("/debug", "test_ignore_lib.py") {
496
497       @Override
498       public void before() throws Exception {
499         createExceptionBreak(myFixture, true, false, true);
500       }
501
502       @Override
503       public void testing() throws Exception {
504         waitForPause();
505         eval("stopped_in_user_file").hasValue("True");
506         resume();
507         waitForTerminate();
508       }
509
510       @NotNull
511       @Override
512       public Set<String> getTags() {
513         return ImmutableSet.of("-iron");
514       }
515     });
516   }
517
518   @Test
519   public void testMultithreading() throws Exception {
520     runPythonTest(new PyDebuggerTask("/debug", "test_multithread.py") {
521       @Override
522       public void before() throws Exception {
523         toggleBreakpoint(getFilePath(getScriptName()), 10);
524         toggleBreakpoint(getFilePath(getScriptName()), 16);
525       }
526
527       @Override
528       public void testing() throws Exception {
529         waitForPause();
530         eval("y").hasValue("2");
531         resume();
532         waitForPause();
533         eval("z").hasValue("102");
534         resume();
535       }
536
537       @NotNull
538       @Override
539       public Set<String> getTags() {
540         return ImmutableSet.of("-pypy"); //TODO: fix that for PyPy
541       }
542     });
543   }
544
545   @Test
546   @StagingOn(os = TestEnv.WINDOWS)
547   public void testEggDebug() throws Exception {
548     runPythonTest(new PyDebuggerTask("/debug", "test_egg.py") {
549       @Override
550       public void before() throws Exception {
551         String egg = getFilePath("Adder-0.1.egg");
552         toggleBreakpointInEgg(egg, "adder/adder.py", 2);
553         PythonSdkFlavor flavor = PythonSdkFlavor.getFlavor(getRunConfiguration().getSdkHome());
554         if (flavor != null) {
555           flavor.initPythonPath(Lists.newArrayList(egg), getRunConfiguration().getEnvs());
556         }
557         else {
558           getRunConfiguration().getEnvs().put("PYTHONPATH", egg);
559         }
560       }
561
562       @Override
563       public void testing() throws Exception {
564         waitForPause();
565         eval("ret").hasValue("16");
566         resume();
567       }
568
569       @NotNull
570       @Override
571       public Set<String> getTags() {
572         return ImmutableSet.of("-jython"); //TODO: fix that for Jython if anybody needs it
573       }
574     });
575   }
576
577
578   @Test
579   public void testWinEggDebug() throws Exception {
580     if (UsefulTestCase.IS_UNDER_TEAMCITY && !SystemInfo.isWindows) {
581       return; // Only needs to run on windows
582     }
583     runPythonTest(new PyDebuggerTask("/debug", "test_winegg.py") {
584       @Override
585       public void before() throws Exception {
586         String egg = getFilePath("wintestegg-0.1.egg");
587         toggleBreakpointInEgg(egg, "eggxample/lower_case.py", 2);
588         toggleBreakpointInEgg(egg, "eggxample/MIXED_case.py", 2);
589
590         PythonSdkFlavor flavor = PythonSdkFlavor.getFlavor(getRunConfiguration().getSdkHome());
591         if (flavor != null) {
592           flavor.initPythonPath(Lists.newArrayList(egg), getRunConfiguration().getEnvs());
593         }
594         else {
595           getRunConfiguration().getEnvs().put("PYTHONPATH", egg);
596         }
597       }
598
599       @Override
600       public void testing() throws Exception {
601         waitForPause();
602         eval("ret").hasValue("16");
603         resume();
604
605         waitForPause();
606         eval("ret").hasValue("17");
607         resume();
608       }
609
610       @NotNull
611       @Override
612       public Set<String> getTags() {
613         return ImmutableSet.of("-jython"); //TODO: fix that for Jython if anybody needs it
614       }
615     });
616   }
617
618   @Test
619   @StagingOn(os = TestEnv.WINDOWS)
620   public void testWinLongName() throws Exception {
621     if (UsefulTestCase.IS_UNDER_TEAMCITY && !SystemInfo.isWindows) {
622       return; // Only needs to run on windows
623     }
624     runPythonTest(new PyDebuggerTask("/debug", "long_n~1.py") {
625       @Override
626       public void before() throws Exception {
627         String scriptPath = getScriptName();
628         String longPath = FileUtil
629           .toSystemDependentName((new File(scriptPath).getCanonicalPath()));
630         LocalFileSystem.getInstance().refreshAndFindFileByPath(longPath);
631         toggleBreakpoint(longPath, 2);
632       }
633
634       @Override
635       public void testing() throws Exception {
636         waitForPause();
637         eval("x").hasValue("10");
638         resume();
639       }
640
641       @NotNull
642       @Override
643       public Set<String> getTags() {
644         return ImmutableSet.of("-jython"); //TODO: fix that for Jython if anybody needs it
645       }
646     });
647   }
648
649
650   @Test
651   public void testStepOverConditionalBreakpoint() throws Exception {
652     runPythonTest(new PyDebuggerTask("/debug", "test_stepOverCondition.py") {
653       @Override
654       public void before() throws Exception {
655         toggleBreakpoint(getScriptName(), 1);
656         toggleBreakpoint(getScriptName(), 2);
657         XDebuggerTestUtil.setBreakpointCondition(getProject(), 2, "y == 3");
658       }
659
660       @Override
661       public void testing() throws Exception {
662         waitForPause();
663         stepOver();
664         waitForPause();
665         eval("y").hasValue("2");
666       }
667     });
668   }
669
670   @Test
671   public void testMultiprocess() throws Exception {
672     runPythonTest(new PyDebuggerTask("/debug", "test_multiprocess.py") {
673       @Override
674       protected void init() {
675         setMultiprocessDebug(true);
676       }
677
678       @Override
679       public void before() throws Exception {
680         toggleBreakpoint(getScriptName(), 9);
681       }
682
683       @Override
684       public void testing() throws Exception {
685         waitForPause();
686
687         eval("i").hasValue("'Result:OK'");
688
689         resume();
690
691         waitForOutput("Result:OK");
692       }
693
694       @NotNull
695       @Override
696       public Set<String> getTags() {
697         return Sets.newHashSet("python3");
698       }
699     });
700   }
701
702   @Test
703   @Staging
704   public void testMultiprocessingSubprocess() throws Exception {
705     runPythonTest(new PyDebuggerTask("/debug", "test_multiprocess_args.py") {
706       @Override
707       protected void init() {
708         setMultiprocessDebug(true);
709       }
710
711       @Override
712       public void before() throws Exception {
713         toggleBreakpoint(getFilePath("test_remote.py"), 2);
714       }
715
716       @Override
717       public void testing() throws Exception {
718         waitForPause();
719         eval("sys.argv[1]").hasValue("'subprocess'");
720         eval("sys.argv[2]").hasValue("'etc etc'");
721
722         resume();
723       }
724
725       @NotNull
726       @Override
727       public Set<String> getTags() {
728         return ImmutableSet.of("-iron", "-jython"); //can't run on iron and jython
729       }
730     });
731   }
732
733   @Test
734   @Staging
735   public void testPyQtQThreadInheritor() throws Exception {
736     if (UsefulTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) {
737       return; //Don't run under Windows
738     }
739
740     runPythonTest(new PyDebuggerTask("/debug", "test_pyqt1.py") {
741       @Override
742       protected void init() {
743         setMultiprocessDebug(true);
744       }
745
746       @Override
747       public void before() throws Exception {
748         toggleBreakpoint(getScriptName(), 8);
749       }
750
751       @Override
752       public void testing() throws Exception {
753
754         waitForPause();
755
756         eval("i").hasValue("0");
757
758         resume();
759
760         waitForPause();
761
762         eval("i").hasValue("1");
763
764         resume();
765       }
766
767       @NotNull
768       @Override
769       public Set<String> getTags() {
770         return Sets.newHashSet("pyqt5");
771       }
772     });
773   }
774
775   @Test
776   @Staging
777   public void testPyQtMoveToThread() throws Exception {
778     if (UsefulTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) {
779       return; //Don't run under Windows
780     }
781
782     runPythonTest(new PyDebuggerTask("/debug", "test_pyqt2.py") {
783       @Override
784       protected void init() {
785         setMultiprocessDebug(true);
786       }
787
788       @Override
789       public void before() throws Exception {
790         toggleBreakpoint(getScriptName(), 10);
791       }
792
793       @Override
794       public void testing() throws Exception {
795
796         waitForPause();
797
798         eval("i").hasValue("0");
799
800         resume();
801
802         waitForPause();
803
804         eval("i").hasValue("1");
805
806         resume();
807       }
808
809       @NotNull
810       @Override
811       public Set<String> getTags() {
812         return Sets.newHashSet("pyqt5");
813       }
814     });
815   }
816
817
818   @Test
819   @Staging
820   public void testPyQtQRunnableInheritor() throws Exception {
821     if (UsefulTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) {
822       return; //Don't run under Windows
823     }
824
825     runPythonTest(new PyDebuggerTask("/debug", "test_pyqt3.py") {
826       @Override
827       protected void init() {
828         setMultiprocessDebug(true);
829       }
830
831       @Override
832       public void before() throws Exception {
833         toggleBreakpoint(getScriptName(), 9);
834       }
835
836       @Override
837       public void testing() throws Exception {
838
839         waitForPause();
840
841         eval("i").hasValue("0");
842
843         resume();
844
845         waitForPause();
846
847         eval("i").hasValue("1");
848
849         resume();
850       }
851
852       @NotNull
853       @Override
854       public Set<String> getTags() {
855         return Sets.newHashSet("pyqt5");
856       }
857     });
858   }
859
860
861   @Test
862   public void testStepOverYieldFrom() throws Exception {
863     runPythonTest(new PyDebuggerTask("/debug", "test_step_over_yield.py") {
864       @Override
865       protected void init() {
866         setMultiprocessDebug(true);
867       }
868
869       @Override
870       public void before() throws Exception {
871         toggleBreakpoint(getScriptName(), 6);
872       }
873
874       @Override
875       public void testing() throws Exception {
876
877         waitForPause();
878
879         stepOver();
880
881         waitForPause();
882
883         eval("a").hasValue("42");
884
885         stepOver();
886
887         waitForPause();
888
889         eval("a").hasValue("42");
890
891         stepOver();
892
893         waitForPause();
894
895         eval("sum").hasValue("6");
896
897         resume();
898       }
899
900       @NotNull
901       @Override
902       public Set<String> getTags() {
903         return Sets.newHashSet("python34");
904       }
905     });
906   }
907
908   @Test
909   public void testSteppingFilter() throws Exception {
910     runPythonTest(new PyDebuggerTask("/debug", "test_stepping_filter.py") {
911
912       @Override
913       public void before() throws Exception {
914         toggleBreakpoint(getScriptName(), 4);
915         List<PySteppingFilter> filters = new ArrayList<>();
916         filters.add(new PySteppingFilter(true, "*/test_m?_code.py"));
917         final PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance();
918         debuggerSettings.setLibrariesFilterEnabled(true);
919         debuggerSettings.setSteppingFiltersEnabled(true);
920         debuggerSettings.setSteppingFilters(filters);
921       }
922
923       @Override
924       public void doFinally() {
925         final PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance();
926         debuggerSettings.setLibrariesFilterEnabled(false);
927         debuggerSettings.setSteppingFiltersEnabled(false);
928       }
929
930       @Override
931       public void testing() throws Exception {
932         waitForPause();
933         stepInto();
934         waitForPause();
935         eval("stopped_in_user_file").hasValue("True");
936         stepInto();
937         waitForPause();
938         eval("stopped_in_user_file").hasValue("True");
939       }
940     });
941   }
942
943   @Test
944   public void testReturnValues() throws Exception {
945     runPythonTest(new PyDebuggerTask("/debug", "test_return_values.py") {
946       @Override
947       public void before() throws Exception {
948         toggleBreakpoint(getScriptName(), 7);
949         toggleBreakpoint(getScriptName(), 11);
950         final PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance();
951         debuggerSettings.setWatchReturnValues(true);
952       }
953
954       @Override
955       public void doFinally() {
956         final PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance();
957         debuggerSettings.setWatchReturnValues(false);
958       }
959
960       @Override
961       public void testing() throws Exception {
962         waitForPause();
963         eval(PyDebugValue.RETURN_VALUES_PREFIX + "['bar'][0]").hasValue("1");
964         resume();
965         waitForPause();
966         eval(PyDebugValue.RETURN_VALUES_PREFIX + "['foo']").hasValue("33");
967         resume();
968       }
969
970       @NotNull
971       @Override
972       public Set<String> getTags() {
973         return ImmutableSet.of("-iron");
974       }
975     });
976   }
977
978   @Test
979   @Staging
980   public void testSuspendAllThreadsPolicy() throws Exception {
981     runPythonTest(new PyDebuggerTask("/debug", "test_two_threads.py") {
982       @Override
983       protected void init() {
984         setMultiprocessDebug(true);
985       }
986
987       @Override
988       public void before() throws Exception {
989         toggleBreakpoint(getFilePath(getScriptName()), 12);
990         setBreakpointSuspendPolicy(getProject(), 12, SuspendPolicy.ALL);
991       }
992
993       @Override
994       public void testing() throws Exception {
995         waitForAllThreadsPause();
996         eval("m").hasValue("42");
997         assertNull(getRunningThread());
998         resume();
999       }
1000
1001       @NotNull
1002       @Override
1003       public Set<String> getTags() {
1004         return ImmutableSet.of("-iron");
1005       }
1006     });
1007   }
1008
1009   @Test
1010   @Staging
1011   public void testSuspendAllThreadsResume() throws Exception {
1012     runPythonTest(new PyDebuggerTask("/debug", "test_two_threads_resume.py") {
1013       @Override
1014       public void before() throws Exception {
1015         toggleBreakpoint(getFilePath(getScriptName()), 10);
1016         setBreakpointSuspendPolicy(getProject(), 10, SuspendPolicy.ALL);
1017       }
1018
1019       @Override
1020       public void testing() throws Exception {
1021         waitForPause();
1022         eval("x").hasValue("12");
1023         resume();
1024         waitForPause();
1025         eval("x").hasValue("12");
1026         resume();
1027       }
1028
1029       @NotNull
1030       @Override
1031       public Set<String> getTags() {
1032         return ImmutableSet.of("-iron");
1033       }
1034     });
1035   }
1036
1037   @Test
1038   @Staging
1039   public void testSuspendOneThreadPolicy() throws Exception {
1040     runPythonTest(new PyDebuggerTask("/debug", "test_two_threads.py") {
1041       @Override
1042       public void before() throws Exception {
1043         toggleBreakpoint(getFilePath(getScriptName()), 12);
1044         setBreakpointSuspendPolicy(getProject(), 12, SuspendPolicy.THREAD);
1045       }
1046
1047       @Override
1048       public void testing() throws Exception {
1049         waitForPause();
1050         eval("m").hasValue("42");
1051         assertEquals("Thread1", getRunningThread());
1052         resume();
1053       }
1054     });
1055   }
1056
1057   @Test
1058   @Staging
1059   public void testShowReferringObjects() throws Exception {
1060     runPythonTest(new PyDebuggerTask("/debug", "test_ref.py") {
1061       @Override
1062       public void before() throws Exception {
1063         toggleBreakpoint(getFilePath(getScriptName()), 3);
1064       }
1065
1066       @Override
1067       public void testing() throws Exception {
1068         waitForPause();
1069         int numberOfReferringObjects = getNumberOfReferringObjects("l");
1070         assertEquals(3, numberOfReferringObjects);
1071       }
1072
1073       @NotNull
1074       @Override
1075       public Set<String> getTags() {
1076         return ImmutableSet.of("-iron");
1077       }
1078     });
1079   }
1080
1081   @Staging
1082   @Test
1083   public void testResume() throws Exception {
1084     runPythonTest(new PyDebuggerTask("/debug", "test_resume.py") {
1085       @Override
1086       public void before() throws Exception {
1087         toggleBreakpoint(getScriptName(), 1);
1088       }
1089
1090       @Override
1091       public void testing() throws Exception {
1092         waitForPause();
1093         eval("x").hasValue("1");
1094         resume();
1095         waitForPause();
1096         eval("x").hasValue("2");
1097         resume();
1098       }
1099     });
1100   }
1101
1102
1103   //TODO: That doesn't work now: case from test_continuation.py and test_continuation2.py are treated differently by interpreter
1104   // (first line is executed in first case and last line in second)
1105
1106   @Staging
1107   @Test
1108   public void testBreakOnContinuationLine() throws Exception {
1109     runPythonTest(new PyDebuggerTask("/debug", "test_continuation.py") {
1110       @Override
1111       public void before() throws Exception {
1112         toggleBreakpoint(getScriptName(), 13);
1113       }
1114
1115       @Override
1116       public void testing() throws Exception {
1117         waitForPause();
1118         eval("x").hasValue("0");
1119         stepOver();
1120         waitForPause();
1121         eval("x").hasValue("1");
1122         stepOver();
1123         waitForPause();
1124         eval("x").hasValue("2");
1125       }
1126     });
1127   }
1128 }
1129