bba37ad71587c89c63ea8586d532fc74d8d5ba2b
[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.vfs.VirtualFile;
25 import com.intellij.testFramework.UsefulTestCase;
26 import com.intellij.util.ui.UIUtil;
27 import com.intellij.xdebugger.breakpoints.XBreakpoint;
28 import com.intellij.xdebugger.breakpoints.XBreakpointManager;
29 import com.intellij.xdebugger.breakpoints.XBreakpointType;
30 import com.intellij.xdebugger.breakpoints.XLineBreakpointType;
31 import com.intellij.xdebugger.evaluation.XDebuggerEvaluator;
32 import com.intellij.xdebugger.frame.*;
33 import com.intellij.xdebugger.impl.breakpoints.XLineBreakpointImpl;
34 import com.intellij.xdebugger.ui.DebuggerIcons;
35 import junit.framework.Assert;
36 import org.jetbrains.annotations.NotNull;
37 import org.jetbrains.annotations.Nullable;
38
39 import java.lang.reflect.InvocationTargetException;
40 import java.util.*;
41 import java.util.concurrent.Semaphore;
42 import java.util.concurrent.TimeUnit;
43
44 public class XDebuggerTestUtil {
45   private static final int TIMEOUT = 25000;
46
47   private XDebuggerTestUtil() {
48   }
49
50   public static <B extends XBreakpoint<?>> void assertBreakpointValidity(Project project,
51                                                                          VirtualFile file,
52                                                                          int line,
53                                                                          boolean validity,
54                                                                          String errorMessage,
55                                                                          Class<? extends XBreakpointType<B, ?>> breakpointType) {
56     XLineBreakpointType type = (XLineBreakpointType)XDebuggerUtil.getInstance().findBreakpointType(breakpointType);
57     XBreakpointManager manager = XDebuggerManager.getInstance(project).getBreakpointManager();
58     XLineBreakpointImpl breakpoint = (XLineBreakpointImpl)manager.findBreakpointAtLine(type, file, line);
59     Assert.assertNotNull(breakpoint);
60     Assert.assertEquals(validity ? DebuggerIcons.VERIFIED_BREAKPOINT_ICON : DebuggerIcons.INVALID_BREAKPOINT_ICON, breakpoint.getIcon());
61     Assert.assertEquals(errorMessage, breakpoint.getErrorMessage());
62   }
63
64   public static void toggleBreakpoint(Project project, VirtualFile file, int line) {
65     XDebuggerUtil.getInstance().toggleLineBreakpoint(project, file, line);
66   }
67
68   public static void assertPosition(XSourcePosition pos, VirtualFile file, int line) {
69     Assert.assertNotNull(pos);
70     Assert.assertEquals(file, pos.getFile());
71     if (line != -1) Assert.assertEquals(line, pos.getLine());
72   }
73
74   public static void assertCurrentPosition(XDebugSession session, VirtualFile file, int line) {
75     assertPosition(session.getCurrentPosition(), file, line);
76   }
77
78   public static XExecutionStack getActiveThread(@NotNull XDebugSession session) {
79     return session.getSuspendContext().getActiveExecutionStack();
80   }
81
82   public static List<XStackFrame> collectStacks(@NotNull XDebugSession session) throws InterruptedException {
83     return collectStacks(null, session);
84   }
85
86   public static List<XStackFrame> collectStacks(@Nullable XExecutionStack thread, @NotNull XDebugSession session) throws InterruptedException {
87     return collectStacks(thread == null ? getActiveThread(session) : thread);
88   }
89
90   public static List<XStackFrame> collectStacks(@NotNull XExecutionStack thread) throws InterruptedException {
91     XTestStackFrameContainer container = new XTestStackFrameContainer();
92     thread.computeStackFrames(0, container);
93     return container.waitFor(TIMEOUT * 2).first;
94   }
95
96   public static Pair<XValue, String> evaluate(XDebugSession session, String expression) throws InterruptedException {
97     XDebuggerEvaluator evaluator = session.getCurrentStackFrame().getEvaluator();
98     XTestEvaluationCallback callback = new XTestEvaluationCallback();
99     evaluator.evaluate(expression, callback, session.getCurrentPosition());
100     return callback.waitFor(TIMEOUT);
101   }
102
103   public static void waitForSwing() throws InterruptedException, InvocationTargetException {
104     final com.intellij.util.concurrency.Semaphore s = new com.intellij.util.concurrency.Semaphore();
105     s.down();
106     ApplicationManager.getApplication().invokeLater(new Runnable() {
107       public void run() {
108         s.up();
109       }
110     });
111     s.waitForUnsafe();
112     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
113       public void run() {
114       }
115     });
116   }
117
118   @NotNull
119   public static XValue findVar(Collection<XValue> vars, String name) {
120     for (XValue each : vars) {
121       if (each instanceof XNamedValue) {
122         if (((XNamedValue)each).getName().equals(name)) return each;
123       }
124     }
125     throw new AssertionError("var '" + name + "' not found");
126   }
127
128   public static XTestValueNode computePresentation(@NotNull XValue value) throws InterruptedException {
129     XTestValueNode node = new XTestValueNode();
130     if (value instanceof XNamedValue) {
131       node.myName = ((XNamedValue)value).getName();
132     }
133     value.computePresentation(node, XValuePlace.TREE);
134     Assert.assertTrue(node.waitFor(TIMEOUT));
135     return node;
136   }
137
138   public static void assertVariable(XValue var,
139                                     @Nullable String name,
140                                     @Nullable String type,
141                                     @Nullable String value,
142                                     @Nullable Boolean hasChildren) throws InterruptedException {
143     XTestValueNode node = computePresentation(var);
144
145     Assert.assertEquals(name, node.myName);
146     if (type != null) Assert.assertEquals(type, node.myType);
147     if (value != null) Assert.assertEquals(value, node.myValue);
148     if (hasChildren != null) Assert.assertEquals((boolean)hasChildren, node.myHasChildren);
149   }
150
151   public static void assertVariableValue(XValue var, @Nullable String name, @Nullable String value) throws InterruptedException {
152     assertVariable(var, name, null, value, null);
153   }
154
155   public static void assertVariableValue(Collection<XValue> vars, @Nullable String name, @Nullable String value) throws InterruptedException {
156     assertVariableValue(findVar(vars, name), name, value);
157   }
158
159   public static void assertVariableValueMatches(Collection<XValue> vars, @Nullable String name, String valuePattern) throws InterruptedException {
160     assertVariableValueMatches(findVar(vars, name), name, valuePattern);
161   }
162
163   public static void assertVariableValueMatches(XValue var, String name, String valuePattern) throws InterruptedException {
164     XTestValueNode node = computePresentation(var);
165     Assert.assertEquals(name, node.myName);
166     Assert.assertTrue(node.myValue, node.myValue.matches(valuePattern));
167   }
168
169   public static void assertVariables(List<XValue> vars, String... names) throws InterruptedException {
170     List<String> expectedNames = new ArrayList<String>(Arrays.asList(names));
171
172     List<String> actualNames = new ArrayList<String>();
173     for (XValue each : vars) {
174       actualNames.add(computePresentation(each).myName);
175     }
176
177     Collections.sort(actualNames);
178     Collections.sort(expectedNames);
179     UsefulTestCase.assertOrderedEquals(actualNames, expectedNames);
180   }
181
182   public static void assertSourcePosition(final XValue value, VirtualFile file, int offset) {
183     final XTestNavigatable n = new XTestNavigatable();
184     ApplicationManager.getApplication().runReadAction(new Runnable() {
185       @Override
186       public void run() {
187         value.computeSourcePosition(n);
188       }
189     });
190     Assert.assertNotNull(n.myPosition);
191     Assert.assertEquals(file, n.myPosition.getFile());
192     Assert.assertEquals(offset, n.myPosition.getOffset());
193   }
194
195   public static boolean waitFor(Semaphore semaphore, long timeoutInMillis) throws InterruptedException {
196     return semaphore.tryAcquire(timeoutInMillis, TimeUnit.MILLISECONDS);
197   }
198
199   public static void assertVariable(Collection<XValue> vars, String name, String type, String value, Boolean hasChildren)
200     throws InterruptedException {
201     assertVariable(findVar(vars, name), name, type, value, hasChildren);
202   }
203
204   @NotNull
205   public static String getConsoleText(final @NotNull ConsoleViewImpl consoleView) {
206     new WriteAction() {
207       protected void run(Result result) throws Throwable {
208         consoleView.flushDeferredText();
209       }
210     }.execute();
211
212     return consoleView.getEditor().getDocument().getText();
213   }
214
215   public static class XTestStackFrameContainer extends XTestContainer<XStackFrame> implements XExecutionStack.XStackFrameContainer {
216     public void addStackFrames(@NotNull List<? extends XStackFrame> stackFrames, boolean last) {
217       addChildren(stackFrames, last);
218     }
219
220     public void errorOccured(String errorMessage) {
221       setErrorMessage(errorMessage);
222     }
223   }
224
225   public static class XTestNavigatable implements XNavigatable {
226     private XSourcePosition myPosition;
227
228     @Override
229     public void setSourcePosition(@Nullable XSourcePosition sourcePosition) {
230       myPosition = sourcePosition;
231     }
232
233     public XSourcePosition getPosition() {
234       return myPosition;
235     }
236   }
237 }