netbeans/jemmy/WindowWaiter.java

/*
 * 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.Component;
import java.awt.Frame;
import java.awt.Window;
import java.util.stream.Stream;

/**
 * A WindowWaiter is a utility class used to look or wait for Windows. It
 * contains methods to search for a Window among the currently showing Windows
 * as well as methods that wait for a Window to show within an allotted time
 * period.
 *
 * Searches and waits always involve search criteria applied by a
 * ComponentChooser instance. Searches and waits can both be restricted to
 * windows owned by a given window.
 *
 * <BR>Timeouts used: <BR>
 * WindowWaiter.WaitWindowTimeout - time to wait window displayed <BR>
 * WindowWaiter.AfterWindowTimeout - time to sleep after window has been
 * dispayed <BR>
 *
 * @see org.netbeans.jemmy.Timeouts
 *
 * @author Alexandre Iline (alexandre.iline@oracle.com)
 */
public class WindowWaiter extends Waiter<Window, Void> implements Timeoutable {

    public static boolean FIND_INVISIBLE_WINDOWS = false;

    private final static long WAIT_TIME = 60000;
    private final static long AFTER_WAIT_TIME = 0;

    private ComponentChooser chooser;
    private Window owner = null;
    private int index = 0;
    private Timeouts timeouts;

    /**
     * Constructor.
     */
    public WindowWaiter() {
        super();
        setTimeouts(JemmyProperties.getProperties().getTimeouts());
    }

    /**
     * Searches for a window. The search proceeds among the currently showing
     * windows for the {@code index+1}'th window that is both owned by the
     * {@code java.awt.Window} {@code owner} and that meets the
     * criteria defined and applied by the {@code ComponentChooser}
     * parameter.
     *
     * @param owner The owner window of all the windows to be searched.
     * @param cc A component chooser used to define and apply the search
     * criteria.
     * @param index The ordinal index of the window in the set of currently
     * displayed windows with the proper window ownership and a suitable title.
     * The first index is 0.
     * @return a reference to the {@code index+1}'th window that is
     * showing, has the proper window ownership, and that meets the search
     * criteria. If there are fewer than {@code index+1} windows, a
     * {@code null} reference is returned.
     */
    public static Window getWindow(Window owner, ComponentChooser cc, int index) {
        return getAWindow(owner, new IndexChooser(cc, index));
    }

    /**
     * Searches for a window. Search among the currently showing windows for the
     * first that is both owned by the {@code java.awt.Window}
     * {@code owner} and that meets the search criteria applied by the
     * {@code ComponentChooser} parameter.
     *
     * @param owner The owner window of the windows to be searched.
     * @param cc A component chooser used to define and apply the search
     * criteria.
     * @return a reference to the first window that is showing, has a proper
     * owner window, and that meets the search criteria. If no such window can
     * be found, a {@code null} reference is returned.
     */
    public static Window getWindow(Window owner, ComponentChooser cc) {
        return getWindow(owner, cc, 0);
    }

    /**
     * Searches for a window. The search proceeds among the currently showing
     * windows for the {@code index+1}'th window that meets the criteria
     * defined and applied by the {@code ComonentChooser} parameter.
     *
     * @param cc A component chooser used to define and apply the search
     * criteria.
     * @param index The ordinal index of the window in the set of currently
     * displayed windows. The first index is 0.
     * @return a reference to the {@code index+1}'th window that is showing
     * and that meets the search criteria. If there are fewer than
     * {@code index+1} windows, a {@code null} reference is returned.
     */
    public static Window getWindow(ComponentChooser cc, int index) {
        return getAWindow(new IndexChooser(cc, index));
    }

    /**
     * Searches for a window. Search among the currently showing windows for one
     * that meets the search criteria applied by the
     * {@code ComponentChooser} parameter.
     *
     * @param cc A component chooser used to define and apply the search
     * criteria.
     * @return a reference to the first window that is showing and that meets
     * the search criteria. If no such window can be found, a {@code null}
     * reference is returned.
     */
    public static Window getWindow(ComponentChooser cc) {
        return getWindow(cc, 0);
    }

