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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/*
* Copyright (c) 2006, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* Blocker can be used to block a thread until another thread
* messages the blocker to stop. This is useful for regression
* tests that use swing, as most of the work for testing a swing component
* is done in the event dispatching thread and the testing harness ends when
* main returns.
* <p>The following shows the typical usable of this class:
* <pre>
public static void main(String[] args) throws Throwable {
... set up the gui ...
Blocker blocker = new Blocker();
blocker.blockTillDone();
}
public void actionPerformed(ActionEvent ae) {
if (failed) {
blocker.testFailed(new RuntimeException("FAILED!"));
}
else {
blocker.testPassed();
}
}
</pre>
* When using jtreg you would include this class via something like:
* <pre>
@library ../../../regtesthelpers
@build Blocker
@run main YourTest
</pre>
*
* <p>You can also use the method <code>createFrameWithPassFailButtons</code>
* that will create a JFrame containing two buttons (pass and fail), with
* the two buttons wired to pass/fail the test. Refer to the javadoc for
* more info.
*/
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JFrame;
public class Blocker {
private boolean done;
private Throwable error;
/**
* Call this from the main thread to block the reciever. Then call
* either <code>testPassed</code> or <code>testFailed</code>, from
* another thread to unblock the receiver. This will only throw an
* exception if <code>testFailed</code> is invoked.
*/
public void blockTillDone() throws Throwable {
synchronized(this) {
while (!done) {
wait();
}
}
if (error != null) {
throw error;
}
}
/**
* Invoke this to stop the blocker thread. This does not change the
* status of the test. This is intended for cases where you don't
* know if you've failed, but want to stop the test.
*/
public void stopTest() {
synchronized(this) {
done = true;
notifyAll();
}
}
/**
* Invoke if the test has suceeded. This will notify the main thread
* causing it to stop waiting and continue, which will
* cause the test to finish.
*/
public void testPassed() {
stopTest(null);
}
/**
* Invoke if the test has failed. <code>error</code> gives the
* exception that will be thrown from the main thread. This will notify
* the main thread causing it to stop waiting and continue, which will
* cause the test to finish. If <code>error</code> is null, this has
* The same effect as calling <code>testPassed</code>.
*/
public void testFailed(Throwable error) {
stopTest(error);
}
/**
* Both <code>testPassed</code> and <code>testFailed</code> call into
* this. Sets the ivar, <code>done</code>, and notifies listeners
* which will unblock the caller of <code>blockTillDone</code>.
*/
protected void stopTest(Throwable error) {
synchronized(this) {
this.error = error;
done = true;
notify();
}
}
/**
* Creates and returns a JFrame with two button, one that says pass,
* another that says fail. The fail button is wired to call
* <code>uiTestFailed</code> with <code>failString</code> and the pass
* button is wired to invoked <code>uiTestPassed</code>.
* <p>The content pane of the JFrame uses a BorderLayout with the
* buttons inside a horizontal box with filler between them and the
* pass button on the left.
* <p>The returned frame has not been packed, or made visible, it is
* up to the caller to do that (after putting in some useful components).
*/
public JFrame createFrameWithPassFailButtons(final String failString) {
JFrame retFrame = new JFrame("TEST");
Box buttonBox = Box.createHorizontalBox();
JButton passButton = new JButton("Pass");
JButton failButton = new JButton("Fail");
passButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
uiTestPassed();
}
});
failButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
uiTestFailed(failString);
}
});
retFrame.getContentPane().setLayout(new BorderLayout());
buttonBox.add(passButton);
buttonBox.add(Box.createGlue());
buttonBox.add(failButton);
retFrame.getContentPane().add(buttonBox, BorderLayout.SOUTH);
retFrame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
return retFrame;
}
/**
* This is invoked from the pass button. It in turn invokes
* <code>testPassed</code>.
*/
protected void uiTestPassed() {
testPassed();
}
/**
* This is invoked from the fail button. It in turn invokes
* <code>testFailed</code> with a RuntimeException, the contents of
* which are <code>failString</code>.
*/
protected void uiTestFailed(String failString) {
testFailed(new RuntimeException(failString));
}
}
|
