1 /*

     2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 import java.awt.Component;

    25 import java.awt.Frame;

    26 import java.awt.Dialog;

    27 import java.awt.Window;

    28 import java.awt.Button;

    29 import java.awt.Point;

    30 import java.awt.Dimension;

    31 import java.awt.Rectangle;

    32 import java.awt.Robot;

    33 import java.awt.Toolkit;

    34 import java.awt.IllegalComponentStateException;

    35 import java.awt.AWTException;

    36 import java.awt.AWTEvent;

    37 

    38 import java.awt.event.InputEvent;

    39 import java.awt.event.WindowAdapter;

    40 import java.awt.event.WindowEvent;

    41 import java.awt.event.ActionEvent;

    42 import java.awt.event.FocusEvent;

    43 import java.awt.event.WindowListener;

    44 import java.awt.event.WindowFocusListener;

    45 import java.awt.event.FocusListener;

    46 import java.awt.event.ActionListener;

    47 

    48 import java.awt.peer.FramePeer;

    49 

    50 import java.lang.reflect.Constructor;

    51 import java.lang.reflect.Field;

    52 import java.lang.reflect.InvocationTargetException;

    53 import java.lang.reflect.Method;

    54 

    55 import java.security.PrivilegedAction;

    56 import java.security.AccessController;

    57 

    58 import java.util.concurrent.atomic.AtomicBoolean;

    59 

    60 /**

    61  * <p>This class contains utilities useful for regression testing.

    62  * <p>When using jtreg you would include this class into the build

    63  * list via something like:

    64  * <pre>

    65      &library ../../../../share/lib/AWT_Mixing/src/regtesthelpers/

    66      &build Util

    67      &run main YourTest

    68    </pre>

    69  * Note that if you are about to create a test based on

    70  * Applet-template, then put those lines into html-file, not in java-file.

    71  * <p> And put an

    72  * import regtesthelpers.Util;

    73  * into the java source of test.

    74 */

    75 public final class Util {

    76     private Util() {} // this is a helper class with static methods :)

    77 

    78     /*

    79      * @throws RuntimeException when creation failed

    80      */

    81     public static Robot createRobot() {

    82         try {

    83             return new Robot();

    84         } catch (AWTException e) {

    85             throw new RuntimeException("Error: unable to create robot", e);

    86         }

    87     }

    88 

    89     public static Frame createEmbeddedFrame(final Frame embedder)

    90         throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException,

    91                InstantiationException, InvocationTargetException

    92     {

    93         Toolkit tk = Toolkit.getDefaultToolkit();

    94         FramePeer frame_peer = (FramePeer) embedder.getPeer();

    95         System.out.println("frame's peer = " + frame_peer);

    96         if ("sun.awt.windows.WToolkit".equals(tk.getClass().getName())) {

    97             Class comp_peer_class =

    98                 Class.forName("sun.awt.windows.WComponentPeer");

    99             System.out.println("comp peer class = " + comp_peer_class);

   100             Field hwnd_field = comp_peer_class.getDeclaredField("hwnd");

   101             hwnd_field.setAccessible(true);

   102             System.out.println("hwnd_field =" + hwnd_field);

   103             long hwnd = hwnd_field.getLong(frame_peer);

   104             System.out.println("hwnd = " + hwnd);

   105 

   106             Class clazz = Class.forName("sun.awt.windows.WEmbeddedFrame");

   107             Constructor constructor = clazz.getConstructor (new Class [] {Long.TYPE});

   108             return (Frame) constructor.newInstance (new Object[] {hwnd});

   109         } else if ("sun.awt.X11.XToolkit".equals(tk.getClass().getName())) {

   110             Class x_base_window_class = Class.forName("sun.awt.X11.XBaseWindow");

   111             System.out.println("x_base_window_class = " + x_base_window_class);

   112             Method get_window = x_base_window_class.getMethod("getWindow", new Class[0]);

   113             System.out.println("get_window = " + get_window);

   114             long window = (Long) get_window.invoke(frame_peer, new Object[0]);

   115             System.out.println("window = " + window);

   116             Class clazz = Class.forName("sun.awt.X11.XEmbeddedFrame");

   117             Constructor constructor = clazz.getConstructor (new Class [] {Long.TYPE, Boolean.TYPE});

   118             return (Frame) constructor.newInstance (new Object[] {window, true});

   119         }

   120 

   121         throw new RuntimeException("Unexpected toolkit - " + tk);

   122     }

   123 

   124     /**

   125      * Makes the window visible and waits until it's shown.

   126      */

   127     public static void showWindowWait(Window win) {

   128         win.setVisible(true);

   129         waitTillShown(win);

   130     }

   131 

   132     /**

   133      * Moves mouse pointer in the center of given {@code comp} component

   134      * using {@code robot} parameter.

   135      */

   136     public static void pointOnComp(final Component comp, final Robot robot) {

   137         Rectangle bounds = new Rectangle(comp.getLocationOnScreen(), comp.getSize());

   138         robot.mouseMove(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);

   139     }

   140 

   141     /**

   142      * Moves mouse pointer in the center of a given {@code comp} component

   143      * and performs a left mouse button click using the {@code robot} parameter

   144      * with the {@code delay} delay between press and release.

   145      */

   146     public static void clickOnComp(final Component comp, final Robot robot, int delay) {

   147         pointOnComp(comp, robot);

   148         robot.delay(delay);

   149         robot.mousePress(InputEvent.BUTTON1_MASK);

   150         robot.delay(delay);

   151         robot.mouseRelease(InputEvent.BUTTON1_MASK);

   152     }

   153 

   154     /**

   155      * Moves mouse pointer in the center of a given {@code comp} component

   156      * and performs a left mouse button click using the {@code robot} parameter

   157      * with the default delay between press and release.

   158      */

   159     public static void clickOnComp(final Component comp, final Robot robot) {

   160         clickOnComp(comp, robot, 50);

   161     }

   162 

   163     /*

   164      * Clicks on a title of Frame/Dialog.

   165      * WARNING: it may fail on some platforms when the window is not wide enough.

   166      */

   167     public static void clickOnTitle(final Window decoratedWindow, final Robot robot) {

   168         Point p = decoratedWindow.getLocationOnScreen();

   169         Dimension d = decoratedWindow.getSize();

   170 

   171         if (decoratedWindow instanceof Frame || decoratedWindow instanceof Dialog) {

   172             robot.mouseMove(p.x + (int)(d.getWidth()/2), p.y + (int)decoratedWindow.getInsets().top/2);

   173             robot.delay(50);

   174             robot.mousePress(InputEvent.BUTTON1_MASK);

   175             robot.delay(50);

   176             robot.mouseRelease(InputEvent.BUTTON1_MASK);

   177         }

   178     }

   179 

   180     public static void waitForIdle(final Robot robot) {

   181         // we do not use robot for now, use SunToolkit.realSync() instead

   182         ((sun.awt.SunToolkit)Toolkit.getDefaultToolkit()).realSync();

   183     }

   184 

   185     public static Field getField(final Class klass, final String fieldName) {

   186         return AccessController.doPrivileged(new PrivilegedAction<Field>() {

   187             public Field run() {

   188                 try {

   189                     Field field = klass.getDeclaredField(fieldName);

   190                     assert (field != null);

   191                     field.setAccessible(true);

   192                     return field;

   193                 } catch (SecurityException se) {

   194                     throw new RuntimeException("Error: unexpected exception caught!", se);

   195                 } catch (NoSuchFieldException nsfe) {

   196                     throw new RuntimeException("Error: unexpected exception caught!", nsfe);

   197                 }

   198             }

   199         });

   200     }

   201 

   202     /*

   203      * Waits for a notification and for a boolean condition to become true.

   204      * The method returns when the above conditions are fullfilled or when the timeout

   205      * occurs.

   206      *

   207      * @param condition the object to be notified and the booelan condition to wait for

   208      * @param timeout the maximum time to wait in milliseconds

   209      * @param catchExceptions if {@code true} the method catches InterruptedException

   210      * @return the final boolean value of the {@code condition}

   211      * @throws InterruptedException if the awaiting proccess has been interrupted

   212      */

   213     public static boolean waitForConditionEx(final AtomicBoolean condition, long timeout)

   214       throws InterruptedException

   215         {

   216             synchronized (condition) {

   217                 long startTime = System.currentTimeMillis();

   218                 while (!condition.get()) {

   219                     condition.wait(timeout);

   220                     if (System.currentTimeMillis() - startTime >= timeout ) {

   221                         break;

   222                     }

   223                 }

   224             }

   225             return condition.get();

   226         }

   227 

   228     /*

   229      * The same as {@code waitForConditionEx(AtomicBoolean, long)} except that it

   230      * doesn't throw InterruptedException.

   231      */

   232     public static boolean waitForCondition(final AtomicBoolean condition, long timeout) {

   233         try {

   234             return waitForConditionEx(condition, timeout);

   235         } catch (InterruptedException e) {

   236             throw new RuntimeException("Error: unexpected exception caught!", e);

   237         }

   238     }

   239 

   240     /*

   241      * The same as {@code waitForConditionEx(AtomicBoolean, long)} but without a timeout.

   242      */

   243     public static void waitForConditionEx(final AtomicBoolean condition)

   244       throws InterruptedException

   245         {

   246             synchronized (condition) {

   247                 while (!condition.get()) {

   248                     condition.wait();

   249                 }

   250             }

   251         }

   252 

   253     /*

   254      * The same as {@code waitForConditionEx(AtomicBoolean)} except that it

   255      * doesn't throw InterruptedException.

   256      */

   257     public static void waitForCondition(final AtomicBoolean condition) {

   258         try {

   259             waitForConditionEx(condition);

   260         } catch (InterruptedException e) {

   261             throw new RuntimeException("Error: unexpected exception caught!", e);

   262         }

   263     }

   264 

   265     public static void waitTillShownEx(final Component comp) throws InterruptedException {

   266         while (true) {

   267             try {

   268                 Thread.sleep(100);

   269                 comp.getLocationOnScreen();

   270                 break;

   271             } catch (IllegalComponentStateException e) {}

   272         }

   273     }

   274     public static void waitTillShown(final Component comp) {

   275         try {

   276             waitTillShownEx(comp);

   277         } catch (InterruptedException e) {

   278             throw new RuntimeException("Error: unexpected exception caught!", e);

   279         }

   280     }

   281 

   282     /**

   283      * Drags from one point to another with the specified mouse button pressed.

   284      *

   285      * @param robot a robot to use for moving the mouse, etc.

   286      * @param startPoint a start point of the drag

   287      * @param endPoint an end point of the drag

   288      * @param button one of {@code InputEvent.BUTTON1_MASK},

   289      *     {@code InputEvent.BUTTON2_MASK}, {@code InputEvent.BUTTON3_MASK}

   290      *

   291      * @throws IllegalArgumentException if {@code button} is not one of

   292      *     {@code InputEvent.BUTTON1_MASK}, {@code InputEvent.BUTTON2_MASK},

   293      *     {@code InputEvent.BUTTON3_MASK}

   294      */

   295     public static void drag(Robot robot, Point startPoint, Point endPoint, int button) {

   296         if (!(button == InputEvent.BUTTON1_MASK || button == InputEvent.BUTTON2_MASK

   297                 || button == InputEvent.BUTTON3_MASK))

   298         {

   299             throw new IllegalArgumentException("invalid mouse button");

   300         }

   301 

   302         robot.mouseMove(startPoint.x, startPoint.y);

   303         robot.mousePress(button);

   304         try {

   305             mouseMove(robot, startPoint, endPoint);

   306         } finally {

   307             robot.mouseRelease(button);

   308         }

   309     }

   310 

   311     /**

   312      * Moves the mouse pointer from one point to another.

   313      * Uses Bresenham's algorithm.

   314      *

   315      * @param robot a robot to use for moving the mouse

   316      * @param startPoint a start point of the drag

   317      * @param endPoint an end point of the drag

   318      */

   319     public static void mouseMove(Robot robot, Point startPoint, Point endPoint) {

   320         int dx = endPoint.x - startPoint.x;

   321         int dy = endPoint.y - startPoint.y;

   322 

   323         int ax = Math.abs(dx) * 2;

   324         int ay = Math.abs(dy) * 2;

   325 

   326         int sx = signWOZero(dx);

   327         int sy = signWOZero(dy);

   328 

   329         int x = startPoint.x;

   330         int y = startPoint.y;

   331 

   332         int d = 0;

   333 

   334         if (ax > ay) {

   335             d = ay - ax/2;

   336             while (true){

   337                 robot.mouseMove(x, y);

   338                 robot.delay(50);

   339 

   340                 if (x == endPoint.x){

   341                     return;

   342                 }

   343                 if (d >= 0){

   344                     y = y + sy;

   345                     d = d - ax;

   346                 }

   347                 x = x + sx;

   348                 d = d + ay;

   349             }

   350         } else {

   351             d = ax - ay/2;

   352             while (true){

   353                 robot.mouseMove(x, y);

   354                 robot.delay(50);

   355 

   356                 if (y == endPoint.y){

   357                     return;

   358                 }

   359                 if (d >= 0){

   360                     x = x + sx;

   361                     d = d - ay;

   362                 }

   363                 y = y + sy;

   364                 d = d + ax;

   365             }

   366         }

   367     }

   368 

   369     private static int signWOZero(int i){

   370         return (i > 0)? 1: -1;

   371     }

   372 

   373     private static int sign(int n) {

   374         return n < 0 ? -1 : n == 0 ? 0 : 1;

   375     }

   376 

   377     /** Returns {@code WindowListener} instance that diposes {@code Window} on

   378      *  "window closing" event.

   379      *

   380      * @return    the {@code WindowListener} instance that could be set

   381      *            on a {@code Window}. After that

   382      *            the {@code Window} is disposed when "window closed"

   383      *            event is sent to the {@code Window}

   384      */

   385     public static WindowListener getClosingWindowAdapter() {

   386         return new WindowAdapter () {

   387             public void windowClosing(WindowEvent e) {

   388                 e.getWindow().dispose();

   389             }

   390         };

   391     }

   392 

   393     /*

   394      * The values directly map to the ones of

   395      * sun.awt.X11.XWM & sun.awt.motif.MToolkit classes.

   396      */

   397     public final static int

   398         UNDETERMINED_WM = 1,

   399         NO_WM = 2,

   400         OTHER_WM = 3,

   401         OPENLOOK_WM = 4,

   402         MOTIF_WM = 5,

   403         CDE_WM = 6,

   404         ENLIGHTEN_WM = 7,

   405         KDE2_WM = 8,

   406         SAWFISH_WM = 9,

   407         ICE_WM = 10,

   408         METACITY_WM = 11,

   409         COMPIZ_WM = 12,

   410         LG3D_WM = 13;

   411 

   412     /*

   413      * Returns -1 in case of not X Window or any problems.

   414      */

   415     public static int getWMID() {

   416         Class clazz = null;

   417         try {

   418             if ("sun.awt.X11.XToolkit".equals(Toolkit.getDefaultToolkit().getClass().getName())) {

   419                 clazz = Class.forName("sun.awt.X11.XWM");

   420             } else if ("sun.awt.motif.MToolkit".equals(Toolkit.getDefaultToolkit().getClass().getName())) {

   421                 clazz = Class.forName("sun.awt.motif.MToolkit");

   422             }

   423         } catch (ClassNotFoundException cnfe) {

   424             cnfe.printStackTrace();

   425         }

   426         if (clazz == null) {

   427             return -1;

   428         }

   429 

   430         try {

   431             final Class _clazz = clazz;

   432             Method m_getWMID = (Method)AccessController.doPrivileged(new PrivilegedAction() {

   433                     public Object run() {

   434                         try {

   435                             Method method = _clazz.getDeclaredMethod("getWMID", new Class[] {});

   436                             if (method != null) {

   437                                 method.setAccessible(true);

   438                             }

   439                             return method;

   440                         } catch (NoSuchMethodException e) {

   441                             assert false;

   442                         } catch (SecurityException e) {

   443                             assert false;

   444                         }

   445                         return null;

   446                     }

   447                 });

   448             return ((Integer)m_getWMID.invoke(null, new Object[] {})).intValue();

   449         } catch (IllegalAccessException iae) {

   450             iae.printStackTrace();

   451         } catch (InvocationTargetException ite) {

   452             ite.printStackTrace();

   453         }

   454         return -1;

   455     }

   456 

   457 

   458     ////////////////////////////

   459     // Some stuff to test focus.

   460     ////////////////////////////

   461 

   462     private static WindowGainedFocusListener wgfListener = new WindowGainedFocusListener();

   463     private static FocusGainedListener fgListener = new FocusGainedListener();

   464     private static ActionPerformedListener apListener = new ActionPerformedListener();

   465 

   466     private abstract static class EventListener {

   467         AtomicBoolean notifier = new AtomicBoolean(false);

   468         Component comp;

   469         boolean printEvent;

   470 

   471         public void listen(Component comp, boolean printEvent) {

   472             this.comp = comp;

   473             this.printEvent = printEvent;

   474             notifier.set(false);

   475             setListener(comp);

   476         }

   477 

   478         public AtomicBoolean getNotifier() {

   479             return notifier;

   480         }

   481 

   482         abstract void setListener(Component comp);

   483 

   484         void printAndNotify(AWTEvent e) {

   485             if (printEvent) {

   486                 System.err.println(e);

   487             }

   488             synchronized (notifier) {

   489                 notifier.set(true);

   490                 notifier.notifyAll();

   491             }

   492         }

   493     }

   494 

   495     private static class WindowGainedFocusListener extends EventListener implements WindowFocusListener {

   496 

   497         void setListener(Component comp) {

   498             ((Window)comp).addWindowFocusListener(this);

   499         }

   500 

   501         public void windowGainedFocus(WindowEvent e) {

   502 

   503             ((Window)comp).removeWindowFocusListener(this);

   504             printAndNotify(e);

   505         }

   506 

   507         public void windowLostFocus(WindowEvent e) {}

   508     }

   509 

   510     private static class FocusGainedListener extends EventListener implements FocusListener {

   511 

   512         void setListener(Component comp) {

   513             comp.addFocusListener(this);

   514         }

   515 

   516         public void focusGained(FocusEvent e) {

   517             comp.removeFocusListener(this);

   518             printAndNotify(e);

   519         }

   520 

   521         public void focusLost(FocusEvent e) {}

   522     }

   523 

   524     private static class ActionPerformedListener extends EventListener implements ActionListener {

   525 

   526         void setListener(Component comp) {

   527             ((Button)comp).addActionListener(this);

   528         }

   529 

   530         public void actionPerformed(ActionEvent e) {

   531             ((Button)comp).removeActionListener(this);

   532             printAndNotify(e);

   533         }

   534     }

   535 

   536     private static boolean trackEvent(int eventID, Component comp, Runnable action, int time, boolean printEvent) {

   537         EventListener listener = null;

   538 

   539         switch (eventID) {

   540         case WindowEvent.WINDOW_GAINED_FOCUS:

   541             listener = wgfListener;

   542             break;

   543         case FocusEvent.FOCUS_GAINED:

   544             listener = fgListener;

   545             break;

   546         case ActionEvent.ACTION_PERFORMED:

   547             listener = apListener;

   548             break;

   549         }

   550 

   551         listener.listen(comp, printEvent);

   552         action.run();

   553         return Util.waitForCondition(listener.getNotifier(), time);

   554     }

   555 

   556     /*

   557      * Tracks WINDOW_GAINED_FOCUS event for a window caused by an action.

   558      * @param window the window to track the event for

   559      * @param action the action to perform

   560      * @param time the max time to wait for the event

   561      * @param printEvent should the event received be printed or doesn't

   562      * @return true if the event has been received, otherwise false

   563      */

   564     public static boolean trackWindowGainedFocus(Window window, Runnable action, int time, boolean printEvent) {

   565         return trackEvent(WindowEvent.WINDOW_GAINED_FOCUS, window, action, time, printEvent);

   566     }

   567 

   568     /*

   569      * Tracks FOCUS_GAINED event for a component caused by an action.

   570      * @see #trackWindowGainedFocus

   571      */

   572     public static boolean trackFocusGained(Component comp, Runnable action, int time, boolean printEvent) {

   573         return trackEvent(FocusEvent.FOCUS_GAINED, comp, action, time, printEvent);

   574     }

   575 

   576     /*

   577      * Tracks ACTION_PERFORMED event for a button caused by an action.

   578      * @see #trackWindowGainedFocus

   579      */

   580     public static boolean trackActionPerformed(Button button, Runnable action, int time, boolean printEvent) {

   581         return trackEvent(ActionEvent.ACTION_PERFORMED, button, action, time, printEvent);

   582     }

   583 

   584     /*

   585      * Requests focus on the component provided and waits for the result.

   586      * @return true if the component has been focused, false otherwise.

   587      */

   588     public static boolean focusComponent(Component comp, int time) {

   589         return focusComponent(comp, time, false);

   590     }

   591     public static boolean focusComponent(final Component comp, int time, boolean printEvent) {

   592         return trackFocusGained(comp,

   593                                 new Runnable() {

   594                                     public void run() {

   595                                         comp.requestFocus();

   596                                     }

   597                                 },

   598                                 time, printEvent);

   599 

   600     }

   601 }