This class provides basis for AWT Mixing testing. *
It provides all standard test machinery and should be used by * extending and overriding next methods: *
Current AWT component should be added to the tested UI by {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) ()}. * There AWT components are prepared to be tested as being overlayed by other (e.g. Swing) components - they are colored to * {@link OverlappingTestBase#AWT_BACKGROUND_COLOR} and throws failure on catching mouse event. *
Validation of component being overlayed should be tested by {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point) } * See each method javadoc for more details. * *
Due to test machinery limitations all test should be run from their own main() by calling next coe
*
* public static void main(String args[]) throws InterruptedException {
* instance = new YourTestInstance();
* OverlappingTestBase.doMain(args);
* }
*
*
* @author Sergey Grinev
*/
public abstract class OverlappingTestBase {
// working variables
private static volatile boolean wasHWClicked = false;
private static volatile boolean passed = true;
// constants
/**
* Default color for AWT component used for validate correct drawing of overlapping. Never use it for lightweight components.
*/
protected static final Color AWT_BACKGROUND_COLOR = new Color(21, 244, 54);
protected static Color AWT_VERIFY_COLOR = AWT_BACKGROUND_COLOR;
protected static final int ROBOT_DELAY = 500;
private static final String[] simpleAwtControls = {"Button", "Checkbox", "Label", "TextArea"};
/**
* Generic strings array. To be used for population of List based controls.
*/
protected static final String[] petStrings = {"Bird", "Cat", "Dog", "Rabbit", "Rhynocephalia Granda", "Bear", "Tiger", "Mustang"};
static Field peerField;
// "properties"
/**
* Tests customization. Set this variable to test only control from java.awt
*
Usage of this variable should be marked with CR being the reason. *
Do not use this variable simultaneously with {@link OverlappingTestBase#skipClassNames} */ protected String onlyClassName = null; /** * For customizing tests. List classes' simple names to skip them from testings. *
Usage of this variable should be marked with CR being the reason.
*/
protected String[] skipClassNames = null;
/**
* Set to false to avoid event delivery validation
* @see OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean)
*/
protected boolean useClickValidation = true;
/**
* Set to false if test doesn't supposed to verify EmbeddedFrame
*/
protected boolean testEmbeddedFrame = false;
/**
* Set this variable to true if testing embedded frame is impossible (on Mac, for instance, for now).
* The testEmbeddedFrame is explicitly set to true in dozen places.
*/
protected boolean skipTestingEmbeddedFrame = false;
public static final boolean isMac = System.getProperty("os.name").toLowerCase().contains("os x");
private boolean isFrameBorderCalculated;
private int borderShift;
{ if (Toolkit.getDefaultToolkit().getClass().getName().matches(".*L.*Toolkit")) {
// No EmbeddedFrame in LWToolkit/LWCToolkit, yet
// And it should be programmed some other way, too, in any case
System.err.println("skipTestingEmbeddedFrame");
skipTestingEmbeddedFrame = true;
}else {
System.err.println("do not skipTestingEmbeddedFrame");
}
}
protected int frameBorderCounter() {
if (!isFrameBorderCalculated) {
try {
new FrameBorderCounter(); // force compilation by jtreg
String JAVA_HOME = System.getProperty("java.home");
Process p = Runtime.getRuntime().exec(JAVA_HOME + "/bin/java FrameBorderCounter");
try {
p.waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
if (p.exitValue() != 0) {
throw new RuntimeException("FrameBorderCounter exited with not null code!\n" + readInputStream(p.getErrorStream()));
}
borderShift = Integer.parseInt(readInputStream(p.getInputStream()).trim());
isFrameBorderCalculated = true;
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("Problem calculating a native border size");
}
}
return borderShift;
}
public void getVerifyColor() {
try {
final int size = 200;
final Point[] p = new Point[1];
SwingUtilities.invokeAndWait(new Runnable() {
public void run(){
JFrame frame = new JFrame("set back");
frame.getContentPane().setBackground(AWT_BACKGROUND_COLOR);
frame.setSize(size, size);
frame.setUndecorated(true);
frame.setVisible(true);
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
p[0] = frame.getLocation();
}
});
Robot robot = new Robot();
robot.waitForIdle();
Thread.sleep(ROBOT_DELAY);
AWT_VERIFY_COLOR = robot.getPixelColor(p[0].x+size/2, p[0].y+size/2);
System.out.println("Color will be compared with " + AWT_VERIFY_COLOR + " instead of " + AWT_BACKGROUND_COLOR);
} catch (Exception e) {
System.err.println("Cannot get verify color: "+e.getMessage());
}
}
private String readInputStream(InputStream is) throws IOException {
byte[] buffer = new byte[4096];
int len = 0;
StringBuilder sb = new StringBuilder();
try (InputStreamReader isr = new InputStreamReader(is)) {
while ((len = is.read(buffer)) > 0) {
sb.append(new String(buffer, 0, len));
}
}
return sb.toString();
}
private void setupControl(final Component control) {
if (useClickValidation) {
control.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
System.err.println("ERROR: " + control.getClass() + " received mouse click.");
wasHWClicked = true;
}
});
}
control.setBackground(AWT_BACKGROUND_COLOR);
control.setForeground(AWT_BACKGROUND_COLOR);
control.setPreferredSize(new Dimension(150, 150));
control.setFocusable(false);
}
private void addAwtControl(java.util.List N.B.: if testEmbeddedFrame == true this method will also add EmbeddedFrame over Canvas
* and it should be called after Frame.setVisible(true) call
* @param container container to hold AWT component
*/
protected final void propagateAWTControls(Container container) {
if (currentAwtControl != null) {
container.add(currentAwtControl);
} else { // embedded frame
try {
//create embedder
Canvas embedder = new Canvas();
embedder.setBackground(Color.RED);
embedder.setPreferredSize(new Dimension(150, 150));
container.add(embedder);
container.setVisible(true); // create peer
long frameWindow = 0;
String getWindowMethodName = "getHWnd";
if (Toolkit.getDefaultToolkit().getClass().getName().contains("XToolkit")) {
getWindowMethodName = "getWindow";
}
ComponentPeer peer = (ComponentPeer) peerField.get(embedder);
// System.err.println("Peer: " + peer);
Method getWindowMethod = peer.getClass().getMethod(getWindowMethodName);
frameWindow = (Long) getWindowMethod.invoke(peer);
// System.err.println("frame peer ID: " + frameWindow);
String eframeClassName = "sun.awt.windows.WEmbeddedFrame";
if (Toolkit.getDefaultToolkit().getClass().getName().contains("XToolkit")) {
eframeClassName = "sun.awt.X11.XEmbeddedFrame";
}
Class eframeClass = Class.forName(eframeClassName);
Constructor eframeCtor = eframeClass.getConstructor(long.class);
EmbeddedFrame eframe = (EmbeddedFrame) eframeCtor.newInstance(frameWindow);
setupControl(eframe);
eframe.setSize(new Dimension(150, 150));
eframe.setVisible(true);
// System.err.println(eframe.getSize());
} catch (Exception ex) {
ex.printStackTrace();
fail("Failed to instantiate EmbeddedFrame: " + ex.getMessage());
}
}
}
private static final Font hugeFont = new Font("Arial", Font.BOLD, 70);
private java.util.List Firstly, verifies point by color pixel check
* Secondly, verifies event delivery by mouse click
* @param robot AWT Robot. Usually created by {@link Util#createRobot() }
* @param lLoc point to verify
* @param defaultShift if true verified position will be shifted by {@link OverlappingTestBase#shift }.
*/
protected void clickAndBlink(Robot robot, Point lLoc, boolean defaultShift) {
Point loc = lLoc.getLocation();
//check color
Util.waitForIdle(robot);
try{
Thread.sleep(500);
}catch(Exception exx){
exx.printStackTrace();
}
if (defaultShift) {
loc.translate(shift.x, shift.y);
}
if (!(System.getProperty("os.name").toLowerCase().contains("os x"))) {
Color c = robot.getPixelColor(loc.x, loc.y);
System.out.println("C&B. color: "+c+" compare with "+AWT_VERIFY_COLOR);
if (c.equals(AWT_VERIFY_COLOR)) {
fail(failMessageColorCheck);
passed = false;
}
// perform click
Util.waitForIdle(robot);
}
robot.mouseMove(loc.x, loc.y);
robot.mousePress(InputEvent.BUTTON1_MASK);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
Util.waitForIdle(robot);
}
/**
* This method should be overriden with code which setups UI for testing.
* Code in this method will be called only from AWT thread so Swing operations can be called directly.
*
* @see {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) } for instructions about adding tested AWT control to UI
*/
protected abstract void prepareControls();
/**
* This method should be overriden with test execution. It will not be called from AWT thread so all Swing operations should be treated accordingly.
* @return true if test passed. Otherwise fail with default fail message.
* @see {@link OverlappingTestBase#failMessage} default fail message
*/
protected abstract boolean performTest();
/**
* This method can be overriden with cleanup routines. It will be called from AWT thread so all Swing operations should be treated accordingly.
*/
protected void cleanup() {
// intentionally do nothing
}
/**
* Currect tested AWT Control. Usually shouldn't be accessed directly.
*
* @see {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) } for instructions about adding tested AWT control to UI
*/
protected Component currentAwtControl;
private void testComponent(Component component) throws InterruptedException, InvocationTargetException {
Robot robot = null;
try {
robot = new Robot();
}catch(Exception ignorex) {
}
currentAwtControl = component;
System.out.println("Testing " + currentAwtControl.getClass().getSimpleName());
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
prepareControls();
}
});
if (component != null) {
Util.waitTillShown(component);
}
Util.waitForIdle(robot);
try {
Thread.sleep(500); // wait for graphic effects on systems like Win7
} catch (InterruptedException ex) {
}
if (!instance.performTest()) {
fail(failMessage);
passed = false;
}
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
cleanup();
}
});
}
private void testEmbeddedFrame() throws InvocationTargetException, InterruptedException {
Robot robot = null;
try {
robot = new Robot();
}catch(Exception ignorex) {
}
System.out.println("Testing EmbeddedFrame");
currentAwtControl = null;
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
prepareControls();
}
});
Util.waitForIdle(robot);
try {
Thread.sleep(500); // wait for graphic effects on systems like Win7
} catch (InterruptedException ex) {
}
if (!instance.performTest()) {
fail(failMessage);
passed = false;
}
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
cleanup();
}
});
}
private void testAwtControls() throws InterruptedException {
try {
for (Component component : getAWTControls()) {
testComponent(component);
}
if (testEmbeddedFrame && !skipTestingEmbeddedFrame) {
testEmbeddedFrame();
}
} catch (InvocationTargetException ex) {
ex.printStackTrace();
fail(ex.getMessage());
}
}
/**
* Used by standard test machinery. See usage at {@link OverlappingTestBase }
*/
protected static OverlappingTestBase instance;
protected OverlappingTestBase() {
getVerifyColor();
}
/*****************************************************
* Standard Test Machinery Section
* DO NOT modify anything in this section -- it's a
* standard chunk of code which has all of the
* synchronisation necessary for the test harness.
* By keeping it the same in all tests, it is easier
* to read and understand someone else's test, as
* well as insuring that all tests behave correctly
* with the test harness.
* There is a section following this for test-
* classes
******************************************************/
private static void init() throws InterruptedException {
//*** Create instructions for the user here ***
//System.setProperty("sun.awt.disableMixing", "true");
String[] instructions = {
"This is an AUTOMATIC test, simply wait until it is done.",
"The result (passed or failed) will be shown in the",
"message window below."
};
Sysout.createDialog();
Sysout.printInstructions(instructions);
instance.testAwtControls();
if (wasHWClicked) {
fail("HW component received the click.");
passed = false;
}
if (passed) {
pass();
}
}//End init()
private static boolean theTestPassed = false;
private static boolean testGeneratedInterrupt = false;
private static String failureMessage = "";
private static Thread mainThread = null;
private static int sleepTime = 300000;
// Not sure about what happens if multiple of this test are
// instantiated in the same VM. Being static (and using
// static vars), it aint gonna work. Not worrying about
// it for now.
/**
* Starting point for test runs. See usage at {@link OverlappingTestBase }
* @param args regular main args, not used.
* @throws InterruptedException
*/
public static void doMain(String args[]) throws InterruptedException {
try {
peerField = Component.class.getDeclaredField("peer");
} catch (NoSuchFieldException e) {
throw new RuntimeException("peer field is not available");
}
peerField.setAccessible(true);
mainThread = Thread.currentThread();
try {
init();
} catch (TestPassedException e) {
//The test passed, so just return from main and harness will
// interepret this return as a pass
return;
}
//At this point, neither test pass nor test fail has been
// called -- either would have thrown an exception and ended the
// test, so we know we have multiple threads.
//Test involves other threads, so sleep and wait for them to
// called pass() or fail()
try {
Thread.sleep(sleepTime);
//Timed out, so fail the test
throw new RuntimeException("Timed out after " + sleepTime / 1000 + " seconds");
} catch (InterruptedException e) {
//The test harness may have interrupted the test. If so, rethrow the exception
// so that the harness gets it and deals with it.
if (!testGeneratedInterrupt) {
throw e;
}
//reset flag in case hit this code more than once for some reason (just safety)
testGeneratedInterrupt = false;
if (theTestPassed == false) {
throw new RuntimeException(failureMessage);
}
}
}//main
/**
* Test will fail if not passed after this timeout. Default timeout is 300 seconds.
* @param seconds timeout in seconds
*/
public static synchronized void setTimeoutTo(int seconds) {
sleepTime = seconds * 1000;
}
/**
* Set test as passed. Usually shoudn't be called directly.
*/
public static synchronized void pass() {
Sysout.println("The test passed.");
Sysout.println("The test is over, hit Ctl-C to stop Java VM");
//first check if this is executing in main thread
if (mainThread == Thread.currentThread()) {
//Still in the main thread, so set the flag just for kicks,
// and throw a test passed exception which will be caught
// and end the test.
theTestPassed = true;
throw new TestPassedException();
}
theTestPassed = true;
testGeneratedInterrupt = true;
mainThread.interrupt();
}//pass()
/**
* Fail test generic message.
*/
public static synchronized void fail() {
//test writer didn't specify why test failed, so give generic
fail("it just plain failed! :-)");
}
/**
* Fail test providing specific reason.
* @param whyFailed reason
*/
public static synchronized void fail(String whyFailed) {
Sysout.println("The test failed: " + whyFailed);
Sysout.println("The test is over, hit Ctl-C to stop Java VM");
//check if this called from main thread
if (mainThread == Thread.currentThread()) {
//If main thread, fail now 'cause not sleeping
throw new RuntimeException(whyFailed);
}
theTestPassed = false;
testGeneratedInterrupt = true;
failureMessage = whyFailed;
mainThread.interrupt();
}//fail()
}// class LWComboBox
class TestPassedException extends RuntimeException {
}
//*********** End Standard Test Machinery Section **********
//************ Begin classes defined for the test ****************
// if want to make listeners, here is the recommended place for them, then instantiate
// them in init()
/* Example of a class which may be written as part of a test
class NewClass implements anInterface
{
static int newVar = 0;
public void eventDispatched(AWTEvent e)
{
//Counting events to see if we get enough
eventCount++;
if( eventCount == 20 )
{
//got enough events, so pass
LWComboBox.pass();
}
else if( tries == 20 )
{
//tried too many times without getting enough events so fail
LWComboBox.fail();
}
}// eventDispatched()
}// NewClass class
*/
//************** End classes defined for the test *******************
/****************************************************
Standard Test Machinery
DO NOT modify anything below -- it's a standard
chunk of code whose purpose is to make user
interaction uniform, and thereby make it simpler
to read and understand someone else's test.
****************************************************/
/**
This is part of the standard test machinery.
It creates a dialog (with the instructions), and is the interface
for sending text messages to the user.
To print the instructions, send an array of strings to Sysout.createDialog
WithInstructions method. Put one line of instructions per array entry.
To display a message for the tester to see, simply call Sysout.println
with the string to be displayed.
This mimics System.out.println but works within the test harness as well
as standalone.
*/
class Sysout {
private static TestDialog dialog;
public static void createDialogWithInstructions(String[] instructions) {
dialog = new TestDialog(new Frame(), "Instructions");
dialog.printInstructions(instructions);
//dialog.setVisible(true);
println("Any messages for the tester will display here.");
}
public static void createDialog() {
dialog = new TestDialog(new Frame(), "Instructions");
String[] defInstr = {"Instructions will appear here. ", ""};
dialog.printInstructions(defInstr);
//dialog.setVisible(true);
println("Any messages for the tester will display here.");
}
public static void printInstructions(String[] instructions) {
dialog.printInstructions(instructions);
}
public static void println(String messageIn) {
dialog.displayMessage(messageIn);
System.out.println(messageIn);
}
}// Sysout class
/**
This is part of the standard test machinery. It provides a place for the
test instructions to be displayed, and a place for interactive messages
to the user to be displayed.
To have the test instructions displayed, see Sysout.
To have a message to the user be displayed, see Sysout.
Do not call anything in this dialog directly.
*/
class TestDialog extends Dialog {
TextArea instructionsText;
TextArea messageText;
int maxStringLength = 80;
//DO NOT call this directly, go through Sysout
public TestDialog(Frame frame, String name) {
super(frame, name);
int scrollBoth = TextArea.SCROLLBARS_BOTH;
instructionsText = new TextArea("", 15, maxStringLength, scrollBoth);
add("North", instructionsText);
messageText = new TextArea("", 5, maxStringLength, scrollBoth);
add("Center", messageText);
pack();
//setVisible(true);
}// TestDialog()
//DO NOT call this directly, go through Sysout
public void printInstructions(String[] instructions) {
//Clear out any current instructions
instructionsText.setText("");
//Go down array of instruction strings
String printStr, remainingStr;
for (int i = 0; i < instructions.length; i++) {
//chop up each into pieces maxSringLength long
remainingStr = instructions[i];
while (remainingStr.length() > 0) {
//if longer than max then chop off first max chars to print
if (remainingStr.length() >= maxStringLength) {
//Try to chop on a word boundary
int posOfSpace = remainingStr.lastIndexOf(' ', maxStringLength - 1);
if (posOfSpace <= 0) {
posOfSpace = maxStringLength - 1;
}
printStr = remainingStr.substring(0, posOfSpace + 1);
remainingStr = remainingStr.substring(posOfSpace + 1);
} //else just print
else {
printStr = remainingStr;
remainingStr = "";
}
instructionsText.append(printStr + "\n");
}// while
}// for
}//printInstructions()
//DO NOT call this directly, go through Sysout
public void displayMessage(String messageIn) {
messageText.append(messageIn + "\n");
System.out.println(messageIn);
}
}// TestDialog class
defaultShift == true for {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean) }.
* This method is used to verify controls by providing just their plain screen coordinates.
* @param robot AWT Robot. Usually created by {@link Util#createRobot() }
* @param lLoc point to verify
* @see OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean)
*/
protected void clickAndBlink(Robot robot, Point lLoc) {
clickAndBlink(robot, lLoc, true);
}
/**
* Default failure message for color check
* @see OverlappingTestBase#performTest()
*/
protected String failMessageColorCheck = "The LW component did not pass pixel color check and is overlapped";
/**
* Default failure message event check
* @see OverlappingTestBase#performTest()
*/
protected String failMessage = "The LW component did not received the click.";
private static boolean isValidForPixelCheck(Component component) {
if ((component instanceof java.awt.Scrollbar) || isMac && (component instanceof java.awt.Button)) {
return false;
}
return true;
}
/**
* Preliminary validation - should be run before overlapping happens to ensure test is correct.
* @param robot AWT Robot. Usually created by {@link Util#createRobot() }
* @param lLoc point to validate to be of {@link OverlappingTestBase#AWT_BACKGROUND_COLOR}
* @param component tested component, should be pointed out as not all components are valid for pixel check.
*/
protected void pixelPreCheck(Robot robot, Point lLoc, Component component) {
if (isValidForPixelCheck(component)) {
int tries = 10;
Color c = null;
while (tries-- > 0) {
c = robot.getPixelColor(lLoc.x, lLoc.y);
System.out.println("Precheck. color: "+c+" compare with "+AWT_VERIFY_COLOR);
if (c.equals(AWT_VERIFY_COLOR)) {
return;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
System.err.println(lLoc + ": " + c);
fail("Dropdown test setup failure, colored part of AWT component is not located at click area");
}
}
/**
* Verifies point using specified AWT Robot.
*