    static {
        Timeouts.initDefault("WindowWaiter.WaitWindowTimeout", WAIT_TIME);
        Timeouts.initDefault("WindowWaiter.AfterWindowTimeout", AFTER_WAIT_TIME);
    }

    /**
     * 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;
        Timeouts times = timeouts.cloneThis();
        times.setTimeout("Waiter.WaitingTime",
                timeouts.getTimeout("WindowWaiter.WaitWindowTimeout"));
        times.setTimeout("Waiter.AfterWaitingTime",
                timeouts.getTimeout("WindowWaiter.AfterWindowTimeout"));
        setWaitingTimeOrigin("WindowWaiter.WaitWindowTimeout");
        super.setTimeouts(times);
    }

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

    /**
     * Action producer--get a window. Get a window. The search uses constraints
     * on window ownership, ordinal index, and search criteria defined by an
     * instance of {@code org.netbeans.jemmy.ComponentChooser}.
     *
     * @param obj Not used.
     * @return the window waited upon. If a window cannot be found then a
     * {@code null} reference is returned.
     * @see org.netbeans.jemmy.Action
     */
    @Override
    public Window actionProduced(Void obj) {
        return WindowWaiter.getWindow(owner, chooser, index);
    }

    /**
     * Waits for a window to show. Wait for the {@code index+1}'th window
     * that meets the criteria defined and applied by the
     * {@code ComonentChooser} parameter to show up.
     *
     * @param ch A component chooser used to define and apply the search
     * criteria.
     * @param index The ordinal index of the window in the set of currently
     * displayed windows. The first index is 0.
     * @return a reference to the {@code index+1}'th window that shows and
     * that meets the search criteria. If fewer than {@code index+1}
     * windows show up in the allotted time period then a {@code null}
     * reference is returned.
     * @throws TimeoutExpiredException
     * @see #actionProduced(Object)
     * @exception InterruptedException
     */
    public Window waitWindow(ComponentChooser ch, int index)
            throws InterruptedException {
        chooser = ch;
        owner = null;
        this.index = index;
        return waitWindow();
    }

    /**
     * Waits for a window to show. Wait for a window that meets the search
     * criteria applied by the {@code ComponentChooser} parameter to show
     * up.
     *
     * @param ch A component chooser used to define and apply the search
     * criteria.
     * @return a reference to the first window that shows and that meets the
     * search criteria. If no such window can be found within the time period
     * allotted, a {@code null} reference is returned.
     * @throws TimeoutExpiredException
     * @see #actionProduced(Object)
     * @exception InterruptedException
     */
    public Window waitWindow(ComponentChooser ch)
            throws InterruptedException {
        return waitWindow(ch, 0);
    }

    /**
     * Waits for a window to show. Wait for the {@code index+1}'th window
     * to show that is both owned by the {@code java.awt.Window}
     * {@code o} and that meets the criteria defined and applied by the
     * {@code ComponentChooser} parameter.
     *
     * @param o The owner window of all the windows to be searched.
     * @param ch A component chooser used to define and apply the search
     * criteria.
     * @param index The ordinal index of the window in the set of currently
     * displayed windows with the proper window ownership and a suitable title.
     * The first index is 0.
     * @return a reference to the {@code index+1}'th window to show that
     * has the proper window ownership, and that meets the search criteria. If
     * there are fewer than {@code index+1} windows, a {@code null}
     * reference is returned.
     * @throws TimeoutExpiredException
     * @see #actionProduced(Object)
     * @exception InterruptedException
     */
    public Window waitWindow(Window o, ComponentChooser ch, int index)
            throws InterruptedException {
        owner = o;
        chooser = ch;
        this.index = index;
        return waitAction(null);
    }

