jdk/test/sanity/client/lib/jemmy/src/org/netbeans/jemmy/EventTool.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.AWTEvent;
import java.awt.Toolkit;
import java.awt.event.AWTEventListener;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Vector;

/**
 *
 * Provides methods to check last dispatched events, to wait for events of
 * specific types, or to guarantee that events of specific types are not
 * dispatched during some time frame.
 * <BR><BR>
 * All possible listeners are added during this class initialization in case if
 * "jemmy.event_listening" system property is not equal to "no", so, by default,
 * all events are listened.
 *
 * Uses timeouts:<BR>
 * EventTool.WaitEventTimeout - time to wait for AWT events.<BR>
 * EventTool.WaitNoEventTimeout - when checking for the absence of incoming AWT
 * events.<BR>
 * EventTool.EventCheckingDelta - time delta between checks for AWT events.
 *
 * @author Alexandre Iline (alexandre.iline@oracle.com)
 */
public class EventTool implements Timeoutable, Outputable {

    private static final long WAIT_EVENT_TIMEOUT = 60000;
    private static final long WAIT_NO_EVENT_TIMEOUT = 180000;
    private static final long EVENT_CHECKING_DELTA = 10;

    private static ListenerSet listenerSet;
    private static long currentEventMask = 0;

    private TestOut output;
    private Timeouts timeouts;

    /**
     * Constructor.
     */
    public EventTool() {
        setOutput(JemmyProperties.getProperties().getOutput());
        setTimeouts(JemmyProperties.getProperties().getTimeouts());
    }

    /**
     * Returns time of the last dispatched event under mask.
     *
     * @param eventMask Events types to be searched.
     * {@code AWTEvent.*_EVENT_MASK} fields combination.
     * @return time in milliseconds
     * @see #addListeners(long)
     */
    public static long getLastEventTime(long eventMask) {
        return listenerSet.getLastEventTime(eventMask);
    }

    /**
     * Returns last dispatched event under mask.
     *
     * @param eventMask Events types to be searched.
     * {@code AWTEvent.*_EVENT_MASK} fields combination.
     * @return AWTEvent
     * @see #addListeners(long)
     */
    public static AWTEvent getLastEvent(long eventMask) {
        return listenerSet.getLastEvent(eventMask);
    }

    /**
     * Returns time of the last dispatched event.
     *
     * @return time in milliseconds
     * @see #addListeners(long)
     */
    public static long getLastEventTime() {
        return getLastEventTime(listenerSet.getTheWholeMask());
    }

    /**
     * Returns last dispatched event.
     *
     * @return AWTEvent
     * @see #addListeners(long)
     */
    public static AWTEvent getLastEvent() {
        return getLastEvent(listenerSet.getTheWholeMask());
    }

    /**
     * Adds listeners to listen events under mask. Invokes
     * {@code removeListeners()} first, so any event history is lost.
     *
     * @param eventMask Mask to listen events under.
     * {@code AWTEvent.*_EVENT_MASK} fields combination.
     * @see #addListeners()
     * @see #removeListeners()
     */
    public static void addListeners(long eventMask) {
        removeListeners();
        listenerSet.addListeners(eventMask);
        currentEventMask = eventMask;
    }

    /**
     * Adds listeners to listen all types of events. Invokes
     * {@code removeListeners()} first, so any event history is lost. This
     * method is invoked during static section of this class.
     *
     * @see #addListeners(long)
     * @see #removeListeners()
     * @see #getTheWholeEventMask()
     */
    public static void addListeners() {
        addListeners(listenerSet.getTheWholeMask());
    }

    /**
     * Removes all listeners.
     *
     * @see #addListeners(long)
     * @see #addListeners()
     */
    public static void removeListeners() {
        listenerSet.removeListeners();
    }

    /**
     * Returns event mask last time used by {@code addListeners(long)}
     * method. In case if {@code addListeners()} method was used last,
     * {@code getTheWholeEventMask() } result is returned.
     *
     * @return a long representing the current event mask value
     * @see #getTheWholeEventMask()
     */
    public static long getCurrentEventMask() {
        return currentEventMask;
    }

    /**
     * Returns a combination of all {@code AWTEvent.*_EVENT_MASK} fields..
     *
     * @return a combination of all {@code AWTEvent.*_EVENT_MASK} fields.
     */
    public static long getTheWholeEventMask() {
        return listenerSet.getTheWholeMask();
    }

    static {
        Timeouts.initDefault("EventTool.WaitEventTimeout", WAIT_EVENT_TIMEOUT);
        Timeouts.initDefault("EventTool.WaitNoEventTimeout", WAIT_NO_EVENT_TIMEOUT);
        Timeouts.initDefault("EventTool.EventCheckingDelta", EVENT_CHECKING_DELTA);
        listenerSet = new ListenerSet();
        if (System.getProperty("jemmy.event_listening") == null
                || !System.getProperty("jemmy.event_listening").equals("no")) {
            listenerSet.addListeners();
        }
    }

