/*
* Copyright (c) 2015, 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.jemmy2ext;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Window;
import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.IntStream;
import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JWindow;
import javax.swing.border.Border;
import javax.swing.border.CompoundBorder;
import javax.swing.border.TitledBorder;
import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.DefaultCharBindingMap;
import org.netbeans.jemmy.QueueTool;
import org.netbeans.jemmy.TimeoutExpiredException;
import org.netbeans.jemmy.Waitable;
import org.netbeans.jemmy.Waiter;
import org.netbeans.jemmy.drivers.scrolling.JSpinnerDriver;
import org.netbeans.jemmy.image.StrictImageComparator;
import org.netbeans.jemmy.operators.ComponentOperator;
import org.netbeans.jemmy.operators.ContainerOperator;
import org.netbeans.jemmy.operators.FrameOperator;
import org.netbeans.jemmy.operators.JButtonOperator;
import org.netbeans.jemmy.operators.JFrameOperator;
import org.netbeans.jemmy.operators.JLabelOperator;
import org.netbeans.jemmy.operators.Operator;
import org.netbeans.jemmy.util.Dumper;
import org.netbeans.jemmy.util.PNGEncoder;
import static org.testng.AssertJUnit.*;
/**
* This class solves two tasks: 1. It adds functionality that is missing in
* Jemmy 2. It references all the Jemmy API that is needed by tests so that they
* can just @build JemmyExt class and do not worry about Jemmy
*
* @author akouznet
*/
public class JemmyExt {
/**
* Statically referencing all the classes that are needed by tests so that
* they're compiled by jtreg
*/
static final Class<?>[] DEPENDENCIES = {
JSpinnerDriver.class,
DefaultCharBindingMap.class
};
public static void assertNotBlack(BufferedImage image) {
int w = image.getWidth();
int h = image.getHeight();
try {
assertFalse("All pixels are not black", IntStream.range(0, w).parallel().allMatch(x
-> IntStream.range(0, h).allMatch(y -> (image.getRGB(x, y) & 0xffffff) == 0)
));
} catch (Throwable t) {
save(image, "allPixelsAreBlack.png");
throw t;
}
}
public static void waitArmed(JButtonOperator button) {
button.waitState(new ComponentChooser() {
@Override
public boolean checkComponent(Component comp) {
return isArmed(button);
}
@Override
public String getDescription() {
return "Button is armed";
}
});
}
public static boolean isArmed(JButtonOperator button) {
return button.getQueueTool().invokeSmoothly(new QueueTool.QueueAction<Boolean>("getModel().isArmed()") {
@Override
public Boolean launch() throws Exception {
return ((JButton) button.getSource()).getModel().isArmed();
}
});
}
public static void waitPressed(JButtonOperator button) {
button.waitState(new ComponentChooser() {
@Override
public boolean checkComponent(Component comp) {
return isPressed(button);
}
@Override
public String getDescription() {
return "Button is pressed";
}
});
}
public static boolean isPressed(JButtonOperator button) {
return button.getQueueTool().invokeSmoothly(new QueueTool.QueueAction<Boolean>("getModel().isPressed()") {
@Override
public Boolean launch() throws Exception {
return ((JButton) button.getSource()).getModel().isPressed();
}
});
}
public static void assertEquals(String string, StrictImageComparator comparator, BufferedImage expected, BufferedImage actual) {
try {
assertTrue(string, comparator.compare(expected, actual));
} catch (Error err) {
save(expected, "expected.png");
save(actual, "actual.png");
throw err;
}
}
public static void assertNotEquals(String string, StrictImageComparator comparator, BufferedImage notExpected, BufferedImage actual) {
try {
assertFalse(string, comparator.compare(notExpected, actual));
} catch (Error err) {
save(notExpected, "notExpected.png");
save(actual, "actual.png");
throw err;
}
}
public static void save(BufferedImage image, String filename) {
String filepath = filename;
try {
filepath = new File(filename).getCanonicalPath();
System.out.println("Saving screenshot to " + filepath);
BufferedOutputStream file = new BufferedOutputStream(new FileOutputStream(filepath));
new PNGEncoder(file, PNGEncoder.COLOR_MODE).encode(image);
} catch (IOException ioe) {
throw new RuntimeException("Failed to save image to " + filepath, ioe);
}
}
public static void waitImageIsStill(Robot rob, ComponentOperator operator) {
operator.waitState(new ComponentChooser() {
private BufferedImage previousImage = null;
private int index = 0;
private final StrictImageComparator sComparator = new StrictImageComparator();
@Override
public boolean checkComponent(Component comp) {
BufferedImage currentImage = capture(rob, operator);
save(currentImage, "waitImageIsStill" + index + ".png");
index++;
boolean compareResult = previousImage == null ? false : sComparator.compare(currentImage, previousImage);
previousImage = currentImage;
return compareResult;
}
@Override
public String getDescription() {
return "Image of " + operator + " is still";
}
});
}
private static class ThrowableHolder {
volatile Throwable t;
}
public static void waitFor(String description, RunnableWithException r) throws Exception {
Waiter<Boolean, ThrowableHolder> waiter = new Waiter<>(new Waitable<Boolean, ThrowableHolder>() {
@Override
public Boolean actionProduced(ThrowableHolder obj) {
try {
r.run();
return true;
} catch (Throwable t) {
obj.t = t;
return null;
}
}
@Override
public String getDescription() {
return description;
}
});
ThrowableHolder th = new ThrowableHolder();
try {
waiter.waitAction(th);
} catch (TimeoutExpiredException tee) {
Throwable t = th.t;
if (t != null) {
t.addSuppressed(tee);
if (t instanceof Exception) {
throw (Exception) t;
} else if (t instanceof Error) {
throw (Error) t;
} else if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new IllegalStateException("Unexpected exception type", t);
}
}
}
}
public static BufferedImage capture(Robot rob, ComponentOperator operator) {
Rectangle boundary = new Rectangle(operator.getLocationOnScreen(),
operator.getSize());
return rob.createScreenCapture(boundary);
}
/**
* Dispose all AWT/Swing windows causing event thread to stop
*/
public static void disposeAllWindows() {
System.out.println("disposeAllWindows");
try {
EventQueue.invokeAndWait(() -> {
Window[] windows = Window.getWindows();
for (Window w : windows) {
w.dispose();
}
});
} catch (InterruptedException | InvocationTargetException ex) {
Logger.getLogger(JemmyExt.class.getName()).log(Level.SEVERE, "Failed to dispose all windows", ex);
}
}
/**
* This is a helper class which allows to catch throwables thrown in other
* threads and throw them in the main test thread
*/
public static class MultiThreadedTryCatch {
private final List<Throwable> throwables
= Collections.synchronizedList(new ArrayList<>());
/**
* Throws registered throwables. If the list of the registered
* throwables is not empty, it re-throws the first throwable in the list
* adding all others into its suppressed list. Can be used in any
* thread.
*
* @throws Exception
*/
public void throwRegistered() throws Exception {
Throwable root = null;
synchronized (throwables) {
if (!throwables.isEmpty()) {
root = throwables.remove(0);
while (!throwables.isEmpty()) {
root.addSuppressed(throwables.remove(0));
}
}
}
if (root != null) {
if (root instanceof Error) {
throw (Error) root;
} else if (root instanceof Exception) {
throw (Exception) root;
} else {
throw new AssertionError("Unexpected exception type: " + root.getClass() + " (" + root + ")");
}
}
}
/**
* Registers a throwable and adds it to the list of throwables. Can be
* used in any thread.
*
* @param t
*/
public void register(Throwable t) {
t.printStackTrace();
throwables.add(t);
}
/**
* Registers a throwable and adds it as the first item of the list of
* catched throwables.
*
* @param t
*/
public void registerRoot(Throwable t) {
t.printStackTrace();
throwables.add(0, t);
}
}
/**
* Trying to capture as much information as possible. Currently it includes
* full dump and a screenshot of the whole screen.
*/
public static void captureAll() {
PNGEncoder.captureScreen("failure.png", PNGEncoder.COLOR_MODE);
try {
Dumper.dumpAll("dumpAll.xml");
} catch (FileNotFoundException ex) {
Logger.getLogger(JemmyExt.class.getName()).log(Level.SEVERE, null, ex);
}
captureWindows();
}
/**
* Captures each showing window image using Window.paint() method.
*/
private static void captureWindows() {
try {
EventQueue.invokeAndWait(() -> {
Window[] windows = Window.getWindows();
int index = 0;
for (Window w : windows) {
if (!w.isShowing()) {
continue;
}
BufferedImage img = new BufferedImage(w.getWidth(), w.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics g = img.getGraphics();
w.paint(g);
g.dispose();
try {
ImageIO.write(img, "png", new File("window" + index++ + ".png"));
} catch (IOException e) {
e.printStackTrace();
}
}
});
} catch (InterruptedException | InvocationTargetException ex) {
Logger.getLogger(JemmyExt.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static interface RunnableWithException {
public void run() throws Exception;
}
public static void waitIsFocused(JFrameOperator jfo) {
jfo.waitState(new ComponentChooser() {
@Override
public boolean checkComponent(Component comp) {
return jfo.isFocused();
}
@Override
public String getDescription() {
return "JFrame is focused";
}
});
}
public static int getJWindowCount() {
return new QueueTool().invokeAndWait(new QueueTool.QueueAction<Integer>(null) {
@Override
public Integer launch() throws Exception {
Window[] windows = Window.getWindows();
int windowCount = 0;
for (Window w : windows) {
if (w.getClass().equals(JWindow.class)) {
windowCount++;
}
}
return windowCount;
}
});
}
public static JWindow getJWindow() {
return getJWindow(0);
}
public static JWindow getJWindow(int index) {
return new QueueTool().invokeAndWait(new QueueTool.QueueAction<JWindow>(null) {
@Override
public JWindow launch() throws Exception {
Window[] windows = Window.getWindows();
int windowIndex = 0;
for (Window w : windows) {
if (w.getClass().equals(JWindow.class)) {
if (windowIndex == index) {
return (JWindow) w;
}
windowIndex++;
}
}
return null;
}
});
}
public static boolean isIconified(FrameOperator frameOperator) {
return frameOperator.getQueueTool().invokeAndWait(new QueueTool.QueueAction<Boolean>("Frame is iconified") {
@Override
public Boolean launch() throws Exception {
return (((Frame) frameOperator.getSource()).getState() & Frame.ICONIFIED) != 0;
}
});
}
public static final Operator.DefaultStringComparator EXACT_STRING_COMPARATOR
= new Operator.DefaultStringComparator(true, true);
/**
* Finds a label with the exact labelText and returns the operator for its
* parent container.
*
* @param container
* @param labelText
* @return
*/
public static ContainerOperator<?> getLabeledContainerOperator(ContainerOperator<?> container, String labelText) {
container.setComparator(EXACT_STRING_COMPARATOR);
JLabelOperator jLabelOperator = new JLabelOperator(container, labelText);
assert labelText.equals(jLabelOperator.getText());
return new ContainerOperator<>(jLabelOperator.getParent());
}
/**
* Finds a JPanel with exact title text.
*
* @param container
* @param titleText
* @return
*/
public static ContainerOperator<?> getBorderTitledJPanelOperator(ContainerOperator<?> container, String titleText) {
return new ContainerOperator<>(container, new JPanelByBorderTitleFinder(titleText, EXACT_STRING_COMPARATOR));
}
public static final QueueTool QUEUE_TOOL = new QueueTool();
/**
* Allows to find JPanel by the title text in its border.
*/
public static class JPanelByBorderTitleFinder implements ComponentChooser {
String titleText;
Operator.StringComparator comparator;
/**
* @param titleText title text pattern
* @param comparator specifies string comparison algorithm.
*/
public JPanelByBorderTitleFinder(String titleText, Operator.StringComparator comparator) {
this.titleText = titleText;
this.comparator = comparator;
}
/**
* @param titleText title text pattern
*/
public JPanelByBorderTitleFinder(String titleText) {
this(titleText, Operator.getDefaultStringComparator());
}
@Override
public boolean checkComponent(Component comp) {
assert EventQueue.isDispatchThread();
if (comp instanceof JPanel) {
return checkBorder(((JPanel) comp).getBorder());
}
return false;
}
public boolean checkBorder(Border border) {
if (border instanceof TitledBorder) {
String title = ((TitledBorder) border).getTitle();
return comparator.equals(title, titleText);
} else if (border instanceof CompoundBorder) {
CompoundBorder compoundBorder = (CompoundBorder) border;
return checkBorder(compoundBorder.getInsideBorder()) || checkBorder(compoundBorder.getOutsideBorder());
} else {
return false;
}
}
@Override
public String getDescription() {
return ("JPanel with border title text \"" + titleText + "\" with comparator " + comparator);
}
}
public static class ByClassSimpleNameChooser implements ComponentChooser {
private final String className;
public ByClassSimpleNameChooser(String className) {
this.className = className;
}
@Override
public boolean checkComponent(Component comp) {
return comp.getClass().getSimpleName().equals(className);
}
@Override
public String getDescription() {
return "Component with the simple class name of " + className;
}
}
public static class ByClassChooser implements ComponentChooser {
private final Class<?> clazz;
public ByClassChooser(Class<?> clazz) {
this.clazz = clazz;
}
@Override
public boolean checkComponent(Component comp) {
return comp.getClass().equals(clazz);
}
@Override
public String getDescription() {
return "Component with the class of " + clazz;
}
}
public static class ByToolTipChooser implements ComponentChooser {
private final String tooltip;
public ByToolTipChooser(String tooltip) {
if (tooltip == null) {
throw new NullPointerException("Tooltip cannot be null");
}
this.tooltip = tooltip;
}
@Override
public boolean checkComponent(Component comp) {
return (comp instanceof JComponent)
? tooltip.equals(((JComponent) comp).getToolTipText())
: false;
}
@Override
public String getDescription() {
return "JComponent with the tooltip '" + tooltip + "'";
}
}
@SuppressWarnings(value = "unchecked")
public static <R, O extends Operator, S extends Component> R getUIValue(O operator, Function<S, R> getter) {
return operator.getQueueTool().invokeSmoothly(new QueueTool.QueueAction<R>("getting UI value through the queue using " + getter) {
@Override
public R launch() throws Exception {
return getter.apply((S) operator.getSource());
}
});
}
}