org.eclipse.tracecompass.analysis.timing.ui,
org.eclipse.tracecompass.analysis.os.linux.core,
org.eclipse.tracecompass.segmentstore.core,
- org.eclipse.tracecompass.lttng2.kernel.core
+ org.eclipse.tracecompass.lttng2.kernel.core,
+ org.eclipse.tracecompass.tmf.ui.tests
Import-Package: com.google.common.collect;version="15.0.0",
org.eclipse.tracecompass.testtraces.ctf,
org.swtchart
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.junit.After;
/* Switch perspectives */
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
bot.waitUntil(ConditionHelpers.ViewIsClosed(view));
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, tracePath, TRACE_TYPE);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
createDensityViewer();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotTable tableBot = new SWTBotTable(fDensityViewer.getTableViewer().getTable());
bot.waitUntil(ConditionHelpers.isTableCellFilled(tableBot, "1,600", 0, 2));
tableBot.header("Duration").click();
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.junit.After;
/* Switch perspectives */
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
bot.waitUntil(ConditionHelpers.ViewIsClosed(view));
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, tracePath, TRACE_TYPE);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
createScatterViewer();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
final Chart scatterChart = fScatterChart;
assertNotNull(scatterChart);
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.PlatformUI;
/* Switch perspectives */
switchTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
bot.waitUntil(ConditionHelpers.ViewIsClosed(view));
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, tracePath, TRACE_TYPE);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
createTree();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
assertEquals("1.000 µs", fTreeBot.cell(0, MIN_COL));
assertEquals("5.904 s", fTreeBot.cell(0, MAX_COL));
assertEquals("15.628 ms", fTreeBot.cell(0, AVERAGE_COL)); // double
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.PlatformUI;
/* Switch perspectives */
switchTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
bot.waitUntil(ConditionHelpers.ViewIsClosed(view));
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, tracePath, TRACE_TYPE);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
createTable();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotTable tableBot = new SWTBotTable(fTable.getTableViewer().getTable());
bot.waitUntil(ConditionHelpers.isTableCellFilled(tableBot, "24,100", 0, 2));
tableBot.header("Duration").click();
org.eclipse.tracecompass.tmf.ui.swtbot.tests,
org.eclipse.tracecompass.tmf.ctf.core;bundle-version="2.0.0",
org.eclipse.tracecompass.tmf.ctf.core.tests,
- org.eclipse.tracecompass.common.core;bundle-version="2.0.0"
+ org.eclipse.tracecompass.common.core;bundle-version="2.0.0",
+ org.eclipse.tracecompass.tmf.ui.tests
Import-Package: org.apache.log4j,
org.apache.log4j.varia,
org.eclipse.swtbot.eclipse.finder,
import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.histogram.HistogramView;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
text.setText(traceProjectName);
fBot.button("Finish").click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
button.click();
}
fBot.waitUntil(Conditions.shellCloses(shell));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
}
});
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(1000);
final CtfTmfEvent desiredEvent2 = getEvent(10000);
final TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(hv, desiredEvent1.getTimestamp());
final TmfSelectionRangeUpdatedSignal signal2 = new TmfSelectionRangeUpdatedSignal(hv, desiredEvent2.getTimestamp());
hv.updateTimeRange(100000);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
hv.selectionRangeUpdated(signal);
hv.broadcast(signal);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(1000);
hv.updateTimeRange(1000000000);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
hv.selectionRangeUpdated(signal2);
hv.broadcast(signal2);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(1000);
assertNotNull(hv);
}
import org.eclipse.swtbot.swt.finder.waits.Conditions;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.createProject(PROJET_NAME);
}
org.eclipse.tracecompass.lttng2.control.core,
org.eclipse.tracecompass.lttng2.control.ui,
org.eclipse.tracecompass.lttng2.control.ui.tests;bundle-version="2.0.0",
- org.eclipse.tracecompass.ctf.core.tests
+ org.eclipse.tracecompass.ctf.core.tests,
+ org.eclipse.tracecompass.tmf.ui.tests
Export-Package: org.eclipse.tracecompass.lttng2.control.ui.swtbot.tests
Import-Package: com.google.common.collect,
org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceSessionState;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
// all tracepoint events and syscalls
shell.bot().radioInGroup(ControlViewSwtBotUtil.GROUP_SELECT_NAME, ControlViewSwtBotUtil.ALL_EVENT_GROUP_NAME).click();
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.KERNEL_DOMAIN_NAME, sessionItem));
import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceEventComponent;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
// Click the Ok at the bottom of the dialog window
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.UST_DOMAIN_NAME, sessionItem));
import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceEventComponent;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
SWTBotText filterText = shell.bot().textInGroup(ControlViewSwtBotUtil.FILTER_EXPRESSION_LABEL);
filterText.setText(FILTER_EXPRESSION);
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.KERNEL_DOMAIN_NAME, sessionItem));
SWTBotText filterText = shell.bot().textInGroup(ControlViewSwtBotUtil.FILTER_EXPRESSION_LABEL);
filterText.setText(FILTER_EXPRESSION);
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotTreeItem sessionItem = SWTBotUtils.getTreeItem(fBot, fTree,
getNodeName(),
import org.eclipse.tracecompass.internal.lttng2.control.ui.views.ControlView;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.Test;
/**
// Click the Ok at the bottom of the dialog window
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(domainName, sessionItem));
// Assert that the domain is correct
// Click the Ok at the bottom of the dialog window
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(domainName, sessionItem));
// Assert that the domain is correct
shell.bot().ccomboBoxInGroup(LOGLEVEL_PROPERTY_NAME).setSelection(logLevel);
// Click the Ok at the bottom of the dialog window
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(domainName, sessionItem));
// Assert that the domain is correct
shell.bot().textInGroup("Specific logger").setText(ControlViewSwtBotUtil.SPECIFIC_LOGGER_NAME1 + "," + ControlViewSwtBotUtil.SPECIFIC_LOGGER_NAME2);
// Click the Ok at the bottom of the dialog window
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(domainName, sessionItem));
// Assert that the domain is correct
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
SWTBotShell shell = fBot.shell(ControlViewSwtBotUtil.SAVE_DIALOG_TITLE).activate();
shell.bot().button(ControlViewSwtBotUtil.CONFIRM_DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
profileItem.click();
shell.bot().button(ControlViewSwtBotUtil.CONFIRM_DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
sessionGroupItem = SWTBotUtils.getTreeItem(fBot, fTree,
getNodeName(), ControlViewSwtBotUtil.SESSION_GROUP_NAME);
import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceSessionState;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
// Click Ok to quit the dialog window
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
// Wait until the child of Sessions is activated
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.KERNEL_DOMAIN_NAME, sessionItem));
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.junit.After;
import org.junit.Before;
SWTBotUtils.closeView("welcome", fBot);
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.switchToPerspective(PERSPECTIVE_ID);
}
@Before
public void beforeTest() throws Exception {
SWTBotUtils.openView(ControlView.ID);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
URL location = FileLocator.find(FrameworkUtil.getBundle(this.getClass()), new Path("testfiles" + File.separator + getTestStream()), null);
File testfile = new File(FileLocator.toFileURL(location).toURI());
fTestFile = testfile.getAbsolutePath();
nodeItem.select();
SWTBotMenu menuBot = nodeItem.contextMenu(ControlViewSwtBotUtil.CONNECT_MENU_ITEM);
menuBot.click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.SESSION_GROUP_NAME, nodeItem));
sessionText.setText(SESSION_NAME);
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
sessionGroupItem.expand();
SWTBotTreeItem allItem = SWTBotUtils.getTreeItem(fBot, tracepointsTree, ControlViewSwtBotUtil.ALL_TREE_NODE);
allItem.check();
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.KERNEL_DOMAIN_NAME, sessionItem));
SWTBotTreeItem allItem = SWTBotUtils.getTreeItem(fBot, syscallsTree, ControlViewSwtBotUtil.ALL_TREE_NODE);
allItem.check();
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.KERNEL_DOMAIN_NAME, sessionItem));
SWTBotTreeItem closeItem = SWTBotUtils.getTreeItem(fBot, syscallsTree, ControlViewSwtBotUtil.ALL_TREE_NODE, ControlViewSwtBotUtil.SYSCALL_CLOSE_EVENT);
closeItem.check();
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.KERNEL_DOMAIN_NAME, sessionItem));
shell.bot().radioInGroup(ControlViewSwtBotUtil.UST_GROUP_NAME, ControlViewSwtBotUtil.DOMAIN_GROUP_NAME).click();
shell.bot().radioInGroup(ControlViewSwtBotUtil.BUFFERTYPE_PER_UID, ControlViewSwtBotUtil.BUFFERTYPE_GROUP_NAME).click();
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(ConditionHelpers.IsTreeChildNodeAvailable(ControlViewSwtBotUtil.UST_DOMAIN_NAME, sessionItem));
}
SWTBotTree tracepointsTree = shell.bot().tree();
tracepointsTree.select(ControlViewSwtBotUtil.ALL_TREE_NODE);
shell.bot().button(ControlViewSwtBotUtil.DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotTreeItem eventItem = SWTBotUtils.getTreeItem(fBot, fTree,
getNodeName(),
if (state == TraceSessionState.ACTIVE) {
SWTBotMenu menuBot = sessionItem.contextMenu(ControlViewSwtBotUtil.START_MENU_ITEM);
menuBot.click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
} else {
SWTBotMenu menuBot = sessionItem.contextMenu(ControlViewSwtBotUtil.STOP_MENU_ITEM);
menuBot.click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
TraceSessionComponent sessionComp = ControlViewSwtBotUtil.getSessionComponent(fNode, getSessionName());
SWTBotShell shell = fBot.shell(ControlViewSwtBotUtil.DESTROY_CONFIRM_DIALOG_TITLE).activate();
shell.bot().button(ControlViewSwtBotUtil.CONFIRM_DIALOG_OK_BUTTON).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotTreeItem sessionGroupItem = SWTBotUtils.getTreeItem(fBot, fTree,
getNodeName(), ControlViewSwtBotUtil.SESSION_GROUP_NAME);
nodeItem.select();
SWTBotMenu menuBot = nodeItem.contextMenu(ControlViewSwtBotUtil.DISCONNECT_MENU_ITEM);
menuBot.click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
// Verify that node is connected
fBot.waitUntil(ControlViewSwtBotUtil.isStateChanged(fNode, TargetNodeState.DISCONNECTED));
shell.bot().waitUntil(Conditions.widgetIsEnabled(button));
button.click();
fBot.waitUntil(Conditions.shellCloses(shell));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
private static String prepareAndVerifyExperimentHandling(SWTBot bot, boolean createExperiment, boolean defaultExperiment, IPath path) {
import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.ITraceControlComponent;
import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TargetNodeComponent;
import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceSessionComponent;
-import org.eclipse.tracecompass.tmf.ui.tests.shared.JobUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
* Waits for all Eclipse jobs to finish
*/
public void waitForJobs() {
- JobUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
private IViewPart showView(String viewId) throws PartInitException {
org.eclipse.ui.views,
org.junit,
org.eclipse.tracecompass.analysis.graph.ui,
- org.eclipse.tracecompass.analysis.os.linux.ui.swtbot.tests
+ org.eclipse.tracecompass.analysis.os.linux.ui.swtbot.tests,
+ org.eclipse.tracecompass.tmf.ui.tests
Import-Package: org.eclipse.tracecompass.testtraces.ctf,
org.swtchart;version="0.7.0"
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.histogram.HistogramView;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
final TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(hv, fDesired1.getTimestamp());
final TmfSelectionRangeUpdatedSignal signal2 = new TmfSelectionRangeUpdatedSignal(hv, fDesired2.getTimestamp());
hv.updateTimeRange(100000);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
hv.selectionRangeUpdated(signal);
hv.broadcast(signal);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(1000);
hv.updateTimeRange(1000000000);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
hv.selectionRangeUpdated(signal2);
hv.broadcast(signal2);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(1000);
assertNotNull(hv);
}
import org.eclipse.tracecompass.ctf.core.tests.shared.LttngTraceGenerator;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.junit.After;
/* Create the trace project */
SWTBotUtils.createProject(TRACE_PROJECT_NAME);
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.analysis.Messages;
import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
SWTBotUtils.switchToPerspective(KERNEL_PERSPECTIVE_ID);
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.hamcrest.Matcher;
import org.junit.Before;
import org.junit.Test;
private static void broadcast(TmfCpuSelectedSignal signal) {
UIThreadRunnable.syncExec(() -> TmfSignalManager.dispatchSignal(signal));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
private String getTitle() {
org.junit,
org.eclipse.tracecompass.lttng2.ust.core,
org.eclipse.tracecompass.lttng2.ust.ui,
- org.swtchart
+ org.swtchart,
+ org.eclipse.tracecompass.tmf.ui.tests
Export-Package: org.eclipse.tracecompass.lttng2.ust.ui.swtbot.tests
Import-Package: com.google.common.collect,
org.eclipse.tracecompass.testtraces.ctf;version="1.1.1"
import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.callstack.CallStackView;
import org.junit.After;
import org.junit.Before;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
final File file = new File(CtfTmfTestTraceUtils.getTrace(cygProfile).getPath());
SWTBotUtils.openTrace(PROJECT_NAME, file.getAbsolutePath(), UST_ID);
SWTBotUtils.openView(CallStackView.ID);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
final SWTBotView viewBot = fBot.viewById(CallStackView.ID);
viewBot.setFocus();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
List<String> names = getVisibleStackFrames(viewBot);
assertArrayEquals(STACK_FRAMES[0], names.toArray());
}
viewBot.toolbarPushButton(SELECT_NEXT_STATE_CHANGE).click();
currentEventOffset++;
fBot.waitUntil(ConditionHelpers.selectionInEventsTable(fBot, TIMESTAMPS[currentEventOffset]));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
assertArrayEquals(STACK_FRAMES[currentEventOffset], getVisibleStackFrames(viewBot).toArray());
}
viewBot.toolbarPushButton(SELECT_PREVIOUS_STATE_CHANGE).click();
currentEventOffset--;
fBot.waitUntil(ConditionHelpers.selectionInEventsTable(fBot, TIMESTAMPS[currentEventOffset]));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
assertArrayEquals(STACK_FRAMES[currentEventOffset], getVisibleStackFrames(viewBot).toArray());
}
// move up and down once to make sure it doesn't explode
viewBot.toolbarPushButton(SELECT_PREVIOUS_ITEM).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
viewBot.toolbarPushButton(SELECT_NEXT_ITEM).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
// Zoom in and out too
viewBot.toolbarPushButton(ZOOM_IN).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
viewBot.toolbarPushButton(ZOOM_OUT).click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
viewBot.toolbarToggleButton(SORT_BY_ID).click();
viewBot.toolbarToggleButton(SORT_BY_START).click();
viewBot.setFocus();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
List<String> names = getVisibleStackFrames(viewBot);
assertArrayEquals(STACK_FRAMES[0], names.toArray());
}
viewBot.setFocus();
// no way to load mappings yet! :(
SWTBotTree tree = viewBot.bot().tree();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
List<String> names = new ArrayList<>();
for (SWTBotTreeItem swtBotTreeItem : tree.getAllItems()) {
for (SWTBotTreeItem items : swtBotTreeItem.getItems()) {
import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.hamcrest.Matcher;
import org.junit.After;
import org.junit.Before;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
final File file = new File(CtfTmfTestTraceUtils.getTrace(cygProfile).getPath());
SWTBotUtils.openTrace(PROJECT_NAME, file.getAbsolutePath(), UST_ID);
SWTBotUtils.openView(MemoryUsageView.ID);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
org.eclipse.tracecompass.tmf.pcap.core.tests,
org.eclipse.tracecompass.tmf.ui,
org.eclipse.tracecompass.tmf.pcap.ui,
- org.eclipse.tracecompass.tmf.ui.swtbot.tests
+ org.eclipse.tracecompass.tmf.ui.swtbot.tests,
+ org.eclipse.tracecompass.tmf.ui.tests
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IViewPart;
/* Switch perspectives */
switchNetworkPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
assertNotNull(botTree);
final TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(slv, fDesired1.getTimestamp());
slv.broadcast(signal);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
// FIXME This is a race condition:
// TmfEventsTable launches an async exec that may be run after the wait
// for jobs. This last delay catches it.
}
SWTBotUtils.delay(1000);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
private void openEditor() {
}
});
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(1000);
assertNotNull(tmfEd);
}
org.eclipse.tracecompass.tmf.ui.swtbot.tests,
org.eclipse.ui,
org.eclipse.ui.views.log,
- org.junit
+ org.junit,
+ org.eclipse.tracecompass.tmf.ui.tests
Import-Package: com.google.common.collect;version="15.0.0"
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.statistics.TmfStatisticsView;
import org.eclipse.ui.IEditorReference;
import org.junit.After;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.createProject(TRACE_PROJECT_NAME);
}
import org.eclipse.tracecompass.tmf.ctf.ui.swtbot.tests.SWTBotImportWizardUtils;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IPageLayout;
import org.junit.AfterClass;
import org.junit.BeforeClass;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.createProject(TRACE_PROJECT_NAME);
}
org.eclipse.tracecompass.lttng2.kernel.core,
org.eclipse.tracecompass.tmf.analysis.xml.ui,
org.eclipse.tracecompass.tmf.analysis.xml.core.tests,
- org.eclipse.tracecompass.tmf.analysis.xml.core
+ org.eclipse.tracecompass.tmf.analysis.xml.core,
+ org.eclipse.tracecompass.tmf.ui.tests
Import-Package: org.eclipse.tracecompass.testtraces.ctf,
org.swtchart
import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.table.AbstractSegmentStoreTableViewer;
import org.eclipse.tracecompass.internal.tmf.analysis.xml.ui.views.latency.PatternDensityView;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
-import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.junit.Test;
@Test
public void testWithTrace() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
setDensityViewer();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
//Test the table content
SWTBotTable tableBot = new SWTBotTable(fDensityViewer.getTableViewer().getTable());
import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.table.AbstractSegmentStoreTableViewer;
import org.eclipse.tracecompass.internal.tmf.analysis.xml.ui.views.latency.PatternLatencyTableView;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
-import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.junit.Test;
@Test
public void testData() {
getTable();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
assertNotNull(fTable);
SWTBotTable tableBot = new SWTBotTable(fTable.getTableViewer().getTable());
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.analysis.xml.core.tests.common.TmfXmlTestFiles;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
/* Switch perspectives */
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot = new SWTWorkbenchBot();
String tracePath = FileLocator.toFileURL(CtfTestTrace.ARM_64_BIT_HEADER.getTraceURL()).getPath();
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, tracePath, TRACE_TYPE);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
} catch (IOException e) {
fail("Failed to get the trace.");
}
import org.eclipse.swtbot.swt.finder.widgets.AbstractSWTBotControl;
import org.eclipse.tracecompass.internal.tmf.analysis.xml.ui.views.latency.PatternScatterGraphView;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
-import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.junit.Test;
@Test
public void testWithTrace() {
setChart();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
final Chart scatterChart = fScatterChart;
assertNotNull(scatterChart);
fBot.waitUntil(ConditionHelpers.numberOfSeries(scatterChart, 1));
org.eclipse.tracecompass.lttng2.kernel.core,
org.eclipse.swtbot.junit4_x,
org.eclipse.swtbot.swt.finder,
- org.eclipse.tracecompass.tmf.ctf.core.tests
+ org.eclipse.tracecompass.tmf.ctf.core.tests,
+ org.eclipse.tracecompass.tmf.ui.tests
Import-Package: org.apache.log4j,
org.apache.log4j.varia,
org.eclipse.swtbot.eclipse.finder,
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
private static class TraceCountCondition extends DefaultCondition {
private static void testImport(Runnable selectionFunctor, Runnable verifyTracesFunctor) {
SWTBotUtils.createProject(PROJECT_NAME);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotView projectExplorerBot = fBot.viewByTitle(PROJECT_EXPLORER);
assertNotNull("Cannot find " + PROJECT_EXPLORER, projectExplorerBot);
projectExplorerBot.show();
fBot.waitUntil(Conditions.widgetIsEnabled(button));
button.click();
fBot.waitUntil(Conditions.shellCloses(shell));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
verifyTracesFunctor.run();
fBot.closeAllEditors();
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.timegraph.AbstractTimeGraphView;
import org.eclipse.ui.IWorkbenchPart;
import org.junit.After;
/* Prepare the workspace */
prepareWorkspace();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
/* Create project */
SWTBotUtils.createProject(PROJECT_NAME);
// Make sure all the analyses we'll need are done
ITmfTrace trace = TmfTraceManager.getInstance().getActiveTrace();
beforeRunningTest(trace);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotView view;
Thread.sleep(1000);
} catch (InterruptedException e) {
}
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
// TODO: Add some vertical scrollings. With eventual 2D queries, that will
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IViewReference;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
@Test
public void testPerspectiveForViews() {
SWTBotUtils.switchToPerspective(fPerspectiveId);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
for (final String viewID : fViewIds) {
List<SWTBotView> view = fBot.views(new BaseMatcher<String>() {
@Test
public void testPerspectiveComplete() {
SWTBotUtils.switchToPerspective(fPerspectiveId);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
for (SWTBotView view : fBot.views()) {
assertTrue("view " + view.getViewReference().getId() + " is present", fViewIds.contains(view.getViewReference().getId()));
}
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTracesFolder;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers.ProjectElementHasChild;
-import org.eclipse.tracecompass.tmf.ui.tests.shared.JobUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.TracingPerspectiveFactory;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
@SuppressWarnings("restriction")
public final class SWTBotUtils {
- private static final long MAX_JOBS_WAIT_TIME = 300000;
private static final String WINDOW_MENU = "Window";
private static final String PREFERENCES_MENU_ITEM = "Preferences";
private static boolean fPrintedEnvironment = false;
/**
* Waits for all Eclipse jobs to finish. Times out after
- * SWTBotUtils#MAX_JOBS_WAIT_TIME by default.
+ * WaitUtils#MAX_JOBS_WAIT_TIME by default.
*
* @throws RuntimeException
* once the waiting time passes the default maximum value
+ *
+ * @deprecated Use {@link WaitUtils#waitForJobs()} instead
*/
+ @Deprecated
public static void waitForJobs() {
- JobUtils.waitForJobs(MAX_JOBS_WAIT_TIME);
+ WaitUtils.waitForJobs();
}
/**
}
});
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
public static void deleteProject(final String projectName, boolean deleteResources, SWTWorkbenchBot bot) {
// Wait for any analysis to complete because it might create
// supplementary files
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
try {
ResourcesPlugin.getWorkspace().getRoot().getProject(projectName).refreshLocal(IResource.DEPTH_INFINITE, null);
} catch (CoreException e) {
}
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
closeSecondaryShells(bot);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
final SWTBotView projectViewBot = bot.viewById(IPageLayout.ID_PROJECT_EXPLORER);
projectViewBot.setFocus();
bot.waitUntil(Conditions.widgetIsEnabled(okButton));
okButton.click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
if (delay) {
delay(1000);
- waitForJobs();
+ WaitUtils.waitForJobs();
}
}
}
});
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(1000);
assertNotNull(tmfEd);
return editorBot;
if (res[0] != null) {
fail(res[0].getMessage());
}
- waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
import org.eclipse.tracecompass.tmf.core.io.BufferedRandomAccessFile;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.swtbot.swt.finder.waits.Conditions;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
// Set the regular expression for each event line
fBot.styledText().setText("12 Hello\nWorld\n23 Goodbye\ncruel world");
eventLine[0].select();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.textWithLabel("Regular expression:").setText("\\s*(\\d\\d)\\s(.*\\S)");
eventLine[1].select();
fBot.textWithLabel("Regular expression:").setText("([^0-9]*)");
assertNotNull(eventLine[1]);
fBot.styledText().setText("12 Hello\nWorld\n23 Goodbye\ncruel world");
eventLine[0].select();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.textWithLabel("Regular expression:").setText("\\s*(\\d\\d)\\s(.*\\S)");
eventLine[1].select();
fBot.textWithLabel("Regular expression:").setText("([^0-9]*)");
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimePreferencesConstants;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IEditorReference;
import org.hamcrest.Matcher;
import org.junit.AfterClass;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.filter.model.ITmfFilterTreeNode;
import org.eclipse.tracecompass.tmf.core.io.BufferedRandomAccessFile;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.colors.ColorSetting;
import org.eclipse.tracecompass.tmf.ui.views.colors.ColorSettingsManager;
import org.eclipse.tracecompass.tmf.ui.views.colors.ColorsView;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fFileLocation = File.createTempFile("sample", ".xml");
try (BufferedRandomAccessFile braf = new BufferedRandomAccessFile(fFileLocation, "rw")) {
braf.writeBytes(TRACE_START);
});
final SWTBotTable eventsEditor = SWTBotUtils.activeEventsEditor(fBot).bot().table();
// should fix race condition of loading the trace
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
eventsEditor.select(2);
final SWTBotTableItem tableItem = eventsEditor.getTableItem(2);
RGB fgc = UIThreadRunnable.syncExec(new Result<RGB>() {
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTableColumn;
import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.createProject(TRACE_PROJECT_NAME);
}
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable;
import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.createProject(TRACE_PROJECT_NAME);
}
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ImageHelper;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.PlatformUI;
import org.junit.After;
import org.junit.AfterClass;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
ColorRegistry colorRegistry = PlatformUI.getWorkbench().getThemeManager().getCurrentTheme().getColorRegistry();
fHighlight = ImageHelper.adjustExpectedColor(colorRegistry.get(HIGHLIGHT_COLOR_DEFINITION_ID).getRGB());
@After
public void cleanup() {
SWTBotUtils.deleteProject(TRACE_PROJECT_NAME, fBot);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.filter.FilterView;
import org.junit.After;
import org.junit.AfterClass;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fFileLocation = File.createTempFile("sample", ".xml");
try (BufferedRandomAccessFile braf = new BufferedRandomAccessFile(fFileLocation, "rw")) {
braf.writeBytes(TRACE_START);
}
private static String applyFilter(SWTWorkbenchBot bot, final String filterName) {
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
final SWTBotTable eventsTable = SWTBotUtils.activeEventsEditor(bot).bot().table();
SWTBotTableItem tableItem = eventsTable.getTableItem(2);
tableItem.contextMenu(filterName).click();
import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
import org.eclipse.tracecompass.tmf.ui.editors.TmfTraceColumnManager;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
SWTBotUtils.switchToTracingPerspective();
/* Finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
public void before() throws Exception {
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, createTrace(INITIAL_NB_EVENTS), getTraceType());
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.tracecompass.tmf.core.io.BufferedRandomAccessFile;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.SDView;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.Frame;
import org.junit.After;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fFileLocation = File.createTempFile("sample", ".xml");
String eventNames[] = { "test:SEND", "test:RECEIVE" };
String targets[] = { "peer1", "peer2" };
assertNotNull(viewBot);
viewBot.setFocus();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
List<SWTBotToolbarButton> viewButtons = viewBot.getToolbarButtons();
List<String> titles = new ArrayList<>();
for (SWTBotToolbarButton buttonBot : viewButtons) {
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
public void before() throws Exception {
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, createTrace(INITIAL_NB_EVENTS), getTraceType());
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fLocation = File.createTempFile("sample", ".xml");
try (BufferedRandomAccessFile braf = new BufferedRandomAccessFile(fLocation, "rw")) {
braf.writeBytes(TRACE_START);
SWTBotTreeItem traceItem = SWTBotUtils.getTraceProjectItem(fBot, traceFolderItem, fLocation.getName());
traceItem.select();
traceItem.contextMenu("Apply Time Offset...").click();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
// set offset to 99 ns
SWTBotShell shell = fBot.shell("Apply time offset");
shell.setFocus();
swtBotTreeItem.pressShortcut(KeyStroke.getInstance('9'));
swtBotTreeItem.pressShortcut(KeyStroke.getInstance('9'));
swtBotTreeItem.pressShortcut(KeyStroke.getInstance('\n'));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.button("OK").click();
// wait for trace to close
import org.eclipse.tracecompass.tmf.ui.project.wizards.NewTmfProjectWizard;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotSash;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.views.callstack.CallStackView;
import org.eclipse.tracecompass.tmf.ui.views.histogram.HistogramView;
import org.eclipse.tracecompass.tmf.ui.views.timechart.TimeChartView;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fLocation = File.createTempFile("sample", ".xml");
try (BufferedRandomAccessFile braf = new BufferedRandomAccessFile(fLocation, "rw")) {
braf.writeBytes(TRACE_START);
final int offset = 100;
// switch to the proper perspective and wait for views to align
SWTBotUtils.switchToPerspective(AlignPerspectiveFactory3.ID);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(SYNC_DELAY);
// get views
SWTBotView masterView = fBot.viewById(vId1);
Point before = slaveSashBot.getPoint();
// move master and wait for slaves to follow
drag(masterView, offset);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(SYNC_DELAY);
// verify that the slave did not follow
assertEquals(before, slaveSashBot.getPoint());
final int offset = 100;
final int delta = offset / 2;
// wait for the perspective switch to propagate alignments
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(SYNC_DELAY);
// select master and slave parts to observe
SWTBotView masterViewBot = fBot.viewById(masterView);
assertEquals("Approx align", masterOriginalSashX, slaveSashBot.getPoint().x, delta);
// move sash and wait for alignment
drag(masterViewBot, offset);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
SWTBotUtils.delay(SYNC_DELAY);
// check results
double masterNewSashX = masterSashBot.getPoint().x;
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWindow;
*/
SWTBotTreeItem treeItem = SWTBotUtils.getTreeItem(projectExplorer.bot(), tree, PROJECT_NAME, tracesNode, traceName);
treeItem.doubleClick();
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
/*
* Check results
*/
final SWTBotButton finishButton = fBot.button("Finish");
finishButton.click();
fBot.waitUntil(Conditions.shellCloses(shell));
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
}
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
SWTBotUtils.switchToTracingPerspective();
/* finish waiting for eclipse to load */
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
assertTrue("Trace :" + f.getAbsolutePath() + " does not exist, aborting test", f.exists());
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotUtils.openTrace(PROJECT_NAME, f.getAbsolutePath(), XMLSTUB_ID);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
assertEquals("Incorrect opened trace!", f.getAbsolutePath(), (new File(TmfTraceManager.getInstance().getActiveTrace().getPath())).getAbsolutePath());
SWTBotView projectExplorerBot = fBot.viewByTitle(PROJECT_EXPLORER);
assertNotNull("Cannot find " + PROJECT_EXPLORER, projectExplorerBot);
SWTBotShell shell = fBot.activeShell();
shellBot.button(FINISH).click();
// finished exporting
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
fBot.waitUntil(Conditions.shellCloses(shell));
fBot = new SWTWorkbenchBot();
exportPackage = new File(EXPORT_LOCATION);
assertEquals("Test if import matches", f.getName(), TmfTraceManager.getInstance().getActiveTrace().getName());
assertFalse("Test if import files don't match", f.getAbsolutePath().equals(TmfTraceManager.getInstance().getActiveTrace().getPath()));
SWTBotUtils.deleteProject(PROJECT_NAME, fBot);
- SWTBotUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2008, 2016 Ketan Padegaonkar and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Ketan Padegaonkar - initial API and implementation
+ * Marc-Andre Laperle - Adapted to Trace Compass from SWTBot's TimeoutException
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.ui.tests.shared;
+
+/**
+ * A condition meant to be tested periodically. If it fails after a certain
+ * timeout, a failure message is provided.
+ */
+public interface IWaitCondition {
+ /**
+ * Tests if the condition has been met.
+ *
+ * @return <code>true</code> if the condition is satisfied, <code>false</code> otherwise.
+ * @throws Exception if the test encounters an error while processing the check.
+ */
+ boolean test() throws Exception;
+
+ /**
+ * Gets the failure message when a test fails (returns <code>false</code>).
+ *
+ * @return the failure message to show in case the test fails.
+ */
+ String getFailureMessage();
+}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2016 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *******************************************************************************/
-package org.eclipse.tracecompass.tmf.ui.tests.shared;
-
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.swt.widgets.Display;
-
-/**
- * A utility class for Job related things.
- */
-public final class JobUtils {
-
- private JobUtils() {
- }
-
- private static final long SLEEP_INTERVAL_MS = 100;
- private static final long UI_THREAD_SLEEP_INTERVAL_MS = 10;
- private static final long DEFAULT_MAX_JOBS_WAIT_TIME_MS = 300000;
-
- /**
- * Waits for all Eclipse jobs to finish. Times out after
- * RuntimeUtils#MAX_JOBS_WAIT_TIME by default.
- *
- * @throws RuntimeException
- * once the waiting time passes the default maximum value
- */
- public static void waitForJobs() {
- waitForJobs(DEFAULT_MAX_JOBS_WAIT_TIME_MS);
- }
-
- /**
- * Waits for all Eclipse jobs to finish
- *
- * @param maxWait
- * the maximum time to wait, in milliseconds. Once the waiting
- * time passes the maximum value, a TimeoutException is thrown
- * @throws RuntimeException
- * once the waiting time passes the maximum value
- */
- public static void waitForJobs(long maxWait) {
- long waitStart = System.currentTimeMillis();
- Display display = Display.getCurrent();
- while (!Job.getJobManager().isIdle()) {
- if (System.currentTimeMillis() - waitStart > maxWait) {
- printJobs();
- throw new RuntimeException("Timed out waiting for jobs to finish."); //$NON-NLS-1$
- }
-
- if (display != null) {
- if (!display.readAndDispatch()) {
- // We do not use Display.sleep because it might never wake up
- // if there is no user interaction
- try {
- Thread.sleep(UI_THREAD_SLEEP_INTERVAL_MS);
- } catch (final InterruptedException e) {
- // Ignored
- }
- }
- display.update();
- } else {
- try {
- Thread.sleep(SLEEP_INTERVAL_MS);
- } catch (final InterruptedException e) {
- // Ignored
- }
- }
- }
- }
-
- private static void printJobs() {
- Job[] jobs = Job.getJobManager().find(null);
- for (Job job : jobs) {
- System.err.println(job.toString() + " state: " + jobStateToString(job.getState())); //$NON-NLS-1$
- Thread thread = job.getThread();
- if (thread != null) {
- for (StackTraceElement stractTraceElement : thread.getStackTrace()) {
- System.err.println(" " + stractTraceElement); //$NON-NLS-1$
- }
- }
- System.err.println();
- }
- }
-
- private static String jobStateToString(int jobState) {
- switch (jobState) {
- case Job.RUNNING:
- return "RUNNING"; //$NON-NLS-1$
- case Job.WAITING:
- return "WAITING"; //$NON-NLS-1$
- case Job.SLEEPING:
- return "SLEEPING"; //$NON-NLS-1$
- case Job.NONE:
- return "NONE"; //$NON-NLS-1$
- default:
- return "UNKNOWN"; //$NON-NLS-1$
- }
- }
-}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2008, 2016 Ketan Padegaonkar and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Ketan Padegaonkar - initial API and implementation
+ * Marc-Andre Laperle - Adapted to Trace Compass from SWTBot's TimeoutException
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.ui.tests.shared;
+/**
+ * This is an exception that is thrown when a timeout occurs waiting for something (e.g. a condition) to complete.
+ */
+public class WaitTimeoutException extends RuntimeException {
+
+ private static final long serialVersionUID = -2673174817824776871L;
+
+ /**
+ * Constructs the exception with the given message.
+ *
+ * @param message the message.
+ */
+ public WaitTimeoutException(String message) {
+ super(message);
+ }
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2016 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.ui.tests.shared;
+
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.swt.widgets.Display;
+
+/**
+ * A utility class for methods related to waiting until certain conditions are met.
+ */
+public final class WaitUtils {
+
+ private WaitUtils() {
+ }
+
+ private static final long SLEEP_INTERVAL_MS = 100;
+ private static final long UI_THREAD_SLEEP_INTERVAL_MS = 10;
+ private static final long DEFAULT_MAX_WAIT_TIME_MS = 300000;
+
+ /**
+ * Waits for all Eclipse jobs to finish.
+ *
+ * @throws WaitTimeoutException
+ * once the waiting time passes the maximum value
+ */
+ public static void waitForJobs() {
+ waitUntil(new IWaitCondition() {
+ @Override
+ public boolean test() throws Exception {
+ return Job.getJobManager().isIdle();
+ }
+
+ @Override
+ public String getFailureMessage() {
+ printJobs();
+ return "Timed out waiting for jobs to finish.";
+ }
+ });
+ }
+
+ /**
+ * Prints the state of all the jobs on stderr.
+ */
+ public static void printJobs() {
+ Job[] jobs = Job.getJobManager().find(null);
+ for (Job job : jobs) {
+ System.err.println(job.toString() + " state: " + jobStateToString(job.getState())); //$NON-NLS-1$
+ Thread thread = job.getThread();
+ if (thread != null) {
+ for (StackTraceElement stractTraceElement : thread.getStackTrace()) {
+ System.err.println(" " + stractTraceElement); //$NON-NLS-1$
+ }
+ }
+ System.err.println();
+ }
+ }
+
+ private static String jobStateToString(int jobState) {
+ switch (jobState) {
+ case Job.RUNNING:
+ return "RUNNING"; //$NON-NLS-1$
+ case Job.WAITING:
+ return "WAITING"; //$NON-NLS-1$
+ case Job.SLEEPING:
+ return "SLEEPING"; //$NON-NLS-1$
+ case Job.NONE:
+ return "NONE"; //$NON-NLS-1$
+ default:
+ return "UNKNOWN"; //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Waits for a certain condition to be met.
+ *
+ * @param condition
+ * the condition to be met
+ *
+ * @throws WaitTimeoutException
+ * once the waiting time passes the maximum value
+ */
+ public static void waitUntil(IWaitCondition condition) {
+ waitUntil(condition, DEFAULT_MAX_WAIT_TIME_MS);
+ }
+
+ /**
+ * Waits for a certain condition to be met.
+ *
+ * @param condition
+ * the condition to be met
+ * @param maxWait
+ * the maximum time to wait, in milliseconds. Once the waiting
+ * time passes the maximum value, a WaitTimeoutException is
+ * thrown
+ * @throws WaitTimeoutException
+ * once the waiting time passes the maximum value
+ */
+ public static void waitUntil(IWaitCondition condition, long maxWait) {
+ long waitStart = System.currentTimeMillis();
+ Display display = Display.getCurrent();
+ try {
+ while (!condition.test()) {
+ if (System.currentTimeMillis() - waitStart > maxWait) {
+ throw new WaitTimeoutException(condition.getFailureMessage()); //$NON-NLS-1$
+ }
+
+ if (display != null) {
+ if (!display.readAndDispatch()) {
+ // We do not use Display.sleep because it might never wake up
+ // if there is no user interaction
+ try {
+ Thread.sleep(UI_THREAD_SLEEP_INTERVAL_MS);
+ } catch (final InterruptedException e) {
+ // Ignored
+ }
+ }
+ display.update();
+ } else {
+ try {
+ Thread.sleep(SLEEP_INTERVAL_MS);
+ } catch (final InterruptedException e) {
+ // Ignored
+ }
+ }
+ }
+ } catch (Exception e) {
+ throw new WaitTimeoutException(condition.getFailureMessage()); //$NON-NLS-1$
+ }
+ }
+}
import org.eclipse.tracecompass.tmf.core.trace.indexer.ITmfTraceIndexer;
import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.TmfCheckpointIndexer;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
-import org.eclipse.tracecompass.tmf.ui.tests.shared.JobUtils;
+import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.tracecompass.tmf.ui.tests.uml2sd.trace.TmfUml2SDTestTrace;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.SDView;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.dialogs.Criteria;
* Waits for all Eclipse jobs to finish
*/
public void waitForJobs() {
- JobUtils.waitForJobs();
+ WaitUtils.waitForJobs();
}
/**
projects / deliverable / tracecompass.git / commitdiff