    /**
     * Defines current timeouts.
     *
     * @param ts ?t? A collection of timeout assignments.
     * @see org.netbeans.jemmy.Timeouts
     * @see org.netbeans.jemmy.Timeoutable
     * @see #getTimeouts
     */
    @Override
    public void setTimeouts(Timeouts ts) {
        timeouts = ts;
    }

    /**
     * Return current timeouts.
     *
     * @return the collection of current timeout assignments.
     * @see org.netbeans.jemmy.Timeouts
     * @see org.netbeans.jemmy.Timeoutable
     * @see #setTimeouts
     */
    @Override
    public Timeouts getTimeouts() {
        return timeouts;
    }

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

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

    /**
     * Waits for the first event under mask. Waits during
     * {@code EventTool.WaitEventTimeout} milliseconds.
     *
     * @param eventMask Mask to wait events under.
     * {@code AWTEvent.*_EVENT_MASK} fields combination.
     * @return an AWTEvent object
     * @see #waitEvent()
     * @throws TimeoutExpiredException
     */
    public AWTEvent waitEvent(long eventMask) {
        return (waitEvent(eventMask,
                timeouts.getTimeout("EventTool.WaitEventTimeout"),
                output.createErrorOutput()));
    }

    /**
     * Waits for the first event. Waits during
     * {@code EventTool.WaitEventTimeout} milliseconds.
     *
     * @return an AWTEvent object
     * @see #waitEvent(long)
     * @see #getTheWholeEventMask()
     * @throws TimeoutExpiredException
     */
    public AWTEvent waitEvent() {
        return waitEvent(listenerSet.getTheWholeMask());
    }

    /**
     * Check that no event under mask will be dispatched during time specified.
     *
     * @param eventMask Mask to wait events under.
     * {@code AWTEvent.*_EVENT_MASK} fields combination.
     * @param waitTime Quiet time (millisecons).
     * @return true if no event ahs found.
     * @see #checkNoEvent(long)
     */
    public boolean checkNoEvent(long eventMask, long waitTime) {
        return checkNoEvent(eventMask, waitTime, output);
    }

    /**
     * Check that no event will be dispatched during time specified.
     *
     * @param waitTime Quiet time (millisecons).
     * @return true if no event ahs found.
     * @see #checkNoEvent(long, long)
     * @see #getTheWholeEventMask()
     */
    public boolean checkNoEvent(long waitTime) {
        return checkNoEvent(listenerSet.getTheWholeMask(), waitTime);
    }

    /**
     * During {@code EventTool.WaitNoEventTimeout} time waits for true
     * result of checkNoEvent(long, long) method.
     *
     * @param eventMask Mask to wait events under.
     * {@code AWTEvent.*_EVENT_MASK} fields combination.
     * @param waitTime Quiet time (millisecons).
     * @see #checkNoEvent(long, long)
     * @see #waitNoEvent(long)
     * @throws TimeoutExpiredException
     */
    public void waitNoEvent(long eventMask, long waitTime) {
        NoEventWaiter waiter = new NoEventWaiter(eventMask, waitTime);
        waiter.setTimeouts(timeouts.cloneThis());
        waiter.getTimeouts().
                setTimeout("Waiter.WaitingTime",
                        timeouts.getTimeout("EventTool.WaitNoEventTimeout"));
        waiter.getTimeouts().
                setTimeout("Waiter.TimeDelta",
                        timeouts.getTimeout("EventTool.EventCheckingDelta"));
        try {
            waiter.waitAction(null);
        } catch (InterruptedException e) {
            output.printStackTrace(e);
        }
    }

    /**
     * During {@code EventTool.WaitNoEventTimeout} time waits for true
     * result of {@code checkNoEvent(long)} method.
     *
     * @param waitTime Quiet time (millisecons).
     * @see #checkNoEvent(long)
     * @see #waitNoEvent(long, long)
     * @throws TimeoutExpiredException
     */
    public void waitNoEvent(long waitTime) {
        ListenerSet ls = listenerSet;
        if (ls != null) {
            // surprisingly this field can be null in case of massive
            // garbage collecting efforts like in NbTestCase.assertGC
            waitNoEvent(ls.getTheWholeMask(), waitTime);
        }
    }

    private AWTEvent waitEvent(long eventMask, long waitTime, TestOut waiterOutput) {
        EventWaiter waiter = new EventWaiter(eventMask);
        waiter.setTimeouts(timeouts.cloneThis());
        waiter.setOutput(waiterOutput);
        waiter.getTimeouts().
                setTimeout("Waiter.WaitingTime",
                        waitTime);
        waiter.getTimeouts().
                setTimeout("Waiter.TimeDelta",
                        timeouts.getTimeout("EventTool.EventCheckingDelta"));
        try {
            return waiter.waitAction(null);
        } catch (InterruptedException e) {
            output.printStackTrace(e);
            return null;
        }
    }

