Commit | Line | Data |
---|---|---|
fa24d78b | 1 | /******************************************************************************* |
3553c912 | 2 | * Copyright (c) 2013, 2016 Ericsson |
fa24d78b AM |
3 | * |
4 | * All rights reserved. This program and the accompanying materials are | |
5 | * made available under the terms of the Eclipse Public License v1.0 which | |
6 | * accompanies this distribution, and is available at | |
7 | * http://www.eclipse.org/legal/epl-v10.html | |
8 | * | |
9 | * Contributors: | |
10 | * Matthew Khouzam - Initial API and implementation | |
11 | * Alexandre Montplaisir - Replaced separate Condition objects by anonymous classes | |
88051e61 | 12 | * Patrick Tasse - Add projectElementHasChild and isEditorOpened conditions |
fa24d78b AM |
13 | *******************************************************************************/ |
14 | ||
15 | package org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared; | |
16 | ||
88051e61 PT |
17 | import static org.eclipse.swtbot.eclipse.finder.matchers.WidgetMatcherFactory.withPartName; |
18 | ||
46958d08 | 19 | import java.util.Arrays; |
e834a6b4 | 20 | import java.util.List; |
46958d08 | 21 | |
156e9ead | 22 | import org.eclipse.jdt.annotation.NonNull; |
573087b4 | 23 | import org.eclipse.jface.viewers.StructuredSelection; |
fa24d78b AM |
24 | import org.eclipse.jface.wizard.IWizardContainer; |
25 | import org.eclipse.jface.wizard.IWizardPage; | |
26 | import org.eclipse.jface.wizard.Wizard; | |
21e5206c | 27 | import org.eclipse.osgi.util.NLS; |
88051e61 | 28 | import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot; |
e834a6b4 | 29 | import org.eclipse.swtbot.eclipse.finder.matchers.WidgetMatcherFactory; |
573087b4 | 30 | import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor; |
fa24d78b AM |
31 | import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView; |
32 | import org.eclipse.swtbot.swt.finder.SWTBot; | |
573087b4 MAL |
33 | import org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable; |
34 | import org.eclipse.swtbot.swt.finder.results.Result; | |
6e4a07af | 35 | import org.eclipse.swtbot.swt.finder.utils.TableCollection; |
21e5206c | 36 | import org.eclipse.swtbot.swt.finder.waits.DefaultCondition; |
fa24d78b AM |
37 | import org.eclipse.swtbot.swt.finder.waits.ICondition; |
38 | import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable; | |
39 | import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree; | |
40 | import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem; | |
573087b4 | 41 | import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; |
156e9ead | 42 | import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp; |
2fe6a9ea | 43 | import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange; |
e834a6b4 | 44 | import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace; |
2fe6a9ea | 45 | import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager; |
573087b4 | 46 | import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor; |
156e9ead | 47 | import org.eclipse.tracecompass.tmf.ui.views.timegraph.AbstractTimeGraphView; |
88051e61 PT |
48 | import org.eclipse.ui.IEditorReference; |
49 | import org.hamcrest.Matcher; | |
aa5b9bd6 | 50 | import org.swtchart.Chart; |
fa24d78b AM |
51 | |
52 | /** | |
53 | * Is a tree node available | |
54 | * | |
55 | * @author Matthew Khouzam | |
56 | */ | |
57 | public final class ConditionHelpers { | |
58 | ||
59 | private ConditionHelpers() {} | |
60 | ||
61 | /** | |
62 | * Provide default implementations for some {@link ICondition} methods. | |
63 | */ | |
2e65d221 | 64 | public abstract static class SWTBotTestCondition implements ICondition { |
fa24d78b AM |
65 | |
66 | @Override | |
67 | public abstract boolean test() throws Exception; | |
68 | ||
69 | @Override | |
70 | public final void init(SWTBot bot) { | |
71 | } | |
72 | ||
73 | @Override | |
2fe6a9ea | 74 | public String getFailureMessage() { |
fa24d78b AM |
75 | return null; |
76 | } | |
77 | } | |
78 | ||
79 | /** | |
80 | * Is a tree node available | |
81 | * | |
82 | * @param name | |
83 | * the name of the node | |
84 | * @param tree | |
85 | * the parent tree | |
86 | * @return true or false, it should swallow all exceptions | |
87 | */ | |
88 | public static ICondition IsTreeNodeAvailable(final String name, final SWTBotTree tree) { | |
89 | return new SWTBotTestCondition() { | |
90 | @Override | |
91 | public boolean test() throws Exception { | |
92 | try { | |
93 | final SWTBotTreeItem[] treeItems = tree.getAllItems(); | |
94 | for (SWTBotTreeItem ti : treeItems) { | |
95 | final String text = ti.getText(); | |
96 | if (text.equals(name)) { | |
97 | return true; | |
98 | } | |
99 | } | |
100 | } catch (Exception e) { | |
101 | } | |
102 | return false; | |
103 | } | |
46958d08 PT |
104 | |
105 | @Override | |
106 | public String getFailureMessage() { | |
3553c912 | 107 | return NLS.bind("No child of tree {0} found with text {1}. Child items: {2}", |
46958d08 PT |
108 | new String[] { tree.toString(), name, Arrays.toString(tree.getAllItems()) }); |
109 | } | |
fa24d78b AM |
110 | }; |
111 | } | |
112 | ||
bbdb3d6d MAL |
113 | /** |
114 | * Is a table item available | |
115 | * | |
116 | * @param name | |
117 | * the name of the item | |
118 | * @param table | |
119 | * the parent table | |
120 | * @return true or false, it should swallow all exceptions | |
121 | */ | |
122 | public static ICondition isTableItemAvailable(final String name, final SWTBotTable table) { | |
123 | return new SWTBotTestCondition() { | |
124 | @Override | |
125 | public boolean test() throws Exception { | |
126 | try { | |
127 | return table.containsItem(name); | |
128 | } catch (Exception e) { | |
129 | } | |
130 | return false; | |
131 | } | |
46958d08 PT |
132 | |
133 | @Override | |
134 | public String getFailureMessage() { | |
135 | return NLS.bind("No child of table {0} found with text '{1}'.", table, name); | |
136 | } | |
bbdb3d6d MAL |
137 | }; |
138 | } | |
139 | ||
fa24d78b AM |
140 | /** |
141 | * Is the treeItem's node available | |
142 | * | |
143 | * @param name | |
144 | * the name of the node | |
145 | * @param treeItem | |
146 | * the treeItem | |
147 | * @return true or false, it should swallow all exceptions | |
148 | */ | |
149 | public static ICondition IsTreeChildNodeAvailable(final String name, final SWTBotTreeItem treeItem) { | |
150 | return new SWTBotTestCondition() { | |
151 | @Override | |
152 | public boolean test() throws Exception { | |
153 | try { | |
154 | return treeItem.getNode(name) != null; | |
155 | } catch (Exception e) { | |
156 | } | |
157 | return false; | |
158 | } | |
46958d08 PT |
159 | |
160 | @Override | |
161 | public String getFailureMessage() { | |
162 | return NLS.bind("No child of tree item {0} found with text '{1}'. Child items: {2}", | |
163 | new String[] { treeItem.toString(), name, Arrays.toString(treeItem.getItems()) }); | |
164 | } | |
fa24d78b AM |
165 | }; |
166 | } | |
167 | ||
2e65d221 BH |
168 | /** |
169 | * Is the treeItem's node removed | |
170 | * | |
171 | * @param length | |
172 | * length of the node after removal | |
173 | * @param treeItem | |
174 | * the treeItem | |
175 | * @return true or false, it should swallow all exceptions | |
176 | */ | |
177 | public static ICondition isTreeChildNodeRemoved(final int length, final SWTBotTreeItem treeItem) { | |
178 | return new SWTBotTestCondition() { | |
179 | @Override | |
180 | public boolean test() throws Exception { | |
181 | try { | |
182 | return treeItem.getNodes().size() == length; | |
183 | } catch (Exception e) { | |
184 | } | |
185 | return false; | |
186 | } | |
187 | ||
188 | @Override | |
189 | public String getFailureMessage() { | |
190 | return NLS.bind("Child of tree item {0} found with text '{1}' not removed. Child items: {2}", | |
191 | new String[] { treeItem.toString(), String.valueOf(length), Arrays.toString(treeItem.getItems()) }); | |
192 | } | |
193 | }; | |
194 | } | |
195 | ||
3553c912 PT |
196 | /** |
197 | * Condition to check if the number of direct children of the | |
198 | * provided tree item equals the specified count. | |
199 | * | |
200 | * @param treeItem | |
201 | * the SWTBot tree item | |
202 | * @param count | |
203 | * the expected count | |
204 | * @return ICondition for verification | |
205 | */ | |
206 | public static ICondition treeItemCount(final SWTBotTreeItem treeItem, int count) { | |
207 | return new SWTBotTestCondition() { | |
208 | @Override | |
209 | public boolean test() throws Exception { | |
210 | return treeItem.rowCount() == count; | |
211 | } | |
212 | ||
213 | @Override | |
214 | public String getFailureMessage() { | |
215 | return NLS.bind("Tree item count: {0} expected: {1}", | |
216 | treeItem.rowCount(), count); | |
217 | } | |
218 | }; | |
219 | } | |
220 | ||
fa24d78b AM |
221 | /** |
222 | * Checks if the wizard's shell is null | |
223 | * | |
224 | * @param wizard | |
225 | * the null | |
226 | * @return false if either are null | |
227 | */ | |
228 | public static ICondition isWizardReady(final Wizard wizard) { | |
229 | return new SWTBotTestCondition() { | |
230 | @Override | |
231 | public boolean test() throws Exception { | |
232 | if (wizard.getShell() == null) { | |
233 | return false; | |
234 | } | |
235 | return true; | |
236 | } | |
237 | }; | |
238 | } | |
239 | ||
240 | /** | |
241 | * Is the wizard on the page you want? | |
242 | * | |
243 | * @param wizard | |
244 | * wizard | |
245 | * @param page | |
246 | * the desired page | |
247 | * @return true or false | |
248 | */ | |
249 | public static ICondition isWizardOnPage(final Wizard wizard, final IWizardPage page) { | |
250 | return new SWTBotTestCondition() { | |
251 | @Override | |
252 | public boolean test() throws Exception { | |
253 | if (wizard == null || page == null) { | |
254 | return false; | |
255 | } | |
256 | final IWizardContainer container = wizard.getContainer(); | |
257 | if (container == null) { | |
258 | return false; | |
259 | } | |
260 | IWizardPage currentPage = container.getCurrentPage(); | |
261 | return page.equals(currentPage); | |
262 | } | |
263 | }; | |
264 | } | |
265 | ||
266 | /** | |
267 | * Wait for a view to close | |
268 | * | |
269 | * @param view | |
270 | * bot view for the view | |
271 | * @return true if the view is closed, false if it's active. | |
272 | */ | |
273 | public static ICondition ViewIsClosed(final SWTBotView view) { | |
274 | return new SWTBotTestCondition() { | |
275 | @Override | |
276 | public boolean test() throws Exception { | |
277 | return (view != null) && (!view.isActive()); | |
278 | } | |
279 | }; | |
280 | } | |
281 | ||
282 | /** | |
283 | * Wait till table cell has a given content. | |
284 | * | |
285 | * @param table | |
286 | * the table bot reference | |
287 | * @param content | |
288 | * the content to check | |
289 | * @param row | |
290 | * the row of the cell | |
291 | * @param column | |
292 | * the column of the cell | |
293 | * @return ICondition for verification | |
294 | */ | |
295 | public static ICondition isTableCellFilled(final SWTBotTable table, | |
296 | final String content, final int row, final int column) { | |
297 | return new SWTBotTestCondition() { | |
298 | @Override | |
299 | public boolean test() throws Exception { | |
300 | try { | |
2470d687 MK |
301 | String cell = table.cell(row, column); |
302 | if( cell == null ) { | |
303 | return false; | |
304 | } | |
4d760144 | 305 | return cell.contains(content); |
fa24d78b AM |
306 | } catch (Exception e) { |
307 | } | |
308 | return false; | |
309 | } | |
310 | }; | |
311 | } | |
21e5206c PT |
312 | |
313 | /** | |
314 | * Condition to check if a tracing project element has a child with the | |
315 | * specified name. A project element label may have a count suffix in the | |
316 | * format ' [n]'. | |
317 | */ | |
318 | public static class ProjectElementHasChild extends DefaultCondition { | |
319 | ||
320 | private final SWTBotTreeItem fParentItem; | |
321 | private final String fName; | |
322 | private final String fRegex; | |
323 | private SWTBotTreeItem fItem = null; | |
324 | ||
325 | /** | |
326 | * Constructor. | |
327 | * | |
328 | * @param parentItem | |
329 | * the parent item | |
330 | * @param name | |
331 | * the child name to look for | |
332 | */ | |
333 | public ProjectElementHasChild(final SWTBotTreeItem parentItem, final String name) { | |
334 | fParentItem = parentItem; | |
335 | fName = name; | |
336 | /* Project element labels may have count suffix */ | |
337 | fRegex = name + "(\\s\\[(\\d)+\\])?"; | |
338 | } | |
339 | ||
340 | @Override | |
341 | public boolean test() throws Exception { | |
342 | fParentItem.expand(); | |
343 | for (SWTBotTreeItem item : fParentItem.getItems()) { | |
344 | if (item.getText().matches(fRegex)) { | |
345 | fItem = item; | |
346 | return true; | |
347 | } | |
348 | } | |
349 | return false; | |
350 | } | |
351 | ||
352 | @Override | |
353 | public String getFailureMessage() { | |
354 | return NLS.bind("No child of {0} found with name {1}", fParentItem.getText(), fName); | |
355 | } | |
356 | ||
357 | /** | |
358 | * Returns the matching child item if the condition returned true. | |
359 | * | |
360 | * @return the matching item | |
361 | */ | |
362 | public SWTBotTreeItem getItem() { | |
363 | return fItem; | |
364 | } | |
365 | } | |
88051e61 PT |
366 | |
367 | /** | |
368 | * Condition to check if an editor with the specified title is opened. | |
369 | * | |
370 | * @param bot | |
371 | * a workbench bot | |
372 | * @param title | |
373 | * the editor title | |
374 | * @return ICondition for verification | |
375 | */ | |
376 | public static ICondition isEditorOpened(final SWTWorkbenchBot bot, final String title) { | |
377 | return new SWTBotTestCondition() { | |
378 | @Override | |
379 | public boolean test() throws Exception { | |
380 | Matcher<IEditorReference> withPartName = withPartName(title); | |
381 | return !bot.editors(withPartName).isEmpty(); | |
382 | } | |
383 | }; | |
384 | } | |
2fe6a9ea PT |
385 | |
386 | /** | |
387 | * Condition to check if the selection range equals the specified range. | |
388 | * | |
389 | * @param range | |
390 | * the selection range | |
391 | * @return ICondition for verification | |
392 | */ | |
393 | public static ICondition selectionRange(final TmfTimeRange range) { | |
394 | return new SWTBotTestCondition() { | |
395 | @Override | |
396 | public boolean test() throws Exception { | |
397 | return TmfTraceManager.getInstance().getCurrentTraceContext().getSelectionRange().equals(range); | |
398 | } | |
399 | ||
400 | @Override | |
401 | public String getFailureMessage() { | |
402 | return NLS.bind("Selection range: {0} expected: {1}", | |
403 | TmfTraceManager.getInstance().getCurrentTraceContext().getSelectionRange(), range); | |
404 | } | |
405 | }; | |
406 | } | |
407 | ||
408 | /** | |
409 | * Condition to check if the window range equals the specified range. | |
410 | * | |
411 | * @param range | |
412 | * the window range | |
413 | * @return ICondition for verification | |
414 | */ | |
415 | public static ICondition windowRange(final TmfTimeRange range) { | |
416 | return new SWTBotTestCondition() { | |
417 | @Override | |
418 | public boolean test() throws Exception { | |
419 | return TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange().equals(range); | |
420 | } | |
421 | ||
422 | @Override | |
423 | public String getFailureMessage() { | |
424 | return NLS.bind("Window range: {0} expected: {1}", | |
425 | TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange(), range); | |
426 | } | |
427 | }; | |
428 | } | |
6e4a07af PT |
429 | |
430 | /** | |
431 | * Condition to check if the selection contains the specified text at the | |
432 | * specified column. The text is checked in any item of the tree selection. | |
433 | * | |
434 | * @param tree | |
435 | * the SWTBot tree | |
436 | * @param column | |
437 | * the column index | |
438 | * @param text | |
439 | * the expected text | |
440 | * @return ICondition for verification | |
441 | */ | |
442 | public static ICondition treeSelectionContains(final SWTBotTree tree, final int column, final String text) { | |
443 | return new SWTBotTestCondition() { | |
444 | @Override | |
445 | public boolean test() throws Exception { | |
446 | TableCollection selection = tree.selection(); | |
447 | for (int row = 0; row < selection.rowCount(); row++) { | |
448 | if (selection.get(row, column).equals(text)) { | |
449 | return true; | |
450 | } | |
451 | } | |
452 | return false; | |
453 | } | |
454 | ||
455 | @Override | |
456 | public String getFailureMessage() { | |
457 | return NLS.bind("Tree selection [0,{0}]: {1} expected: {2}", | |
458 | new Object[] { column, tree.selection().get(0, column), text}); | |
459 | } | |
460 | }; | |
461 | } | |
573087b4 MAL |
462 | |
463 | private static class EventsTableSelectionCondition extends DefaultCondition { | |
464 | private long fSelectionTime; | |
465 | private SWTWorkbenchBot fBot; | |
9bb4b61e | 466 | private long fCurValue; |
573087b4 MAL |
467 | |
468 | private EventsTableSelectionCondition(SWTWorkbenchBot bot, long selectionTime) { | |
469 | fBot = bot; | |
470 | fSelectionTime = selectionTime; | |
471 | } | |
472 | ||
473 | @Override | |
474 | public boolean test() throws Exception { | |
475 | StructuredSelection eventsTableSelection = getEventsTableSelection(); | |
476 | if (eventsTableSelection.isEmpty()) { | |
477 | return false; | |
478 | } | |
9bb4b61e MAL |
479 | fCurValue = ((ITmfEvent) eventsTableSelection.getFirstElement()).getTimestamp().getValue(); |
480 | return fCurValue == fSelectionTime; | |
573087b4 MAL |
481 | } |
482 | ||
483 | @Override | |
484 | public String getFailureMessage() { | |
9bb4b61e | 485 | return "The selection in the table was not an event with timestamp " + fSelectionTime + ". Actual is " + fCurValue; |
573087b4 MAL |
486 | } |
487 | ||
488 | private StructuredSelection getEventsTableSelection() { | |
489 | return UIThreadRunnable.syncExec(new Result<StructuredSelection>() { | |
490 | ||
491 | @Override | |
492 | public StructuredSelection run() { | |
493 | SWTBotEditor eventsEditor = SWTBotUtils.activeEventsEditor(fBot); | |
494 | TmfEventsEditor part = (TmfEventsEditor) eventsEditor.getReference().getPart(false); | |
495 | StructuredSelection selection = (StructuredSelection) part.getSelection(); | |
496 | return selection; | |
497 | } | |
498 | }); | |
499 | } | |
500 | } | |
501 | ||
502 | /** | |
503 | * Wait until the events table selection matches the specified time stamp. | |
504 | * | |
505 | * @param bot | |
506 | * a workbench bot | |
507 | * | |
508 | * @param selectionTime | |
509 | * the selection time | |
510 | * @return ICondition for verification | |
511 | */ | |
512 | public static ICondition selectionInEventsTable(final SWTWorkbenchBot bot, long selectionTime) { | |
513 | return new EventsTableSelectionCondition(bot, selectionTime); | |
514 | } | |
156e9ead MAL |
515 | |
516 | private static class TimeGraphIsReadyCondition extends DefaultCondition { | |
517 | ||
518 | private @NonNull TmfTimeRange fSelectionRange; | |
519 | private @NonNull ITmfTimestamp fVisibleTime; | |
520 | private AbstractTimeGraphView fView; | |
f149d124 | 521 | private String fFailureMessage; |
156e9ead MAL |
522 | |
523 | private TimeGraphIsReadyCondition(AbstractTimeGraphView view, @NonNull TmfTimeRange selectionRange, @NonNull ITmfTimestamp visibleTime) { | |
524 | fView = view; | |
525 | fSelectionRange = selectionRange; | |
526 | fVisibleTime = visibleTime; | |
527 | } | |
528 | ||
529 | @Override | |
530 | public boolean test() throws Exception { | |
f149d124 MAL |
531 | ICondition selectionRangeCondition = ConditionHelpers.selectionRange(fSelectionRange); |
532 | if (!selectionRangeCondition.test()) { | |
533 | fFailureMessage = selectionRangeCondition.getFailureMessage(); | |
156e9ead MAL |
534 | return false; |
535 | } | |
f149d124 MAL |
536 | @NonNull TmfTimeRange curWindowRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange(); |
537 | if (!curWindowRange.contains(fVisibleTime)) { | |
538 | fFailureMessage = "Current window range " + curWindowRange + " does not contain " + fVisibleTime; | |
156e9ead MAL |
539 | return false; |
540 | } | |
f149d124 MAL |
541 | |
542 | if (fView.isDirty()) { | |
543 | fFailureMessage = "Time graph is dirty"; | |
544 | return false; | |
545 | ||
546 | } | |
547 | return true; | |
156e9ead MAL |
548 | } |
549 | ||
550 | @Override | |
551 | public String getFailureMessage() { | |
f149d124 | 552 | return fFailureMessage; |
156e9ead MAL |
553 | } |
554 | } | |
555 | ||
556 | /** | |
557 | * | |
558 | * Wait until the Time Graph view is ready. The Time Graph view is | |
559 | * considered ready if the selectionRange is selected, the visibleTime is | |
560 | * visible and the view is not dirty (its model is done updating). | |
561 | * | |
562 | * @param view | |
563 | * the time graph view | |
564 | * @param selectionRange | |
565 | * the selection that the time graph should have | |
566 | * @param visibleTime | |
567 | * the visible time that the time graph should have | |
568 | * @return ICondition for verification | |
569 | */ | |
570 | public static ICondition timeGraphIsReadyCondition(AbstractTimeGraphView view, @NonNull TmfTimeRange selectionRange, @NonNull ITmfTimestamp visibleTime) { | |
571 | return new TimeGraphIsReadyCondition(view, selectionRange, visibleTime); | |
572 | } | |
e834a6b4 MAL |
573 | |
574 | private static class NumberOfEventsCondition extends DefaultCondition { | |
575 | ||
576 | private ITmfTrace fTrace; | |
577 | private long fNbEvents; | |
578 | ||
579 | private NumberOfEventsCondition(ITmfTrace trace, long nbEvents) { | |
580 | fTrace = trace; | |
581 | fNbEvents = nbEvents; | |
582 | } | |
583 | ||
584 | @Override | |
585 | public boolean test() throws Exception { | |
586 | return fTrace.getNbEvents() == fNbEvents; | |
587 | } | |
588 | ||
589 | @Override | |
590 | public String getFailureMessage() { | |
591 | return fTrace.getName() + " did not contain the expected number of " + fNbEvents + " events. Current: " + fTrace.getNbEvents(); | |
592 | } | |
593 | } | |
594 | ||
595 | /** | |
596 | * Wait until the trace contains the specified number of events. | |
597 | * | |
598 | * @param trace | |
599 | * the trace | |
600 | * @param nbEvents | |
601 | * the number of events to wait for | |
602 | * @return ICondition for verification | |
603 | */ | |
604 | public static ICondition numberOfEventsInTrace(ITmfTrace trace, long nbEvents) { | |
605 | return new NumberOfEventsCondition(trace, nbEvents); | |
606 | } | |
607 | ||
608 | /** | |
609 | * Wait until there is an active events editor. A title can also be | |
610 | * specified to wait until a more specific editor. | |
611 | */ | |
612 | public static final class ActiveEventsEditor extends DefaultCondition { | |
613 | private final SWTWorkbenchBot fWorkbenchBot; | |
614 | private SWTBotEditor fEditor; | |
615 | private String fEditorTitle; | |
616 | ||
617 | /** | |
618 | * Wait until there is an active events editor. | |
619 | * | |
620 | * @param workbenchBot | |
621 | * a workbench bot | |
622 | * @param editorTitle | |
623 | * If specified, wait until an active events editor with this | |
624 | * title. Can be set to null. | |
625 | */ | |
626 | public ActiveEventsEditor(SWTWorkbenchBot workbenchBot, String editorTitle) { | |
627 | fWorkbenchBot = workbenchBot; | |
628 | fEditorTitle = editorTitle; | |
629 | } | |
630 | ||
631 | @Override | |
632 | public boolean test() throws Exception { | |
633 | List<SWTBotEditor> editors = fWorkbenchBot.editors(WidgetMatcherFactory.withPartId(TmfEventsEditor.ID)); | |
634 | for (SWTBotEditor e : editors) { | |
635 | // We are careful not to call e.getWidget() here because it actually forces the editor to show. | |
636 | // This is especially a problem for cases where we wait until there is no active editor. | |
637 | if (e.isActive()) { | |
638 | if (fEditorTitle != null && !fEditorTitle.equals(e.getTitle())) { | |
639 | return false; | |
640 | } | |
641 | fEditor = e; | |
642 | return true; | |
643 | } | |
644 | } | |
645 | return false; | |
646 | } | |
647 | ||
648 | @Override | |
649 | public String getFailureMessage() { | |
650 | String editorMessage = fEditorTitle != null ? " " + fEditorTitle : ""; | |
651 | return "Active events editor" + editorMessage + " not found"; | |
652 | } | |
653 | ||
654 | /** | |
655 | * @return The active editor found | |
656 | */ | |
657 | public SWTBotEditor getActiveEditor() { | |
658 | return fEditor; | |
659 | } | |
660 | } | |
aa5b9bd6 MAL |
661 | |
662 | private static class NumberOfSeries extends DefaultCondition { | |
663 | private String fFailureMessage; | |
664 | private Chart fChart; | |
665 | private final int fNumberOfSeries; | |
666 | ||
667 | public NumberOfSeries(Chart chart, int numberOfSeries) { | |
668 | fChart = chart; | |
669 | fNumberOfSeries = numberOfSeries; | |
670 | } | |
671 | ||
672 | @Override | |
673 | public boolean test() throws Exception { | |
674 | int length = fChart.getSeriesSet().getSeries().length; | |
675 | if (length != fNumberOfSeries){ | |
676 | fFailureMessage = "Chart did not contain the expected number series. Actual " + length + ", expected " + fNumberOfSeries; | |
677 | return false; | |
678 | } | |
679 | ||
680 | return true; | |
681 | } | |
682 | ||
683 | @Override | |
684 | public String getFailureMessage() { | |
685 | return fFailureMessage; | |
686 | } | |
687 | } | |
688 | ||
689 | /** | |
690 | * Wait until the chart has the specified number of series. | |
691 | * | |
692 | * @param chart | |
693 | * the chart | |
694 | * @param numberOfSeries | |
695 | * the number of expected series | |
696 | * | |
697 | * @return ICondition for verification | |
698 | */ | |
699 | public static ICondition numberOfSeries(Chart chart, int numberOfSeries) { | |
700 | return new NumberOfSeries(chart, numberOfSeries); | |
701 | } | |
88051e61 | 702 | } |