| /* |
| * Copyright (c) 2006, 2014, 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. |
| */ |
| |
| package test.java.awt.regtesthelpers; |
| /** |
| * <p>This class contains utilities useful for regression testing. |
| * <p>When using jtreg you would include this class into the build |
| * list via something like: |
| * <pre> |
| @library ../../../regtesthelpers |
| @build Util |
| @run main YourTest |
| </pre> |
| * Note that if you are about to create a test based on |
| * Applet-template, then put those lines into html-file, not in java-file. |
| * <p> And put an |
| * import test.java.awt.regtesthelpers.Util; |
| * into the java source of test. |
| */ |
| |
| import java.awt.Component; |
| import java.awt.Frame; |
| import java.awt.Dialog; |
| import java.awt.Window; |
| import java.awt.Button; |
| import java.awt.Point; |
| import java.awt.Dimension; |
| import java.awt.Rectangle; |
| import java.awt.Robot; |
| import java.awt.Toolkit; |
| import java.awt.IllegalComponentStateException; |
| import java.awt.AWTException; |
| import java.awt.AWTEvent; |
| import java.awt.Color; |
| |
| import java.awt.event.InputEvent; |
| import java.awt.event.WindowAdapter; |
| import java.awt.event.WindowEvent; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.FocusEvent; |
| import java.awt.event.WindowListener; |
| import java.awt.event.WindowFocusListener; |
| import java.awt.event.FocusListener; |
| import java.awt.event.ActionListener; |
| |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| |
| import java.security.PrivilegedAction; |
| import java.security.AccessController; |
| |
| import java.util.concurrent.atomic.AtomicBoolean; |
| |
| public final class Util { |
| private Util() {} // this is a helper class with static methods :) |
| |
| private volatile static Robot robot; |
| |
| /* |
| * @throws RuntimeException when creation failed |
| */ |
| public static Robot createRobot() { |
| try { |
| if (robot == null) { |
| robot = new Robot(); |
| } |
| return robot; |
| } catch (AWTException e) { |
| throw new RuntimeException("Error: unable to create robot", e); |
| } |
| } |
| |
| |
| /** |
| * Makes the window visible and waits until it's shown. |
| */ |
| public static void showWindowWait(Window win) { |
| win.setVisible(true); |
| waitTillShown(win); |
| } |
| |
| /** |
| * Moves mouse pointer in the center of given {@code comp} component |
| * using {@code robot} parameter. |
| */ |
| public static void pointOnComp(final Component comp, final Robot robot) { |
| Rectangle bounds = new Rectangle(comp.getLocationOnScreen(), comp.getSize()); |
| robot.mouseMove(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2); |
| } |
| |
| /** |
| * Moves mouse pointer in the center of a given {@code comp} component |
| * and performs a left mouse button click using the {@code robot} parameter |
| * with the {@code delay} delay between press and release. |
| */ |
| public static void clickOnComp(final Component comp, final Robot robot, int delay) { |
| pointOnComp(comp, robot); |
| robot.delay(delay); |
| robot.mousePress(InputEvent.BUTTON1_MASK); |
| robot.delay(delay); |
| robot.mouseRelease(InputEvent.BUTTON1_MASK); |
| } |
| |
| /** |
| * Moves mouse pointer in the center of a given {@code comp} component |
| * and performs a left mouse button click using the {@code robot} parameter |
| * with the default delay between press and release. |
| */ |
| public static void clickOnComp(final Component comp, final Robot robot) { |
| clickOnComp(comp, robot, 50); |
| } |
| |
| public static Point getTitlePoint(Window decoratedWindow) { |
| Point p = decoratedWindow.getLocationOnScreen(); |
| Dimension d = decoratedWindow.getSize(); |
| return new Point(p.x + (int)(d.getWidth()/2), |
| p.y + (int)(decoratedWindow.getInsets().top/2)); |
| } |
| |
| /* |
| * Clicks on a title of Frame/Dialog. |
| * WARNING: it may fail on some platforms when the window is not wide enough. |
| */ |
| public static void clickOnTitle(final Window decoratedWindow, final Robot robot) { |
| if (decoratedWindow instanceof Frame || decoratedWindow instanceof Dialog) { |
| Point p = getTitlePoint(decoratedWindow); |
| robot.mouseMove(p.x, p.y); |
| robot.delay(50); |
| robot.mousePress(InputEvent.BUTTON1_MASK); |
| robot.delay(50); |
| robot.mouseRelease(InputEvent.BUTTON1_MASK); |
| } |
| } |
| |
| /** |
| * Tests whether screen pixel has the expected color performing several |
| * attempts. This method is useful for asynchronous window manager where |
| * it's impossible to determine when drawing actually takes place. |
| * |
| * @param x X position of pixel |
| * @param y Y position of pixel |
| * @param color expected color |
| * @param attempts number of attempts to undertake |
| * @param delay delay before each attempt |
| * @param robot a robot to use for retrieving pixel color |
| * @return true if pixel color matches the color expected, otherwise false |
| */ |
| public static boolean testPixelColor(int x, int y, final Color color, int attempts, int delay, final Robot robot) { |
| while (attempts-- > 0) { |
| robot.delay(delay); |
| Color screen = robot.getPixelColor(x, y); |
| if (screen.equals(color)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Tests whether the area within boundaries has the expected color |
| * performing several attempts. This method is useful for asynchronous |
| * window manager where it's impossible to determine when drawing actually |
| * takes place. |
| * |
| * @param bounds position of area |
| * @param color expected color |
| * @param attempts number of attempts to undertake |
| * @param delay delay before each attempt |
| * @param robot a robot to use for retrieving pixel color |
| * @return true if area color matches the color expected, otherwise false |
| */ |
| public static boolean testBoundsColor(final Rectangle bounds, final Color color, int attempts, int delay, final Robot robot) { |
| int right = bounds.x + bounds.width - 1; |
| int bottom = bounds.y + bounds.height - 1; |
| while (attempts-- > 0) { |
| if (testPixelColor(bounds.x, bounds.y, color, 1, delay, robot) |
| && testPixelColor(right, bounds.y, color, 1, 0, robot) |
| && testPixelColor(right, bottom, color, 1, 0, robot) |
| && testPixelColor(bounds.x, bottom, color, 1, 0, robot)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public static void waitForIdle(Robot robot) { |
| if (robot == null) { |
| robot = createRobot(); |
| } |
| robot.waitForIdle(); |
| } |
| |
| |
| /* |
| * Waits for a notification and for a boolean condition to become true. |
| * The method returns when the above conditions are fullfilled or when the timeout |
| * occurs. |
| * |
| * @param condition the object to be notified and the booelan condition to wait for |
| * @param timeout the maximum time to wait in milliseconds |
| * @param catchExceptions if {@code true} the method catches InterruptedException |
| * @return the final boolean value of the {@code condition} |
| * @throws InterruptedException if the awaiting proccess has been interrupted |
| */ |
| public static boolean waitForConditionEx(final AtomicBoolean condition, long timeout) |
| throws InterruptedException |
| { |
| synchronized (condition) { |
| long startTime = System.currentTimeMillis(); |
| while (!condition.get()) { |
| condition.wait(timeout); |
| if (System.currentTimeMillis() - startTime >= timeout ) { |
| break; |
| } |
| } |
| } |
| return condition.get(); |
| } |
| |
| /* |
| * The same as {@code waitForConditionEx(AtomicBoolean, long)} except that it |
| * doesn't throw InterruptedException. |
| */ |
| public static boolean waitForCondition(final AtomicBoolean condition, long timeout) { |
| try { |
| return waitForConditionEx(condition, timeout); |
| } catch (InterruptedException e) { |
| throw new RuntimeException("Error: unexpected exception caught!", e); |
| } |
| } |
| |
| /* |
| * The same as {@code waitForConditionEx(AtomicBoolean, long)} but without a timeout. |
| */ |
| public static void waitForConditionEx(final AtomicBoolean condition) |
| throws InterruptedException |
| { |
| synchronized (condition) { |
| while (!condition.get()) { |
| condition.wait(); |
| } |
| } |
| } |
| |
| /* |
| * The same as {@code waitForConditionEx(AtomicBoolean)} except that it |
| * doesn't throw InterruptedException. |
| */ |
| public static void waitForCondition(final AtomicBoolean condition) { |
| try { |
| waitForConditionEx(condition); |
| } catch (InterruptedException e) { |
| throw new RuntimeException("Error: unexpected exception caught!", e); |
| } |
| } |
| |
| public static void waitTillShownEx(final Component comp) throws InterruptedException { |
| while (true) { |
| try { |
| Thread.sleep(100); |
| comp.getLocationOnScreen(); |
| break; |
| } catch (IllegalComponentStateException e) {} |
| } |
| } |
| public static void waitTillShown(final Component comp) { |
| try { |
| waitTillShownEx(comp); |
| } catch (InterruptedException e) { |
| throw new RuntimeException("Error: unexpected exception caught!", e); |
| } |
| } |
| |
| /** |
| * Drags from one point to another with the specified mouse button pressed. |
| * |
| * @param robot a robot to use for moving the mouse, etc. |
| * @param startPoint a start point of the drag |
| * @param endPoint an end point of the drag |
| * @param button one of {@code InputEvent.BUTTON1_MASK}, |
| * {@code InputEvent.BUTTON2_MASK}, {@code InputEvent.BUTTON3_MASK} |
| * |
| * @throws IllegalArgumentException if {@code button} is not one of |
| * {@code InputEvent.BUTTON1_MASK}, {@code InputEvent.BUTTON2_MASK}, |
| * {@code InputEvent.BUTTON3_MASK} |
| */ |
| public static void drag(Robot robot, Point startPoint, Point endPoint, int button) { |
| if (!(button == InputEvent.BUTTON1_MASK || button == InputEvent.BUTTON2_MASK |
| || button == InputEvent.BUTTON3_MASK)) |
| { |
| throw new IllegalArgumentException("invalid mouse button"); |
| } |
| |
| robot.mouseMove(startPoint.x, startPoint.y); |
| robot.mousePress(button); |
| try { |
| mouseMove(robot, startPoint, endPoint); |
| } finally { |
| robot.mouseRelease(button); |
| } |
| } |
| |
| /** |
| * Moves the mouse pointer from one point to another. |
| * Uses Bresenham's algorithm. |
| * |
| * @param robot a robot to use for moving the mouse |
| * @param startPoint a start point of the drag |
| * @param endPoint an end point of the drag |
| */ |
| public static void mouseMove(Robot robot, Point startPoint, Point endPoint) { |
| int dx = endPoint.x - startPoint.x; |
| int dy = endPoint.y - startPoint.y; |
| |
| int ax = Math.abs(dx) * 2; |
| int ay = Math.abs(dy) * 2; |
| |
| int sx = signWOZero(dx); |
| int sy = signWOZero(dy); |
| |
| int x = startPoint.x; |
| int y = startPoint.y; |
| |
| int d = 0; |
| |
| if (ax > ay) { |
| d = ay - ax/2; |
| while (true){ |
| robot.mouseMove(x, y); |
| robot.delay(50); |
| |
| if (x == endPoint.x){ |
| return; |
| } |
| if (d >= 0){ |
| y = y + sy; |
| d = d - ax; |
| } |
| x = x + sx; |
| d = d + ay; |
| } |
| } else { |
| d = ax - ay/2; |
| while (true){ |
| robot.mouseMove(x, y); |
| robot.delay(50); |
| |
| if (y == endPoint.y){ |
| return; |
| } |
| if (d >= 0){ |
| x = x + sx; |
| d = d - ay; |
| } |
| y = y + sy; |
| d = d + ax; |
| } |
| } |
| } |
| |
| private static int signWOZero(int i){ |
| return (i > 0)? 1: -1; |
| } |
| |
| private static int sign(int n) { |
| return n < 0 ? -1 : n == 0 ? 0 : 1; |
| } |
| |
| /** Returns {@code WindowListener} instance that diposes {@code Window} on |
| * "window closing" event. |
| * |
| * @return the {@code WindowListener} instance that could be set |
| * on a {@code Window}. After that |
| * the {@code Window} is disposed when "window closed" |
| * event is sent to the {@code Window} |
| */ |
| public static WindowListener getClosingWindowAdapter() { |
| return new WindowAdapter () { |
| public void windowClosing(WindowEvent e) { |
| e.getWindow().dispose(); |
| } |
| }; |
| } |
| |
| /* |
| * The values directly map to the ones of |
| * sun.awt.X11.XWM & sun.awt.motif.MToolkit classes. |
| */ |
| public final static int |
| UNDETERMINED_WM = 1, |
| NO_WM = 2, |
| OTHER_WM = 3, |
| OPENLOOK_WM = 4, |
| MOTIF_WM = 5, |
| CDE_WM = 6, |
| ENLIGHTEN_WM = 7, |
| KDE2_WM = 8, |
| SAWFISH_WM = 9, |
| ICE_WM = 10, |
| METACITY_WM = 11, |
| COMPIZ_WM = 12, |
| LG3D_WM = 13, |
| CWM_WM = 14, |
| MUTTER_WM = 15; |
| |
| /* |
| * Returns -1 in case of not X Window or any problems. |
| */ |
| public static int getWMID() { |
| Class clazz = null; |
| try { |
| if ("sun.awt.X11.XToolkit".equals(Toolkit.getDefaultToolkit().getClass().getName())) { |
| clazz = Class.forName("sun.awt.X11.XWM"); |
| } else if ("sun.awt.motif.MToolkit".equals(Toolkit.getDefaultToolkit().getClass().getName())) { |
| clazz = Class.forName("sun.awt.motif.MToolkit"); |
| } |
| } catch (ClassNotFoundException cnfe) { |
| cnfe.printStackTrace(); |
| } |
| if (clazz == null) { |
| return -1; |
| } |
| |
| try { |
| final Class _clazz = clazz; |
| Method m_addExports = Class.forName("java.awt.Helper").getDeclaredMethod("addExports", String.class, java.lang.Module.class); |
| // No MToolkit anymore: nothing to do about it. |
| // We may be called from non-X11 system, and this permission cannot be delegated to a test. |
| m_addExports.invoke(null, "sun.awt.X11", Util.class.getModule()); |
| Method m_getWMID = (Method)AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| try { |
| Method method = _clazz.getDeclaredMethod("getWMID", new Class[] {}); |
| if (method != null) { |
| method.setAccessible(true); |
| } |
| return method; |
| } catch (NoSuchMethodException e) { |
| assert false; |
| } catch (SecurityException e) { |
| assert false; |
| } |
| return null; |
| } |
| }); |
| return ((Integer)m_getWMID.invoke(null, new Object[] {})).intValue(); |
| } catch (ClassNotFoundException cnfe) { |
| cnfe.printStackTrace(); |
| } catch (NoSuchMethodException nsme) { |
| nsme.printStackTrace(); |
| } catch (IllegalAccessException iae) { |
| iae.printStackTrace(); |
| } catch (InvocationTargetException ite) { |
| ite.printStackTrace(); |
| } |
| return -1; |
| } |
| |
| //Cleans all the references |
| public static void cleanUp() { |
| apListener = null; |
| fgListener = null; |
| wgfListener = null; |
| } |
| |
| |
| //////////////////////////// |
| // Some stuff to test focus. |
| //////////////////////////// |
| |
| private static WindowGainedFocusListener wgfListener = new WindowGainedFocusListener(); |
| private static FocusGainedListener fgListener = new FocusGainedListener(); |
| private static ActionPerformedListener apListener = new ActionPerformedListener(); |
| |
| private abstract static class EventListener { |
| AtomicBoolean notifier = new AtomicBoolean(false); |
| Component comp; |
| boolean printEvent; |
| |
| public void listen(Component comp, boolean printEvent) { |
| this.comp = comp; |
| this.printEvent = printEvent; |
| notifier.set(false); |
| setListener(comp); |
| } |
| |
| public AtomicBoolean getNotifier() { |
| return notifier; |
| } |
| |
| abstract void setListener(Component comp); |
| |
| void printAndNotify(AWTEvent e) { |
| if (printEvent) { |
| System.err.println(e); |
| } |
| synchronized (notifier) { |
| notifier.set(true); |
| notifier.notifyAll(); |
| } |
| } |
| } |
| |
| private static class WindowGainedFocusListener extends EventListener implements WindowFocusListener { |
| |
| void setListener(Component comp) { |
| ((Window)comp).addWindowFocusListener(this); |
| } |
| |
| public void windowGainedFocus(WindowEvent e) { |
| |
| ((Window)comp).removeWindowFocusListener(this); |
| printAndNotify(e); |
| } |
| |
| public void windowLostFocus(WindowEvent e) {} |
| } |
| |
| private static class FocusGainedListener extends EventListener implements FocusListener { |
| |
| void setListener(Component comp) { |
| comp.addFocusListener(this); |
| } |
| |
| public void focusGained(FocusEvent e) { |
| comp.removeFocusListener(this); |
| printAndNotify(e); |
| } |
| |
| public void focusLost(FocusEvent e) {} |
| } |
| |
| private static class ActionPerformedListener extends EventListener implements ActionListener { |
| |
| void setListener(Component comp) { |
| ((Button)comp).addActionListener(this); |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| ((Button)comp).removeActionListener(this); |
| printAndNotify(e); |
| } |
| } |
| |
| private static boolean trackEvent(int eventID, Component comp, Runnable action, int time, boolean printEvent) { |
| EventListener listener = null; |
| |
| switch (eventID) { |
| case WindowEvent.WINDOW_GAINED_FOCUS: |
| listener = wgfListener; |
| break; |
| case FocusEvent.FOCUS_GAINED: |
| listener = fgListener; |
| break; |
| case ActionEvent.ACTION_PERFORMED: |
| listener = apListener; |
| break; |
| } |
| |
| listener.listen(comp, printEvent); |
| action.run(); |
| return Util.waitForCondition(listener.getNotifier(), time); |
| } |
| |
| /* |
| * Tracks WINDOW_GAINED_FOCUS event for a window caused by an action. |
| * @param window the window to track the event for |
| * @param action the action to perform |
| * @param time the max time to wait for the event |
| * @param printEvent should the event received be printed or doesn't |
| * @return true if the event has been received, otherwise false |
| */ |
| public static boolean trackWindowGainedFocus(Window window, Runnable action, int time, boolean printEvent) { |
| return trackEvent(WindowEvent.WINDOW_GAINED_FOCUS, window, action, time, printEvent); |
| } |
| |
| /* |
| * Tracks FOCUS_GAINED event for a component caused by an action. |
| * @see #trackWindowGainedFocus |
| */ |
| public static boolean trackFocusGained(Component comp, Runnable action, int time, boolean printEvent) { |
| return trackEvent(FocusEvent.FOCUS_GAINED, comp, action, time, printEvent); |
| } |
| |
| /* |
| * Tracks ACTION_PERFORMED event for a button caused by an action. |
| * @see #trackWindowGainedFocus |
| */ |
| public static boolean trackActionPerformed(Button button, Runnable action, int time, boolean printEvent) { |
| return trackEvent(ActionEvent.ACTION_PERFORMED, button, action, time, printEvent); |
| } |
| |
| /* |
| * Requests focus on the component provided and waits for the result. |
| * @return true if the component has been focused, false otherwise. |
| */ |
| public static boolean focusComponent(Component comp, int time) { |
| return focusComponent(comp, time, false); |
| } |
| public static boolean focusComponent(final Component comp, int time, boolean printEvent) { |
| return trackFocusGained(comp, |
| new Runnable() { |
| public void run() { |
| comp.requestFocus(); |
| } |
| }, |
| time, printEvent); |
| |
| } |
| |
| |
| /** |
| * Invokes the <code>task</code> on the EDT thread. |
| * |
| * @return result of the <code>task</code> |
| */ |
| public static <T> T invokeOnEDT(final java.util.concurrent.Callable<T> task) throws Exception { |
| final java.util.List<T> result = new java.util.ArrayList<T>(1); |
| final Exception[] exception = new Exception[1]; |
| |
| javax.swing.SwingUtilities.invokeAndWait(new Runnable() { |
| |
| @Override |
| public void run() { |
| try { |
| result.add(task.call()); |
| } catch (Exception e) { |
| exception[0] = e; |
| } |
| } |
| }); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| |
| return result.get(0); |
| } |
| |
| } |