awt/regtesthelpers/VisibilityValidator.java

/*
 * Copyright (c) 2011, 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.
 */

 /*
 * @summary Utility routines that wait for a window to be displayed or for
colors to be visible
 * @summary com.apple.junit.utils
 */
package test.java.awt.regtesthelpers;

import java.awt.*;
import java.awt.event.*;

//import junit.framework.Assert;
public class VisibilityValidator {

    // Wait up to five seconds for our window events
    static final int SETUP_PERIOD = 5000;
    static final boolean DEBUG = false;

    volatile Window win = null;
    boolean activated = false;
    boolean opened = false;
    boolean focused = false;
    volatile boolean valid = false;

    //
    // Utility functions that encapsulates normal usage patterns
    //
    public static void setVisibleAndConfirm(Frame testframe) throws Exception {
        setVisibleAndConfirm(testframe, "Could not confirm test frame was "
                + "visible");
    }

    public static void setVisibleAndConfirm(Frame testframe, String msg)
            throws Exception {
        if (testframe.isVisible()) {
            throw new RuntimeException("Frame is already visible");
        }

        VisibilityValidator checkpoint = new VisibilityValidator(testframe);
        testframe.setVisible(true);
        checkpoint.requireVisible();
        if (!checkpoint.isValid()) {
            //System.err.println(msg);
            throw new Exception("Frame not visible after " + SETUP_PERIOD
                    + " milliseconds");
        }
    }

    //
    // Add listeners to the window
    //
    public VisibilityValidator(Window win) {
        this.win = win;
        WindowAdapter watcher = new WindowAdapter() {
            public void windowOpened(WindowEvent e) {
                doOpen();
            }

            public void windowActivated(WindowEvent e) {
                doActivate();
            }

            public void windowGainedFocus(WindowEvent e) {
                doGainedFocus();
            }
        };

        win.addWindowListener(watcher);
        win.addWindowFocusListener(watcher);
    }

    // Make the window visible
    //
    // The only way to make it through this routine is for the window to
    // generate BOTH a windowOpened, a windowActivated event and a
    // windowGainedFocus, or to timeout.
    //
    synchronized public void requireVisible() {
        int tries = 0;

        // wait for windowOpened and windowActivated events
        try {
            while ((opened == false)
                    || (activated == false)
                    || (focused == false)) {
                if (tries < 4) {
                    tries += 1;
                    wait(SETUP_PERIOD);
                } else {
                    break;
                }
            }

            if (opened && activated) {
                valid = true;
            } else {
                valid = false;
            }
        } catch (InterruptedException ix) {
            valid = false;
        }

        // Extra-super paranoid checks
        if (win.isVisible() == false) {
            valid = false;
        }

        if (win.isShowing() == false) {
            valid = false;
        }

        if (win.isFocused() == false) {
            valid = false;
        }

        if (DEBUG) {
            if (!isValid()) {
                System.out.println("\tactivated:" + new Boolean(activated));
                System.out.println("\topened:" + new Boolean(opened));
                System.out.println("\tfocused:" + new Boolean(focused));
                System.out.println("\tvalid:" + new Boolean(valid));
                System.out.println("\tisVisible():"
                        + new Boolean(win.isVisible()));
                System.out.println("\tisShowing():"
                        + new Boolean(win.isShowing()));
                System.out.println("\tisFocused():"
                        + new Boolean(win.isFocused()));
            }
        }

    }

    synchronized void doOpen() {
        opened = true;
        notify();
    }

    synchronized void doActivate() {
        activated = true;
        notify();
    }

    synchronized void doGainedFocus() {
        focused = true;
        notify();
    }

    public boolean isValid() {
        return valid;
    }

    public boolean isClear() {
        return valid;
    }

    volatile static Robot robot = null;

