| /* |
| * 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()); |
| } |
| }); |
| } |
| } |