    private boolean checkNoEvent(long eventMask, long waitTime, TestOut waiterOutput) {
        try {
            AWTEvent event = waitEvent(eventMask, waitTime, TestOut.getNullOutput());
            waiterOutput.printLine("AWT event was produced during waiting: ");
            // used instead of event.toString() because it is not thread safe
            waiterOutput.printLine(event.getClass().getName());
            return false;
        } catch (TimeoutExpiredException e) {
            return true;
        }
    }

    private static class EventType implements AWTEventListener {

        long eventMask;
        long eventTime;
        private Reference<AWTEvent> eventRef;

        public EventType(long eventMask) {
            this.eventMask = eventMask;
            eventRef = new WeakReference<>(null);
            eventTime = -1;
        }

        @Override
        public void eventDispatched(AWTEvent event) {
            eventRef = new WeakReference<>(event);
            eventTime = System.currentTimeMillis();
        }

        public AWTEvent getEvent() {
            return eventRef.get();
        }

        public long getTime() {
            return eventTime;
        }

        public long getEventMask() {
            return eventMask;
        }
    }

    private static class ListenerSet {

        private Vector<EventType> eventTypes;
        private long theWholeMask;

        public ListenerSet() {
            eventTypes = new Vector<>();
            try {
                Class<?> eventClass = Class.forName("java.awt.AWTEvent");
                Field[] fields = eventClass.getFields();
                theWholeMask = 0;
                long eventMask;
                for (Field field : fields) {
                    if ((field.getModifiers()
                            & (Modifier.PUBLIC | Modifier.STATIC)) != 0
                            && field.getType().equals(Long.TYPE)
                            && field.getName().endsWith("_EVENT_MASK")) {
                        eventMask = (Long) field.get(null);
                        eventTypes.add(new EventType(eventMask));
                        theWholeMask = theWholeMask | eventMask;
                    }
                }
            } catch (ClassNotFoundException | IllegalAccessException e) {
                JemmyProperties.getCurrentOutput().printStackTrace(e);
            }
        }

        public void addListeners(long eventMask) {
            Toolkit dtk = Toolkit.getDefaultToolkit();
            for (EventType et : eventTypes) {
                if ((et.getEventMask() & eventMask) != 0) {
                    dtk.addAWTEventListener(et, et.getEventMask());
                }
            }
        }

        public void addListeners() {
            addListeners(getTheWholeMask());
        }

        public void removeListeners() {
            Toolkit dtk = Toolkit.getDefaultToolkit();
            for (EventType eventType : eventTypes) {
                dtk.removeAWTEventListener(eventType);
            }
        }

        public long getTheWholeMask() {
            return theWholeMask;
        }

        public long getLastEventTime(long eventMask) {
            EventType et = getLastEventType(eventMask);
            return (et == null) ? -1 : et.getTime();
        }

        public AWTEvent getLastEvent(long eventMask) {
            EventType et = getLastEventType(eventMask);
            return (et == null) ? null : et.getEvent();
        }

        private EventType getLastEventType(long eventMask) {
            long maxTime = -1;
            EventType maxType = null;
            for (EventType et : eventTypes) {
                if ((eventMask & et.getEventMask()) != 0
                        && et.getTime() > maxTime) {
                    maxType = et;
                    maxTime = maxType.getTime();
                }
            }
            return maxType;
        }
    }

    private static class EventWaiter extends Waiter<AWTEvent, Void> {

        long eventMask;
        long startTime;

        public EventWaiter(long eventMask) {
            this.eventMask = eventMask;
            startTime = getLastEventTime(eventMask);
        }

        @Override
        public AWTEvent actionProduced(Void obj) {
            EventType et = listenerSet.getLastEventType(eventMask);
            if (et != null
                    && et.getTime() > startTime) {
                return et.getEvent();
            } else {
                return null;
            }
        }

        @Override
        public String getDescription() {
            return ("Last event under "
                    + Long.toString(eventMask, 2) + " event mask");
        }

        @Override
        public String toString() {
            return "EventWaiter{" + "eventMask=" + Long.toString(eventMask, 2) + ", startTime=" + startTime + '}';
        }
    }

    private class NoEventWaiter extends Waiter<String, Void> {

        long eventMask;
        long waitTime;

        public NoEventWaiter(long eventMask, long waitTime) {
            this.eventMask = eventMask;
            this.waitTime = waitTime;
        }

        @Override
        public String actionProduced(Void obj) {
            return (checkNoEvent(eventMask, waitTime, TestOut.getNullOutput())
                    ? "Reached!"
                    : null);
        }

        @Override
        public String getDescription() {
            return ("No event under "
                    + Long.toString(eventMask, 2)
                    + " event mask during "
                    + Long.toString(waitTime)
                    + " milliseconds");
        }

        @Override
        public String toString() {
            return "NoEventWaiter{" + "eventMask=" + Long.toString(eventMask, 2) + ", waitTime=" + waitTime + '}';
        }
    }
}