Env tests: added test for django conditional breakpoint.
[idea/community.git] / platform / xdebugger-impl / testSrc / com / intellij / xdebugger / XDebuggerTestUtil.java
1 /*
2  * Copyright 2000-2011 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.xdebugger;
17
18 import com.intellij.execution.impl.ConsoleViewImpl;
19 import com.intellij.openapi.application.ApplicationManager;
20 import com.intellij.openapi.application.Result;
21 import com.intellij.openapi.application.WriteAction;
22 import com.intellij.openapi.project.Project;
23 import com.intellij.openapi.util.Pair;
24 import com.intellij.openapi.util.Ref;
25 import com.intellij.openapi.vfs.VirtualFile;
26 import com.intellij.testFramework.UsefulTestCase;
27 import com.intellij.util.ui.UIUtil;
28 import com.intellij.xdebugger.breakpoints.*;
29 import com.intellij.xdebugger.evaluation.XDebuggerEvaluator;
30 import com.intellij.xdebugger.frame.*;
31 import com.intellij.xdebugger.impl.breakpoints.XBreakpointUtil;
32 import com.intellij.xdebugger.impl.breakpoints.XLineBreakpointImpl;
33 import com.intellij.xdebugger.ui.DebuggerIcons;
34 import junit.framework.Assert;
35 import org.jetbrains.annotations.NotNull;
36 import org.jetbrains.annotations.Nullable;
37
38 import java.lang.reflect.InvocationTargetException;
39 import java.util.*;
40 import java.util.concurrent.Semaphore;
41 import java.util.concurrent.TimeUnit;
42
43 public class XDebuggerTestUtil {
44   private static final int TIMEOUT = 25000;
45
46   private XDebuggerTestUtil() {
47   }
48
49   public static <B extends XBreakpoint<?>> void assertBreakpointValidity(Project project,
50                                                                          VirtualFile file,
51                                                                          int line,
52                                                                          boolean validity,
53                                                                          String errorMessage,
54                                                                          Class<? extends XBreakpointType<B, ?>> breakpointType) {
55     XLineBreakpointType type = (XLineBreakpointType)XDebuggerUtil.getInstance().findBreakpointType(breakpointType);
56     XBreakpointManager manager = XDebuggerManager.getInstance(project).getBreakpointManager();
57     XLineBreakpointImpl breakpoint = (XLineBreakpointImpl)manager.findBreakpointAtLine(type, file, line);
58     Assert.assertNotNull(breakpoint);
59     Assert.assertEquals(validity ? DebuggerIcons.VERIFIED_BREAKPOINT_ICON : DebuggerIcons.INVALID_BREAKPOINT_ICON, breakpoint.getIcon());
60     Assert.assertEquals(errorMessage, breakpoint.getErrorMessage());
61   }
62
63   public static void toggleBreakpoint(Project project, VirtualFile file, int line) {
64     XDebuggerUtil.getInstance().toggleLineBreakpoint(project, file, line);
65   }
66
67   public static void assertPosition(XSourcePosition pos, VirtualFile file, int line) {
68     Assert.assertNotNull(pos);
69     Assert.assertEquals(file, pos.getFile());
70     if (line != -1) Assert.assertEquals(line, pos.getLine());
71   }
72
73   public static void assertCurrentPosition(XDebugSession session, VirtualFile file, int line) {
74     assertPosition(session.getCurrentPosition(), file, line);
75   }
76
77   public static XExecutionStack getActiveThread(@NotNull XDebugSession session) {
78     return session.getSuspendContext().getActiveExecutionStack();
79   }
80
81   public static List<XStackFrame> collectStacks(@NotNull XDebugSession session) throws InterruptedException {
82     return collectStacks(null, session);
83   }
84
85   public static List<XStackFrame> collectStacks(@Nullable XExecutionStack thread, @NotNull XDebugSession session) throws InterruptedException {
86     return collectStacks(thread == null ? getActiveThread(session) : thread);
87   }
88
89   public static List<XStackFrame> collectStacks(@NotNull XExecutionStack thread) throws InterruptedException {
90     XTestStackFrameContainer container = new XTestStackFrameContainer();
91     thread.computeStackFrames(0, container);
92     return container.waitFor(TIMEOUT * 2).first;
93   }
94
95   public static Pair<XValue, String> evaluate(XDebugSession session, String expression) throws InterruptedException {
96     XDebuggerEvaluator evaluator = session.getCurrentStackFrame().getEvaluator();
97     XTestEvaluationCallback callback = new XTestEvaluationCallback();
98     evaluator.evaluate(expression, callback, session.getCurrentPosition());
99     return callback.waitFor(TIMEOUT);
100   }
101
102   public static void waitForSwing() throws InterruptedException, InvocationTargetException {
103     final com.intellij.util.concurrency.Semaphore s = new com.intellij.util.concurrency.Semaphore();
104     s.down();
105     ApplicationManager.getApplication().invokeLater(new Runnable() {
106       public void run() {
107         s.up();
108       }
109     });
110     s.waitForUnsafe();
111     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
112       public void run() {
113       }
114     });
115   }
116
117   @NotNull
118   public static XValue findVar(Collection<XValue> vars, String name) {
119     for (XValue each : vars) {
120       if (each instanceof XNamedValue) {
121         if (((XNamedValue)each).getName().equals(name)) return each;
122       }
123     }
124     throw new AssertionError("var '" + name + "' not found");
125   }
126
127   public static XTestValueNode computePresentation(@NotNull XValue value) throws InterruptedException {
128     XTestValueNode node = new XTestValueNode();
129     if (value instanceof XNamedValue) {
130       node.myName = ((XNamedValue)value).getName();
131     }
132     value.computePresentation(node, XValuePlace.TREE);
133     Assert.assertTrue(node.waitFor(TIMEOUT));
134     return node;
135   }
136
137   public static void assertVariable(XValue var,
138                                     @Nullable String name,
139                                     @Nullable String type,
140                                     @Nullable String value,
141                                     @Nullable Boolean hasChildren) throws InterruptedException {
142     XTestValueNode node = computePresentation(var);
143
144     Assert.assertEquals(name, node.myName);
145     if (type != null) Assert.assertEquals(type, node.myType);
146     if (value != null) Assert.assertEquals(value, node.myValue);
147     if (hasChildren != null) Assert.assertEquals((boolean)hasChildren, node.myHasChildren);
148   }
149
150   public static void assertVariableValue(XValue var, @Nullable String name, @Nullable String value) throws InterruptedException {
151     assertVariable(var, name, null, value, null);
152   }
153
154   public static void assertVariableValue(Collection<XValue> vars, @Nullable String name, @Nullable String value) throws InterruptedException {
155     assertVariableValue(findVar(vars, name), name, value);
156   }
157
158   public static void assertVariableValueMatches(Collection<XValue> vars, @Nullable String name, String valuePattern) throws InterruptedException {
159     assertVariableValueMatches(findVar(vars, name), name, valuePattern);
160   }
161
162   public static void assertVariableValueMatches(XValue var, String name, String valuePattern) throws InterruptedException {
163     XTestValueNode node = computePresentation(var);
164     Assert.assertEquals(name, node.myName);
165     Assert.assertTrue(node.myValue, node.myValue.matches(valuePattern));
166   }
167
168   public static void assertVariables(List<XValue> vars, String... names) throws InterruptedException {
169     List<String> expectedNames = new ArrayList<String>(Arrays.asList(names));
170
171     List<String> actualNames = new ArrayList<String>();
172     for (XValue each : vars) {
173       actualNames.add(computePresentation(each).myName);
174     }
175
176     Collections.sort(actualNames);
177     Collections.sort(expectedNames);
178     UsefulTestCase.assertOrderedEquals(actualNames, expectedNames);
179   }
180
181   public static void assertSourcePosition(final XValue value, VirtualFile file, int offset) {
182     final XTestNavigatable n = new XTestNavigatable();
183     ApplicationManager.getApplication().runReadAction(new Runnable() {
184       @Override
185       public void run() {
186         value.computeSourcePosition(n);
187       }
188     });
189     Assert.assertNotNull(n.myPosition);
190     Assert.assertEquals(file, n.myPosition.getFile());
191     Assert.assertEquals(offset, n.myPosition.getOffset());
192   }
193
194   public static boolean waitFor(Semaphore semaphore, long timeoutInMillis) throws InterruptedException {
195     return semaphore.tryAcquire(timeoutInMillis, TimeUnit.MILLISECONDS);
196   }
197
198   public static void assertVariable(Collection<XValue> vars, String name, String type, String value, Boolean hasChildren)
199     throws InterruptedException {
200     assertVariable(findVar(vars, name), name, type, value, hasChildren);
201   }
202
203   @NotNull
204   public static String getConsoleText(final @NotNull ConsoleViewImpl consoleView) {
205     new WriteAction() {
206       protected void run(Result result) throws Throwable {
207         consoleView.flushDeferredText();
208       }
209     }.execute();
210
211     return consoleView.getEditor().getDocument().getText();
212   }
213
214   public static <T extends XBreakpointType> XBreakpoint addBreakpoint(@NotNull final Project project,
215                                                                @NotNull final Class<T> exceptionType,
216                                                                @NotNull final XBreakpointProperties properties) {
217     final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
218     XBreakpointType[] types = XBreakpointUtil.getBreakpointTypes();
219     final Ref<XBreakpoint> breakpoint = Ref.create(null);
220     for (XBreakpointType type : types) {
221       if (exceptionType.isInstance(type)) {
222         final T breakpointType = exceptionType.cast(type);
223         new WriteAction() {
224           @Override
225           protected void run(Result result) throws Throwable {
226             breakpoint.set(breakpointManager.addBreakpoint(breakpointType, properties));
227           }
228         }.execute();
229         break;
230       }
231     }
232     return breakpoint.get();
233   }
234
235   public static void setBreakpointCondition(Project project, int line, final String condition) {
236     XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
237     for (XBreakpoint breakpoint : breakpointManager.getAllBreakpoints()) {
238       if (breakpoint instanceof XLineBreakpoint) {
239         final XLineBreakpoint lineBreakpoint = (XLineBreakpoint)breakpoint;
240
241         if (lineBreakpoint.getLine() == line) {
242           new WriteAction() {
243             @Override
244             protected void run(Result result) throws Throwable {
245               lineBreakpoint.setCondition(condition);
246             }
247           }.execute();
248         }
249       }
250     }
251   }
252
253   public static class XTestStackFrameContainer extends XTestContainer<XStackFrame> implements XExecutionStack.XStackFrameContainer {
254     public void addStackFrames(@NotNull List<? extends XStackFrame> stackFrames, boolean last) {
255       addChildren(stackFrames, last);
256     }
257
258     public void errorOccured(String errorMessage) {
259       setErrorMessage(errorMessage);
260     }
261   }
262
263   public static class XTestNavigatable implements XNavigatable {
264     private XSourcePosition myPosition;
265
266     @Override
267     public void setSourcePosition(@Nullable XSourcePosition sourcePosition) {
268       myPosition = sourcePosition;
269     }
270
271     public XSourcePosition getPosition() {
272       return myPosition;
273     }
274   }
275 }