    /**
     * Waits for a window to show. Wait for the first window to show that is
     * both owned by the {@code java.awt.Window} {@code o} and that
     * meets the criteria defined and applied by the
     * {@code ComponentChooser} parameter.
     *
     * @param o The owner window of all the windows to be searched.
     * @param ch A component chooser used to define and apply the search
     * criteria.
     * @return a reference to the first window to show that has the proper
     * window ownership, and that meets the search criteria. If there is no such
     * window, a {@code null} reference is returned.
     * @throws TimeoutExpiredException
     * @see #actionProduced(Object)
     * @exception InterruptedException
     */
    public Window waitWindow(Window o, ComponentChooser ch)
            throws InterruptedException {
        return waitWindow(o, ch, 0);
    }

    /**
     * Wait till the count of windows which meet the the search criteria becomes
     * equal to count.
     *
     * @param ch a component chooser used to define and apply the search
     * criteria.
     * @param count the number of expected windows meeting the search criteria.
     * @throws InterruptedException
     */
    public static void waitWindowCount(ComponentChooser ch, int count)
            throws InterruptedException {
        waitWindowCount(null, ch, count);
    }

    /**
     * Wait till the count of windows which meet the the search criteria becomes
     * equal to count.
     *
     * @param owner The owner window of all the windows to be checked
     * @param ch a component chooser used to define and apply the search
     * criteria.
     * @param count the number of expected windows meeting the search criteria.
     * @throws InterruptedException
     */
    public static void waitWindowCount(Window owner, ComponentChooser ch, int count)
            throws InterruptedException {
        Waiter<String, Void> stateWaiter = new Waiter<>(new Waitable<String, Void>() {
            @Override
            public String actionProduced(Void obj) {
                return countWindows(owner, ch) == count ? "" : null;
            }

            @Override
            public String getDescription() {
                return "Wait till the count of windows matching the criteria "
                        + "specified by ComponentChooser reaches :" + count;
            }

            @Override
            public String toString() {
                return "Operator.waitState.Waitable{description = "
                        + getDescription() + '}';
            }
        });
        stateWaiter.waitAction(null);
    }

    /**
     * Counts all the windows owned by the owner window which match the
     * criterion specified by component chooser.
     *
     * @param owner The owner window of all the windows to be checked
     * @param ch A component chooser used to define and apply the search
     * criteria
     * @return the number of matched windows
     */
    public static int countWindows(Window owner, ComponentChooser ch) {
        return new QueueTool().invokeAndWait(new QueueTool.QueueAction<Integer>(null) {

            @Override
            public Integer launch() {
                Window[] windows;
                if (owner == null) {
                    windows = Window.getWindows();
                } else {
                    windows = owner.getOwnedWindows();
                }
                return (int) Stream.of(windows)
                        .filter(x -> ch.checkComponent(x)).count();
            }
        });
    }

    /**
     * Counts all the windows which match the criterion specified by component
     * chooser.
     *
     * @param ch A component chooser used to define and apply the search
     * criteria
     * @return the number of matched windows
     */
    public static int countWindows(ComponentChooser ch) {
        return countWindows(null, ch);
    }

    @Override
    public String getDescription() {
        return chooser.getDescription();
    }

    @Override
    public String toString() {
        return "WindowWaiter{" + "chooser=" + chooser + ", owner=" + owner + ", index=" + index + '}';
    }

    /**
     * Method can be used by a subclass to define chooser.
     *
     * @param ch a chooser specifying searching criteria.
     * @see #getComponentChooser
     */
    protected void setComponentChooser(ComponentChooser ch) {
        chooser = ch;
    }

    /**
     * Method can be used by a subclass to define chooser.
     *
     * @return a chooser specifying searching criteria.
     * @see #setComponentChooser
     */
    protected ComponentChooser getComponentChooser() {
        return chooser;
    }

    /**
     * Method can be used by a subclass to define window owner.
     *
     * @param owner Window-owner of the set of windows.
     * @see #getOwner
     */
    protected void setOwner(Window owner) {
        this.owner = owner;
    }

    /**
     * Method can be used by a subclass to define window owner.
     *
     * @return Window-owner of the set of windows.
     * @see #setOwner
     */
    protected Window getOwner() {
        return owner;
    }

    /**
     * @see org.netbeans.jemmy.Waiter#getWaitingStartedMessage()
     */
    @Override
    protected String getWaitingStartedMessage() {
        return "Start to wait window \"" + chooser.getDescription() + "\" opened";
    }

