1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*******************************************************************************
* Copyright (c) 2016 Google, Inc 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:
* Stefan Xenos (Google) - Initial implementation
*******************************************************************************/
package org.eclipse.jdt.debug.tests;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jdt.debug.testplugin.JavaTestPlugin;
import org.eclipse.swt.widgets.Display;
import org.junit.Assert;
public class TestUtil {
/**
* Call this in the tearDown method of every test to clean up state that can
* otherwise leak through SWT between tests.
*/
public static void cleanUp(String owner) {
// Ensure that the Thread.interrupted() flag didn't leak.
Assert.assertFalse("The main thread should not be interrupted at the end of a test", Thread.interrupted());
// Wait for any pending *syncExec calls to finish
TestUtil.runEventLoop();
// Wait for any outstanding jobs to finish. Protect against deadlock by
// terminating the wait after a timeout.
boolean timedOut = waitForJobs(owner, 10, 10000);
if (timedOut) {
// We don't expect any extra jobs run during the test: try to cancel them
log(IStatus.INFO, owner, "Trying to cancel running jobs: " + getRunningOrWaitingJobs(null));
getRunningOrWaitingJobs(null).forEach(job -> job.cancel());
waitForJobs(owner, 10, 1000);
}
// Wait for any pending *syncExec calls to finish
runEventLoop();
// Ensure that the Thread.interrupted() flag didn't leak.
Assert.assertFalse("The main thread should not be interrupted at the end of a test", Thread.interrupted());
}
public static void log(int severity, String owner, String message, Throwable... optionalError) {
message = "[" + owner + "] " + message;
Throwable error = null;
if (optionalError != null && optionalError.length > 0) {
error = optionalError[0];
}
Status status = new Status(severity, JavaTestPlugin.getDefault().getBundle().getSymbolicName(), message, error);
JavaTestPlugin.getDefault().getLog().log(status);
}
/**
* Process all queued UI events. If called from background thread, does
* nothing.
*/
public static void runEventLoop() {
Display display = Display.getCurrent();
if (display != null && !display.isDisposed()) {
while (display.readAndDispatch()) {
// Keep pumping events until the queue is empty
}
}
}
/**
* Utility for waiting until the execution of jobs of any family has finished or timeout is reached. If no jobs are running, the method waits
* given minimum wait time. While this method is waiting for jobs, UI events are processed.
*
* @param owner
* name of the caller which will be logged as prefix if the wait times out
* @param minTimeMs
* minimum wait time in milliseconds
* @param maxTimeMs
* maximum wait time in milliseconds
* @return true if the method timed out, false if all the jobs terminated before the timeout
*/
public static boolean waitForJobs(String owner, long minTimeMs, long maxTimeMs) {
if (maxTimeMs < minTimeMs) {
throw new IllegalArgumentException("Max time is smaller as min time!");
}
final long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start < minTimeMs) {
runEventLoop();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// Uninterruptable
}
}
while (!Job.getJobManager().isIdle()) {
if (System.currentTimeMillis() - start >= maxTimeMs) {
String message = "Some job is still running or waiting to run: " + dumpRunningOrWaitingJobs();
log(IStatus.ERROR, owner, message);
return true;
}
runEventLoop();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// Uninterruptable
}
}
return false;
}
private static String dumpRunningOrWaitingJobs() {
List<Job> jobs = getRunningOrWaitingJobs((Object) null);
if (jobs.isEmpty()) {
return "";
}
StringBuilder sb = new StringBuilder();
for (Job job : jobs) {
sb.append("'").append(job.getName()).append("'/");
sb.append(job.getClass().getName());
sb.append(", ");
}
sb.setLength(sb.length() - 2);
return sb.toString();
}
private static List<Job> getRunningOrWaitingJobs(Object jobFamily) {
List<Job> running = new ArrayList<>();
Job[] jobs = Job.getJobManager().find(jobFamily);
for (Job job : jobs) {
if (isRunningOrWaitingJob(job)) {
running.add(job);
}
}
return running;
}
private static boolean isRunningOrWaitingJob(Job job) {
int state = job.getState();
return (state == Job.RUNNING || state == Job.WAITING);
}
}
|
