The following shows the typical usable of this class: *
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();
}
}
* When using jtreg you would include this class via something like:
*
@library ../../../regtesthelpers
@build Blocker
@run main YourTest
*
* You can also use the method createFrameWithPassFailButtons
* 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 testPassed or testFailed, from
* another thread to unblock the receiver. This will only throw an
* exception if testFailed 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. error 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 error is null, this has
* The same effect as calling testPassed.
*/
public void testFailed(Throwable error) {
stopTest(error);
}
/**
* Both testPassed and testFailed call into
* this. Sets the ivar, done, and notifies listeners
* which will unblock the caller of blockTillDone.
*/
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
* uiTestFailed with failString and the pass
* button is wired to invoked uiTestPassed.
*
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. *
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
* testPassed.
*/
protected void uiTestPassed() {
testPassed();
}
/**
* This is invoked from the fail button. It in turn invokes
* testFailed with a RuntimeException, the contents of
* which are failString.
*/
protected void uiTestFailed(String failString) {
testFailed(new RuntimeException(failString));
}
}