    /**
     * Overrides Waiter.getTimeoutExpiredMessage.
     *
     * @see org.netbeans.jemmy.Waiter#getTimeoutExpiredMessage(long)
     * @param timeSpent time from waiting start (milliseconds)
     * @return a message.
     */
    @Override
    protected String getTimeoutExpiredMessage(long timeSpent) {
        return ("Window \"" + chooser.getDescription() + "\" has not been opened in "
                + timeSpent + " milliseconds");
    }

    /**
     * Overrides Waiter.getActionProducedMessage.
     *
     * @see org.netbeans.jemmy.Waiter#getActionProducedMessage(long, Object)
     * @param timeSpent time from waiting start (milliseconds)
     * @param result result of Waitable.actionproduced method.
     * @return a message.
     */
    @Override
    protected String getActionProducedMessage(long timeSpent, final Object result) {
        String resultToString;
        if (result instanceof Component) {
            // run toString in dispatch thread
            resultToString = new QueueTool().invokeSmoothly(
                    new QueueTool.QueueAction<String>("result.toString()") {
                @Override
                public String launch() {
                    return result.toString();
                }
            }
            );
        } else {
            resultToString = result.toString();
        }
        return ("Window \"" + chooser.getDescription() + "\" has been opened in "
                + timeSpent + " milliseconds"
                + "\n    " + resultToString);
    }

    /**
     * @return a message.
     * @see org.netbeans.jemmy.Waiter#getGoldenWaitingStartedMessage()
     */
    @Override
    protected String getGoldenWaitingStartedMessage() {
        return "Start to wait window \"" + chooser.getDescription() + "\" opened";
    }

    /**
     * @return a message.
     * @see org.netbeans.jemmy.Waiter#getGoldenTimeoutExpiredMessage()
     */
    @Override
    protected String getGoldenTimeoutExpiredMessage() {
        return "Window \"" + chooser.getDescription() + "\" has not been opened";
    }

    /**
     * @return a message.
     * @see org.netbeans.jemmy.Waiter#getGoldenActionProducedMessage()
     */
    @Override
    protected String getGoldenActionProducedMessage() {
        return "Window \"" + chooser.getDescription() + "\" has been opened";
    }

    private static Window getAWindow(Window owner, ComponentChooser cc) {
        if (owner == null) {
            return WindowWaiter.getAWindow(cc);
        } else {
            Window result = null;
            Window[] windows = owner.getOwnedWindows();
            for (Window window : windows) {
                if (cc.checkComponent(window)) {
                    return window;
                }
                if ((result = WindowWaiter.getWindow(window, cc)) != null) {
                    return result;
                }
            }
            return null;
        }
    }

    private static Window getAWindow(ComponentChooser cc) {
        Window result = null;
        Frame[] frames = Frame.getFrames();
        for (Frame frame : frames) {
            if (cc.checkComponent(frame)) {
                return frame;
            }
            if ((result = WindowWaiter.getWindow(frame, cc)) != null) {
                return result;
            }
        }
        return null;
    }

    private Window waitWindow()
            throws InterruptedException {
        return waitAction(null);
    }

    private static class IndexChooser implements ComponentChooser {

        private int curIndex = 0;
        private int index;
        private ComponentChooser chooser;

        public IndexChooser(ComponentChooser ch, int i) {
            index = i;
            chooser = ch;
            curIndex = 0;
        }

        @Override
        public boolean checkComponent(Component comp) {
            if ((FIND_INVISIBLE_WINDOWS || (comp.isShowing() && comp.isVisible()))
                    && chooser.checkComponent(comp)) {
                if (curIndex == index) {
                    return true;
                }
                curIndex++;
            }
            return false;
        }

        @Override
        public String getDescription() {
            return chooser.getDescription();
        }

        @Override
        public String toString() {
            return "IndexChooser{" + "curIndex=" + curIndex + ", index=" + index + ", chooser=" + chooser + '}';
        }
    }
}