/*
* Copyright (c) 1997, 2016, 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 org.netbeans.jemmy;
import java.awt.AWTEvent;
import java.awt.Component;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.AWTEventListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.WindowEvent;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* Provides low level functions for reproducing user actions. One dispatch model
* uses the managed component's event queue to dispatch events. The other
* dispatch model uses {@code java.awt.Robot} to generate native events. It
* is an option in the Robot dispatch model to wait for the managed component's
* event queue to empty before dispatching events.
*
* Timeouts used: <BR>
* EventDispatcher.WaitQueueEmptyTimeout - to wait event queue empty. <BR>
* EventDispatcher.RobotAutoDelay - param for java.awt.Robot.setAutoDelay
* method. <BR>
* EventDispatcher.WaitComponentUnderMouseTimeout - time to wait component under
* mouse. <BR>
*
* @see org.netbeans.jemmy.Timeouts
*
* @author Alexandre Iline (alexandre.iline@oracle.com)
*
*/
public class EventDispatcher implements Outputable, Timeoutable {
private static final long WAIT_QUEUE_EMPTY_TIMEOUT = 180000;
private static final long ROBOT_AUTO_DELAY = 10;
private static final long WAIT_COMPONENT_UNDER_MOUSE_TIMEOUT = 60000;
private static Field[] keyFields;
private static volatile MotionListener motionListener = null;
/**
* Component to dispatch events to.
*/
protected Component component;
private TestOut output;
private Timeouts timeouts;
private final ClassReference reference;
private int model;
private ClassReference robotReference = null;
private boolean outsider = false;
private final QueueTool queueTool;
/**
* Constructor.
*
* @param comp Component to operate with.
*/
public EventDispatcher(Component comp) {
super();
component = comp;
reference = new ClassReference(comp);
queueTool = new QueueTool();
setOutput(JemmyProperties.getProperties().getOutput());
setTimeouts(JemmyProperties.getProperties().getTimeouts());
setDispatchingModel(JemmyProperties.getProperties().getDispatchingModel());
}
/**
* Waits for the managed component's {@code java.awt.EventQueue} to
* empty. The timeout for this wait is
* EventDispatcher.WaitQueueEmptyTimeout.
*
* @param output Output to print exception into.
* @param timeouts A collection of timeout assignments.
* @throws TimeoutExpiredException
* @see org.netbeans.jemmy.QueueTool
*/
public static void waitQueueEmpty(TestOut output, Timeouts timeouts) {
QueueTool qt = new QueueTool();
qt.setTimeouts(timeouts.cloneThis());
qt.getTimeouts().
setTimeout("QueueTool.WaitQueueEmptyTimeout",
JemmyProperties.
getCurrentTimeout("EventDispatcher.WaitQueueEmptyTimeout"));
qt.setOutput(output);
qt.waitEmpty();
}
/**
* Waits for the managed component's {@code java.awt.EventQueue} to
* empty. Uses default output and timeouts. The timeout for this wait is
* EventDispatcher.WaitQueueEmptyTimeout.
*
* @see QueueTool
* @throws TimeoutExpiredException
*/
public static void waitQueueEmpty() {
waitQueueEmpty(JemmyProperties.getCurrentOutput(),
JemmyProperties.getCurrentTimeouts());
}
/**
* Waits for the managed component's {@code java.awt.EventQueue} to
* stay empty. The timeout for this wait is
* EventDispatcher.WaitQueueEmptyTimeout.
*
* @param emptyTime The time that the event queue has to stay empty to avoid
* a TimeoutExpiredException.
* @param output Output to print exception into
* @param timeouts A collection of timeout assignments.
* @throws TimeoutExpiredException
* @see org.netbeans.jemmy.QueueTool
*/
public static void waitQueueEmpty(long emptyTime, TestOut output, Timeouts timeouts) {
QueueTool qt = new QueueTool();
qt.setTimeouts(timeouts.cloneThis());
qt.getTimeouts().
setTimeout("QueueTool.WaitQueueEmptyTimeout",
JemmyProperties.
getCurrentTimeout("EventDispatcher.WaitQueueEmptyTimeout"));
qt.setOutput(output);
qt.waitEmpty(emptyTime);
}
/**
* Waits for the managed component's {@code java.awt.EventQueue} to
* stay empty. Uses default output and timeouts. The timeout for this wait
* is EventDispatcher.WaitQueueEmptyTimeout.
*
* @param emptyTime The time that the event queue has to stay empty to avoid
* a TimeoutExpiredException.
* @throws TimeoutExpiredException
* @see org.netbeans.jemmy.QueueTool
*/
public static void waitQueueEmpty(long emptyTime) {
waitQueueEmpty(emptyTime,
JemmyProperties.getCurrentOutput(),
JemmyProperties.getCurrentTimeouts());
}
/**
* Get a string representation for key modifiers. Used to print trace.
*
* @param modifiers Bit mask of keyboard event modifiers.
* @return a string representation for the keyboard event modifiers.
*/
public static String getModifiersString(int modifiers) {
String result = "";
if ((modifiers & InputEvent.CTRL_MASK) != 0) {
result = result + "CTRL_MASK | ";
}
if ((modifiers & InputEvent.META_MASK) != 0) {
result = result + "META_MASK | ";
}
if ((modifiers & InputEvent.ALT_MASK) != 0) {
result = result + "ALT_MASK | ";
}
if ((modifiers & InputEvent.ALT_GRAPH_MASK) != 0) {
result = result + "ALT_GRAPH_MASK | ";
}
if ((modifiers & InputEvent.SHIFT_MASK) != 0) {
result = result + "SHIFT_MASK | ";
}
if (result.length() > 0) {
return result.substring(0, result.length() - 3);
}
return result;
}
/**
* Returns a string representation for a keyboard event. Used to print
* trace.
*
* @param keyCode Key code ({@code KeyEvent.VK_*} value)
* @return the KeyEvent field name.
*/
public static String getKeyDescription(int keyCode) {
for (Field keyField : keyFields) {
try {
if (keyField.getName().startsWith("VK_")
&& keyField.getInt(null) == keyCode) {
return keyField.getName();
}
} catch (IllegalAccessException e) {
JemmyProperties.getCurrentOutput().printStackTrace(e);
}
}
return "VK_UNKNOWN";
}
/**
* Returns a mouse button string representation. Used to print trace.
*
* @param button Mouse button ({@code InputEvent.BUTTON1/2/3_MASK}
* value).
* @return InputEvent field name.
*/
public static String getMouseButtonDescription(int button) {
String result;
if ((button & InputEvent.BUTTON1_MASK) != 0) {
result = "BUTTON1";
} else if ((button & InputEvent.BUTTON2_MASK) != 0) {
result = "BUTTON2";
} else if ((button & InputEvent.BUTTON3_MASK) != 0) {
result = "BUTTON3";
} else {
result = "UNKNOWN_BUTTON";
}
return result;
}
public static void performInit() {
Timeouts.initDefault("EventDispatcher.WaitQueueEmptyTimeout", WAIT_QUEUE_EMPTY_TIMEOUT);
Timeouts.initDefault("EventDispatcher.RobotAutoDelay", ROBOT_AUTO_DELAY);
Timeouts.initDefault("EventDispatcher.WaitComponentUnderMouseTimeout", WAIT_COMPONENT_UNDER_MOUSE_TIMEOUT);
try {
keyFields = Class.forName("java.awt.event.KeyEvent").getFields();
} catch (ClassNotFoundException e) {
JemmyProperties.getCurrentOutput().printStackTrace(e);
}
}
static {
performInit();
}
/**
* Wait (or not) for the mouse to move over a Java component before
* pressing. This option is relevant when using {@code java.awt.Robot}
* to generate mouse events. If a mouse press occurs at a position not
* occupied by a known Java component then a
* {@code NoComponentUnderMouseException} will be thrown.
*
* @param yesOrNo if {@code true} then the test system will wait for
* the mouse to move over a Java component before pressing. therwise, mouse
* presses can take place anywhere on the screen.
*/
public void checkComponentUnderMouse(boolean yesOrNo) {
outsider = !yesOrNo;
}
/**
* Defines print output streams or writers.
*
* @param out Identify the streams or writers used for print output.
* @see org.netbeans.jemmy.Outputable
* @see org.netbeans.jemmy.TestOut
* @see #getOutput
*/
@Override
public void setOutput(TestOut out) {
output = out;
queueTool.setOutput(out);
}
/**
* Returns print output streams or writers.
*
* @return an object that contains references to objects for printing to
* output and err streams.
* @see org.netbeans.jemmy.Outputable
* @see org.netbeans.jemmy.TestOut
* @see #setOutput
*/
@Override
public TestOut getOutput() {
return output;
}
/**
* Defines current timeouts.
*
* @param timeouts A collection of timeout assignments.
* @see org.netbeans.jemmy.Timeoutable
* @see org.netbeans.jemmy.Timeouts
* @see #getTimeouts
*/
@Override
public void setTimeouts(Timeouts timeouts) {
this.timeouts = timeouts;
queueTool.setTimeouts(timeouts);
queueTool.getTimeouts().
setTimeout("QueueTool.WaitQueueEmptyTimeout",
timeouts.
getTimeout("EventDispatcher.WaitQueueEmptyTimeout"));
if (robotReference != null) {
try {
Object[] params = {(int) timeouts.getTimeout("EventDispatcher.RobotAutoDelay")};
Class<?>[] paramClasses = {Integer.TYPE};
robotReference.invokeMethod("setAutoDelay", params, paramClasses);
} catch (InvocationTargetException
| IllegalStateException
| NoSuchMethodException
| IllegalAccessException e) {
output.printStackTrace(e);
}
}
}
/**
* Return current timeouts.
*
* @return the collection of current timeout assignments.
* @see org.netbeans.jemmy.Timeoutable
* @see org.netbeans.jemmy.Timeouts
* @see #setTimeouts
*/
@Override
public Timeouts getTimeouts() {
return timeouts;
}
/**
* Defines dispatching model.
*
* @param m New model value.
* @see #getDispatchingModel()
* @see org.netbeans.jemmy.JemmyProperties#QUEUE_MODEL_MASK
* @see org.netbeans.jemmy.JemmyProperties#ROBOT_MODEL_MASK
* @see org.netbeans.jemmy.JemmyProperties#getCurrentDispatchingModel()
* @see org.netbeans.jemmy.JemmyProperties#setCurrentDispatchingModel(int)
* @see org.netbeans.jemmy.JemmyProperties#initDispatchingModel(boolean,
* boolean)
* @see org.netbeans.jemmy.JemmyProperties#initDispatchingModel()
*/
public void setDispatchingModel(int m) {
model = m;
if ((model & JemmyProperties.ROBOT_MODEL_MASK) != 0) {
createRobot();
try {
Object[] params = {(model & JemmyProperties.QUEUE_MODEL_MASK) != 0 ? Boolean.TRUE : Boolean.FALSE};
Class<?>[] paramClasses = {Boolean.TYPE};
robotReference.invokeMethod("setAutoWaitForIdle", params, paramClasses);
} catch (InvocationTargetException
| IllegalStateException
| NoSuchMethodException
| IllegalAccessException e) {
output.printStackTrace(e);
}
}
}
/**
* Gets the dispatching model value.
*
* @return the model value.
* @see #setDispatchingModel(int)
* @see org.netbeans.jemmy.JemmyProperties#QUEUE_MODEL_MASK
* @see org.netbeans.jemmy.JemmyProperties#ROBOT_MODEL_MASK
* @see org.netbeans.jemmy.JemmyProperties#getCurrentDispatchingModel()
* @see org.netbeans.jemmy.JemmyProperties#setCurrentDispatchingModel(int)
* @see org.netbeans.jemmy.JemmyProperties#initDispatchingModel(boolean,
* boolean)
* @see org.netbeans.jemmy.JemmyProperties#initDispatchingModel()
*/
public int getDispatchingModel() {
return model;
}
/**
* Dispatches {@code AWTEvent} to component passed in constructor. If
* {@code (getDispatchingModel & JemmyProperties.QUEUE_MODEL_MASK) == 0}
* dispatched event directly, otherwise uses
* {@code javax.swing.SwingUtilities.invokeAndWait(Runnable)}<BR>
*
* @param event AWTEvent instance to be dispatched.
* @throws ComponentIsNotVisibleException
* @throws ComponentIsNotFocusedException
*/
public void dispatchEvent(final AWTEvent event) {
// run in dispatch thread
String eventToString = queueTool.invokeSmoothly(
new QueueTool.QueueAction<String>("event.toString()") {
@Override
public String launch() {
return event.toString();
}
}
);
output.printLine("Dispatch event " + eventToString);
output.printGolden("Dispatch event " + event.getClass().toString());
Dispatcher<Void> disp = new Dispatcher<>(event);
queueTool.invokeAndWait(disp);
}
/**
* Dispatches a MouseEvent.
*
* @see #dispatchEvent(AWTEvent)
* @param id {@code MouseEvent.MOUSE_*} value
* @param mods {@code InputEvent.MOUSE1/2/3_BUTTON} | (modifiers value)
* @param clickCount Click count
* @param x Horizontal click point coordinate.
* @param y vertical click point coordinate.
* @param popup Defines if mouse event is a popup event.
*/
public void dispatchMouseEvent(int id, int mods, int clickCount, int x, int y,
boolean popup) {
MouseEvent event = new MouseEvent(component, id, System.currentTimeMillis(),
mods, x, y, clickCount, popup);
dispatchEvent(event);
}
/**
* Dispatches MouseEvent at the center of component.
*
* @see #dispatchEvent(AWTEvent)
* @param id {@code MouseEvent.MOUSE_*} value
* @param mods {@code InputEvent.MOUSE1/2/3_BUTTON} | (modiviers value)
* @param clickCount Click count
* @param popup Difines if mouse event is popup event.
*/
public void dispatchMouseEvent(int id, int mods, int clickCount,
boolean popup) {
int x = component.getWidth() / 2;
int y = component.getHeight() / 2;
dispatchMouseEvent(id, mods, clickCount, x, y, popup);
}
/**
* Dispatches WindowEvent.
*
* @see #dispatchEvent(AWTEvent)
* @param id {@code WindowEvent.WINDOW_*} value
*/
public void dispatchWindowEvent(int id) {
WindowEvent event = new WindowEvent((Window) component, id);
dispatchEvent(event);
}
/**
* Dispatches KeyEvent.
*
* @see #dispatchEvent(AWTEvent)
* @param id {@code KeyEvent.KEY_PRESSED} or
* {@code KeyEvent.KEY_RELEASED} value.
* @param mods Modifiers.
* @param keyCode Key code,
*/
@Deprecated
public void dispatchKeyEvent(int id, int mods, int keyCode) {
KeyEvent event = new KeyEvent(component, id, System.currentTimeMillis(), mods, keyCode);
dispatchEvent(event);
}
/**
* Dispatches KeyEvent.
*
* @see #dispatchEvent(AWTEvent)
* @param id {@code KeyEvent.KEY_TYPED} value.
* @param mods Modifiers.
* @param keyCode Key code,
* @param keyChar Char to be tiped
*/
public void dispatchKeyEvent(int id, int mods, int keyCode, char keyChar) {
KeyEvent event = new KeyEvent(component, id, System.currentTimeMillis(),
mods, keyCode, keyChar);
dispatchEvent(event);
}
/**
* Waits until all events currently on the event queue have been processed.
*/
public void waitForIdle() {
makeRobotOperation("waitForIdle", null, null);
}
/**
* Bind horizontal relative cursor coordinate to screen coordinate.
*
* @param x Relative coordinate
* @return Absolute coordinate
*/
protected int getAbsoluteX(int x) {
return (int) component.getLocationOnScreen().getX() + x;
}
/**
* Bind vertical relative cursor coordinate to screen coordinate.
*
* @param y Relative coordinate
* @return Absolute coordinate
*/
protected int getAbsoluteY(int y) {
return (int) component.getLocationOnScreen().getY() + y;
}
/**
* Delays robot.
*
* @param time Time to dalay robot for.
*/
public void delayRobot(long time) {
Object[] params = {(int) time};
Class<?>[] paramClasses = {Integer.TYPE};
makeRobotOperation("delay", params, paramClasses);
}
/**
* Moves mouse by robot.
*
* @param x Component relative horizontal coordinate.
* @param y Component relative vertical coordinate.
* @throws ComponentIsNotVisibleException
*/
public void robotMoveMouse(int x, int y) {
if (motionListener == null) {
initMotionListener();
}
output.printLine("Move mouse to (" + Integer.toString(x) + ","
+ Integer.toString(y) + ")");
Object[] params = {getAbsoluteX(x), getAbsoluteY(y)};
Class<?>[] paramClasses = {Integer.TYPE, Integer.TYPE};
makeRobotOperation("mouseMove", params, paramClasses);
}
/**
* Press mouse button by robot.
*
* @param button Mouse button (InputEvent.MOUSE1/2/3_BUTTON value)
* @param modifiers Modifiers
* @throws ComponentIsNotVisibleException
*/
public void robotPressMouse(int button, int modifiers) {
if (!outsider) {
waitMouseOver();
}
robotPressModifiers(modifiers);
output.printLine("Press " + getMouseButtonDescription(button) + " mouse button");
Object[] params = {button};
Class<?>[] paramClasses = {Integer.TYPE};
makeRobotOperation("mousePress", params, paramClasses);
}
/**
* Press mouse button with 0 modifiers.
*
* @param button Mouse button ({@code InputEvent.MOUSE1/2/3_BUTTON}
* value)
* @see #robotPressMouse(int, int)
*/
public void robotPressMouse(int button) {
robotPressMouse(button, 0);
}
/**
* Releases mouse button by robot.
*
* @param button Mouse button ({@code InputEvent.MOUSE1/2/3_BUTTON}
* value)
* @param modifiers Modifiers
* @throws ComponentIsNotVisibleException
*/
public void robotReleaseMouse(int button, int modifiers) {
output.printLine("Release " + getMouseButtonDescription(button) + " mouse button");
Object[] params = {button};
Class<?>[] paramClasses = {Integer.TYPE};
makeRobotOperation("mouseRelease", params, paramClasses);
robotReleaseModifiers(modifiers);
}
/**
* Releases mouse button with 0 modifiers.
*
* @param button Mouse button ({@code InputEvent.MOUSE1/2/3_BUTTON}
* value)
* @see #robotReleaseMouse(int, int)
*/
public void robotReleaseMouse(int button) {
robotReleaseMouse(button, 0);
}
/**
* Press a key using {@code java.awt.Robot}.
*
* @param keyCode Key ({@code KeyEvent.VK_*} value)
* @param modifiers Mask of KeyEvent modifiers.
* @throws ComponentIsNotVisibleException
* @throws ComponentIsNotFocusedException
*/
public void robotPressKey(int keyCode, int modifiers) {
robotPressModifiers(modifiers);
output.printLine("Press " + getKeyDescription(keyCode) + " key");
Object[] params = {keyCode};
Class<?>[] paramClasses = {Integer.TYPE};
makeRobotOperation("keyPress", params, paramClasses);
}
/**
* Press key with no modifiers using {@code java.awt.Robot}.
*
* @param keyCode Key ({@code KeyEvent.VK_*} value)
* @see #robotPressKey(int, int)
*/
public void robotPressKey(int keyCode) {
robotPressKey(keyCode, 0);
}
/**
* Releases key by robot.
*
* @param keyCode Key ({@code KeyEvent.VK_*} value)
* @param modifiers Mask of KeyEvent modifiers.
* @throws ComponentIsNotVisibleException
* @throws ComponentIsNotFocusedException
*/
public void robotReleaseKey(int keyCode, int modifiers) {
output.printLine("Release " + getKeyDescription(keyCode) + " key");
Object[] params = {keyCode};
Class<?>[] paramClasses = {Integer.TYPE};
makeRobotOperation("keyRelease", params, paramClasses);
robotReleaseModifiers(modifiers);
}
/**
* Releases key with 0 modifiers.
*
* @param keyCode Key ({@code KeyEvent.VK_*} value)
* @see #robotPressKey(int, int)
*/
public void robotReleaseKey(int keyCode) {
robotReleaseKey(keyCode, 0);
}
/**
* Invokes component method through
* {@code SwingUtilities.invokeAndWait(Runnable)}.
*
* @param method_name Name of a method to be invoked
* @param params Method params
* @param params_classes Method params' classes
* @return an Object - methods result.
* @see org.netbeans.jemmy.ClassReference
* @exception IllegalAccessException
* @exception NoSuchMethodException
* @exception IllegalStateException
* @exception InvocationTargetException
*/
public Object invokeMethod(String method_name, Object[] params, Class<?>[] params_classes)
throws InvocationTargetException, IllegalStateException, NoSuchMethodException, IllegalAccessException {
Invoker invk = new Invoker(method_name, params, params_classes);
try {
return queueTool.invokeAndWait(invk);
} catch (JemmyException e) {
Exception ex = invk.getException();
if (ex != null) {
if (ex instanceof InvocationTargetException) {
InvocationTargetException ite = (InvocationTargetException) ex;
ite.addSuppressed(e);
throw ite;
} else if (ex instanceof IllegalStateException) {
IllegalStateException ise = (IllegalStateException) ex;
ise.addSuppressed(e);
throw ise;
} else if (ex instanceof NoSuchMethodException) {
NoSuchMethodException nsme = (NoSuchMethodException) ex;
nsme.addSuppressed(e);
throw nsme;
} else if (ex instanceof IllegalAccessException) {
IllegalAccessException iae = (IllegalAccessException) ex;
iae.addSuppressed(e);
throw iae;
} else {
e.addSuppressed(ex);
}
}
throw (e);
}
}
/**
* Gets component field value through
* {@code SwingUtilities.invokeAndWait(Runnable)}.
*
* @param field_name Name of a field
* @see #setField(String, Object)
* @see org.netbeans.jemmy.ClassReference
* @return an Object - field value
* @exception IllegalAccessException
* @exception IllegalStateException
* @exception InvocationTargetException
* @exception NoSuchFieldException
*/
public Object getField(String field_name)
throws InvocationTargetException, IllegalStateException, NoSuchFieldException, IllegalAccessException {
Getter gtr = new Getter(field_name);
try {
return queueTool.invokeAndWait(gtr);
} catch (JemmyException e) {
Exception ex = gtr.getException();
if (ex != null) {
if (ex instanceof InvocationTargetException) {
InvocationTargetException ite = (InvocationTargetException) ex;
ite.addSuppressed(e);
throw ite;
} else if (ex instanceof IllegalStateException) {
IllegalStateException ise = (IllegalStateException) ex;
ise.addSuppressed(e);
throw ise;
} else if (ex instanceof NoSuchFieldException) {
NoSuchFieldException nsfe = (NoSuchFieldException) ex;
nsfe.addSuppressed(e);
throw nsfe;
} else if (ex instanceof IllegalAccessException) {
IllegalAccessException iae = (IllegalAccessException) ex;
iae.addSuppressed(e);
throw iae;
} else {
e.addSuppressed(ex);
}
}
throw (e);
}
}
/**
* Sets component field value through
* {@code SwingUtilities.invokeAndWait(Runnable)}.
*
* @param field_name Name of a field
* @param newValue New field value
* @see #getField(String)
* @see org.netbeans.jemmy.ClassReference
* @exception IllegalAccessException
* @exception IllegalStateException
* @exception InvocationTargetException
* @exception NoSuchFieldException
*/
public void setField(String field_name, Object newValue)
throws InvocationTargetException, IllegalStateException, NoSuchFieldException, IllegalAccessException {
Setter str = new Setter(field_name, newValue);
try {
queueTool.invokeAndWait(str);
} catch (JemmyException e) {
Exception ex = str.getException();
if (ex != null) {
if (ex instanceof InvocationTargetException) {
InvocationTargetException ite = (InvocationTargetException) ex;
ite.addSuppressed(e);
throw ite;
} else if (ex instanceof IllegalStateException) {
IllegalStateException ise = (IllegalStateException) ex;
ise.addSuppressed(e);
throw ise;
} else if (ex instanceof NoSuchFieldException) {
NoSuchFieldException nsfe = (NoSuchFieldException) ex;
nsfe.addSuppressed(e);
throw nsfe;
} else if (ex instanceof IllegalAccessException) {
IllegalAccessException iae = (IllegalAccessException) ex;
iae.addSuppressed(e);
throw iae;
} else {
e.addSuppressed(ex);
}
}
throw (e);
}
}
/**
* Invokes component method through
* {@code SwingUtilities.invokeAndWait(Runnable)}. and catch all
* exceptions.
*
* @param method_name Name of a method to be invoked
* @param params Method params
* @param params_classes Method params' classes
* @param out TestOut instance to print exceptions stack trace to.
* @return an Object - method result
* @see #invokeMethod(String, Object[], Class[])
* @see org.netbeans.jemmy.ClassReference
*/
public Object invokeExistingMethod(String method_name, Object[] params, Class<?>[] params_classes,
TestOut out) {
try {
return invokeMethod(method_name, params, params_classes);
} catch (InvocationTargetException
| IllegalStateException
| NoSuchMethodException
| IllegalAccessException e) {
out.printStackTrace(e);
}
return null;
}
/**
* Gets component field value through
* {@code SwingUtilities.invokeAndWait(Runnable)}. and catch all
* exceptions.
*
* @param field_name Name of a field
* @param out TestOut instance to print exceptions stack trace to.
* @return an Object - fields value
* @see #getField(String)
* @see #setExistingField(String, Object, TestOut)
* @see org.netbeans.jemmy.ClassReference
*/
public Object getExistingField(String field_name,
TestOut out) {
try {
return getField(field_name);
} catch (InvocationTargetException
| IllegalStateException
| NoSuchFieldException
| IllegalAccessException e) {
out.printStackTrace(e);
}
return null;
}
/**
* Sets component field value through
* {@code SwingUtilities.invokeAndWait(Runnable)}. and catch all
* exceptions.
*
* @param field_name Name of a field
* @param newValue New field value
* @param out TestOut instance to print exceptions stack trace to.
* @see #setField(String, Object)
* @see #getExistingField(String, TestOut)
* @see org.netbeans.jemmy.ClassReference
*/
public void setExistingField(String field_name, Object newValue,
TestOut out) {
try {
setField(field_name, newValue);
} catch (InvocationTargetException
| IllegalStateException
| NoSuchFieldException
| IllegalAccessException e) {
out.printStackTrace(e);
}
}
/**
* Invokes component method through
* {@code SwingUtilities.invokeAndWait(Runnable)}. and catch all
* exceptions. Exceptions are printed into TestOut object defined by
* setOutput(TestOut) method.
*
* @param method_name Name of a method to be invoked
* @param params Method params
* @param params_classes Method params' classes
* @return an Object - method result
* @see #invokeExistingMethod(String, Object[], Class[], TestOut)
* @see org.netbeans.jemmy.ClassReference
*/
public Object invokeExistingMethod(String method_name, Object[] params, Class<?>[] params_classes) {
return invokeExistingMethod(method_name, params, params_classes, output);
}
/**
* Gets component field value through
* {@code SwingUtilities.invokeAndWait(Runnable)}. and catch all
* exceptions. Exceptions are printed into TestOut object defined by
* setOutput(TestOut) method.
*
* @param field_name Name of a field
* @return an Object - fields value
* @see #getExistingField(String, TestOut)
* @see #setExistingField(String, Object)
* @see org.netbeans.jemmy.ClassReference
*/
public Object getExistingField(String field_name) {
return getExistingField(field_name, output);
}
/**
* Sets component field value through
* {@code SwingUtilities.invokeAndWait(Runnable)}. and catch all
* exceptions. Exceptions are printed into TestOut object defined by
* setOutput(TestOut) method.
*
* @param field_name Name of a field
* @param newValue New field value
* @see #setExistingField(String, Object, TestOut)
* @see #getExistingField(String)
* @see org.netbeans.jemmy.ClassReference
*/
public void setExistingField(String field_name, Object newValue) {
setExistingField(field_name, newValue, output);
}
//recursivelly releases all modifiers keys
private void robotReleaseModifiers(int modifiers) {
if ((modifiers & InputEvent.SHIFT_MASK) != 0) {
robotReleaseKey(KeyEvent.VK_SHIFT, modifiers - (InputEvent.SHIFT_MASK & modifiers));
} else if ((modifiers & InputEvent.ALT_GRAPH_MASK) != 0) {
robotReleaseKey(KeyEvent.VK_ALT_GRAPH, modifiers - (InputEvent.ALT_GRAPH_MASK & modifiers));
} else if ((modifiers & InputEvent.ALT_MASK) != 0) {
robotReleaseKey(KeyEvent.VK_ALT, modifiers - (InputEvent.ALT_MASK & modifiers));
} else if ((modifiers & InputEvent.META_MASK) != 0) {
robotReleaseKey(KeyEvent.VK_META, modifiers - (InputEvent.META_MASK & modifiers));
} else if ((modifiers & InputEvent.CTRL_MASK) != 0) {
robotReleaseKey(KeyEvent.VK_CONTROL, modifiers - (InputEvent.CTRL_MASK & modifiers));
}
}
//throws ComponentIsNotVisibleException if component is not visible
private void checkVisibility() {
if (!component.isVisible()) {
throw (new ComponentIsNotVisibleException(component));
}
}
//throws ComponentIsNotFocusedException if component has not focus
private void checkFocus() {
if (!component.hasFocus()) {
throw (new ComponentIsNotFocusedException(component));
}
}
//creates java.awt.Robot instance
private void createRobot() {
try {
ClassReference robotClassReverence = new ClassReference("java.awt.Robot");
robotReference = new ClassReference(robotClassReverence.newInstance(null, null));
} catch (ClassNotFoundException
| InstantiationException
| InvocationTargetException
| IllegalStateException
| NoSuchMethodException
| IllegalAccessException e) {
output.printStackTrace(e);
}
}
private void waitMouseOver() {
try {
Waiter<String, Component> wt = new Waiter<>(new Waitable<String, Component>() {
@Override
public String actionProduced(Component obj) {
if (motionListener.getComponent() != null) {
return "";
} else {
return null;
}
}
@Override
public String getDescription() {
return "Mouse over component";
}
@Override
public String toString() {
return "waitMouseOver.Waiter{" + getDescription() + '}';
}
});
wt.setTimeoutsToCloneOf(timeouts, "EventDispatcher.WaitComponentUnderMouseTimeout");
wt.setOutput(output.createErrorOutput());
wt.waitAction(component);
} catch (InterruptedException e) {
output.printStackTrace(e);
} catch (TimeoutExpiredException e) {
throw (new NoComponentUnderMouseException());
}
}
//produce a robot operations through reflection
private void makeRobotOperation(String method, Object[] params, Class<?>[] paramClasses) {
try {
robotReference.invokeMethod(method, params, paramClasses);
} catch (InvocationTargetException
| IllegalStateException
| NoSuchMethodException
| IllegalAccessException e) {
output.printStackTrace(e);
}
if ((model & JemmyProperties.QUEUE_MODEL_MASK) != 0) {
try {
waitQueueEmpty(output.createErrorOutput(), timeouts);
} catch (TimeoutExpiredException e) {
output.printStackTrace(e);
}
}
}
//recursivelly presses all modifiers keys
private void robotPressModifiers(int modifiers) {
if ((modifiers & InputEvent.SHIFT_MASK) != 0) {
robotPressKey(KeyEvent.VK_SHIFT, modifiers & ~InputEvent.SHIFT_MASK);
} else if ((modifiers & InputEvent.ALT_GRAPH_MASK) != 0) {
robotPressKey(KeyEvent.VK_ALT_GRAPH, modifiers & ~InputEvent.ALT_GRAPH_MASK);
} else if ((modifiers & InputEvent.ALT_MASK) != 0) {
robotPressKey(KeyEvent.VK_ALT, modifiers & ~InputEvent.ALT_MASK);
} else if ((modifiers & InputEvent.META_MASK) != 0) {
robotPressKey(KeyEvent.VK_META, modifiers & ~InputEvent.META_MASK);
} else if ((modifiers & InputEvent.CTRL_MASK) != 0) {
robotPressKey(KeyEvent.VK_CONTROL, modifiers & ~InputEvent.CTRL_MASK);
}
}
private void initMotionListener() {
synchronized(EventDispatcher.class) {
if (motionListener == null) {
motionListener = new MotionListener();
Toolkit.getDefaultToolkit().addAWTEventListener(motionListener, AWTEvent.MOUSE_EVENT_MASK);
Object[] params = new Object[2];
Class<?>[] paramClasses = {Integer.TYPE, Integer.TYPE};
params[0] = getAbsoluteX(-1);
params[1] = getAbsoluteX(-1);
makeRobotOperation("mouseMove", params, paramClasses);
params[0] = getAbsoluteX(0);
params[1] = getAbsoluteX(0);
makeRobotOperation("mouseMove", params, paramClasses);
}
}
}
private class Dispatcher<R> extends QueueTool.QueueAction<R> {
AWTEvent event;
public Dispatcher(AWTEvent e) {
super(e.getClass().getName() + " event dispatching");
event = e;
}
@Override
public R launch() {
if (event instanceof MouseEvent || event instanceof KeyEvent) {
checkVisibility();
}
component.dispatchEvent(event);
return null;
}
}
private class Invoker extends QueueTool.QueueAction<Object> {
protected String methodName;
protected Object[] params;
protected Class<?>[] paramClasses;
public Invoker(String mn, Object[] p, Class<?>[] pc) {
super(mn + " method invocation");
methodName = mn;
params = p;
paramClasses = pc;
}
@Override
public Object launch()
throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
checkVisibility();
if (methodName.equals("keyPress") || methodName.equals("keyRelease")) {
checkFocus();
}
return reference.invokeMethod(methodName, params, paramClasses);
}
}
private class Getter extends QueueTool.QueueAction<Object> {
String fieldName;
public Getter(String fn) {
super(fn + " field receiving");
fieldName = fn;
}
@Override
public Object launch()
throws InvocationTargetException, NoSuchFieldException, IllegalAccessException {
return reference.getField(fieldName);
}
}
private class Setter extends QueueTool.QueueAction<Object> {
String fieldName;
Object newValue;
public Setter(String fn, Object nv) {
super(fn + " field changing");
fieldName = fn;
newValue = nv;
}
@Override
public Object launch()
throws InvocationTargetException, NoSuchFieldException, IllegalAccessException {
reference.setField(fieldName, newValue);
return null;
}
}
private static class MotionListener implements AWTEventListener {
private volatile Component mouseComponent;
@Override
public void eventDispatched(AWTEvent event) {
if (event instanceof MouseEvent) {
MouseEvent e = (MouseEvent) event;
if (e.getID() == MouseEvent.MOUSE_ENTERED) {
mouseComponent = e.getComponent();
} else if (e.getID() == MouseEvent.MOUSE_EXITED) {
mouseComponent = null;
}
}
}
public Component getComponent() {
return mouseComponent;
}
}
}