    // utility function that waits until a Component is shown with the
    // appropriate color
    public static boolean waitForColor(Component c,
            Color expected) throws AWTException,
            InterruptedException {
        Dimension dim = c.getSize();
        int xOff = dim.width / 2;
        int yOff = dim.height / 2;
        return waitForColor(c, xOff, yOff, expected);
    }

    // utility function that waits for 5 seconds for Component to be shown with
    // the appropriate color
    public static boolean waitForColor(Component c,
            int xOff,
            int yOff,
            Color expected) throws AWTException, InterruptedException {
        return waitForColor(c, xOff, yOff, expected, 5000L);
    }

    // utility function that waits until a Component is up with the appropriate
    // color
    public static boolean waitForColor(Component c,
            int xOff,
            int yOff,
            Color expected,
            long timeout) throws AWTException, InterruptedException {
        Point p = c.getLocationOnScreen();
        int x = (int) p.getX() + xOff;
        int y = (int) p.getY() + yOff;
        return waitForColor(x, y, expected, timeout);
    }

    // utility function that waits until specific screen coords have the
    // appropriate color
    public static boolean waitForColor(int locX,
            int locY,
            Color expected,
            long timeout) throws AWTException, InterruptedException {
        if (robot == null) {
            robot = new Robot();
        }

        long endtime = System.currentTimeMillis() + timeout;
        while (endtime > System.currentTimeMillis()) {
            if (colorMatch(robot.getPixelColor(locX, locY), expected)) {
                return true;
            }
            Thread.sleep(50);
        }

        return false;
    }

    // utility function that asserts that two colors are similar to each other
    public static void assertColorEquals(final String message,
            final Color actual,
            final Color expected) {
        System.out.println("actual color: " + actual);
        System.out.println("expect color: " + expected);
        //Assert.assertTrue(message, colorMatch(actual, expected));
    }

    // determines if two colors are close in hue and brightness
    public static boolean colorMatch(final Color actual, final Color expected) {
        final float[] actualHSB = getHSB(actual);
        final float[] expectedHSB = getHSB(expected);

        final float actualHue = actualHSB[0];
        final float expectedHue = expectedHSB[0];
        final boolean hueMatched = closeMatchHue(actualHue, expectedHue, 0.17f);
        //System.out.println("hueMatched? " + hueMatched);
        final float actualBrightness = actualHSB[2];
        final float expectedBrightness = expectedHSB[2];
        final boolean brightnessMatched = closeMatch(actualBrightness,
                expectedBrightness, 0.15f);
        //System.out.println("brightnessMatched? " + brightnessMatched);

        // check to see if the brightness was so low or so high that the hue
        // got clamped to red
        if (brightnessMatched && !hueMatched) {
            return (expectedBrightness < 0.15f);
        }

        return brightnessMatched && hueMatched;
    }

    static float[] getHSB(final Color color) {
        final float[] hsb = new float[3];
        Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), hsb);
        return hsb;
    }

    // matches hues from 0.0 to 1.0, accounting for wrap-around at the 1.0/0.0
    // boundry
    static boolean closeMatchHue(final float actual,
            final float expected,
            final float tolerance) {
        if (closeMatch(actual, expected, tolerance)) {
            return true;
        }

        // all that remains is the overflow and underflow cases
        final float expectedHigh = expected + tolerance;
        final float expectedLow = expected - tolerance;

        if (expectedHigh > 1.0f) {
            // expected is too high, and actual was too low
            //System.out.println("\thue expected too high, actual too low");
            return closeMatch(actual + 0.5f, expected - 0.5f, tolerance);
        }

        if (expectedLow < 0.0f) {
            // expected is too low, and actual was too high
            //System.out.println("\thue expected too low, actual too high");
            return closeMatch(actual - 0.5f, expected + 0.5f, tolerance);
        }

        //System.out.println("\tcloseMatchHue? " + false);
        return false;
    }

    static boolean closeMatch(final float actual,
            final float expected,
            final float tolerance) {
        return (expected + tolerance) > actual && (expected - tolerance) < actual;
    }
}