test/jdk/java/awt/EventQueue/InvocationEventTest/InvocationEventTest.java

/*
 * Copyright (c) 2014, 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.
 */


import java.awt.*;
import java.awt.event.*;

/*
 * @test
 * @summary  To Test the following assertions in InvovationEvent.
 * 1.InvocationEvent when dispatched, should invoke the
 *   run() method of the Runnable Interface.
 * 2.If catchExceptions is false, Exception should be
 *   propagated up to the EventDispatchThread's dispatch loop.
 * 3.If catchExceptions is true, InvocationEvent.getExceptions()
 *   should return the exception thrown inside thr run() method.
 * 4.When InvocationEvent object is posted on to the EventQueue,
 *   InvocationEvent.dispatch() method should be invoked by the
 *   EventQueue.
 * 5.If the notifier object is not null, notifyAll() of the
 *   notifier object should be invoked when the run() method returns.
 * 6.To test whether the threads are invoked in the right order
 *   When InvocationEvents are nested.
 * 7.The getWhen method should return timestamp which is less than
 *   current System time and greater than the time before it has
 *   actually happened
 * @author Dmitriy Ermashov (dmitriy.ermashov@oracle.com)
 * @run main InvocationEventTest
 */

public class InvocationEventTest {
    EventQueue eventQ1 = new EventQueue();

    Object lock = new Object();

    static final int delay = 5000;

    public volatile boolean notifierStatus = false;
    public Object notifierLock = new Object();

    public volatile boolean threadStatus = false;
    public volatile boolean childInvoked = false;

    public synchronized void doTest() throws Exception {
        // Testing assertions 1, 2 and 7:
        // 1.InvocationEvent when dispatched, should invoke the
        //   run() method of the Runnable Interface.
        // 2.If catchExceptions is false, Exception should be
        //   propagated up to the EventDispatchThread's dispatch loop.
        // 7.The getWhen method should return timestamp which is less than
        //   current System time and greater than the time before it has
        //   actually happened

        long timeBeforeInvoking = System.currentTimeMillis();

        Thread.sleep(10);

        InvocationEvent invoc = new InvocationEvent(this, () -> { threadStatus = true; }, lock, false);
        invoc.dispatch();

        Thread.sleep(10);

        if (!threadStatus) {
            synchronized (lock) {
                lock.wait(delay);
            }
        }

        // testing getException() when no exception is thrown
        if (invoc.getWhen() <= timeBeforeInvoking ||
                invoc.getWhen() >= System.currentTimeMillis()) {
            throw new RuntimeException("getWhen method is not getting the time at which event occured");
        }

        if (invoc.getException() != null) {
            throw new RuntimeException("InvocationEvent.getException() does not return null " +
                    "when catchException is false");
        }

        // testing the normal behaviour of InvocationEvent
        if (!threadStatus) {
            throw new RuntimeException("InvocationEvent when dispatched, did not" +
                    " invoke the run() of the Runnable interface  ");
        }
        threadStatus = false;

        // Testing assertion 3:
        // 3.If catchExceptions is true, InvocationEvent.getExceptions()
        //   should return the exception thrown inside the run() method.
        RuntimeException sampleExn = new RuntimeException(" test exception");

        invoc = new InvocationEvent(this, () -> { threadStatus = true; throw sampleExn; }, lock, true);
        invoc.dispatch();
        if (!threadStatus) {
            synchronized (lock) {
                lock.wait(delay);
            }
        }
        // testing getException() when exception is thrown
        // Should return the same exception thrown inside the run() method
        if (!invoc.getException().equals(sampleExn)) {
            throw new RuntimeException("getException() does not return " +
                    "the same Exception thrown inside the run() method ");
        }
        threadStatus = false;

        // Testing assertions 4 and 5:
        // 4.When InvocationEvent object is posted on to the EventQueue,
        //   InvocationEvent.dispatch() method should be invoked by the
        //   EventQueue.
        // 5.If the notifier object is not null, notifyAll() of the
        //   notifier object should be invoked when the run() method returns.

        Thread notify = new Thread(){
            public void run() {
                synchronized (this) {
                    try { wait(); } catch (InterruptedException e) { throw new RuntimeException(e); }
                }
                notifierStatus = true;
                synchronized (notifierLock) {
                    notifierLock.notifyAll();
                }
            }
        };
        notify.start();

        while (notify.getState() != Thread.State.WAITING)
            Thread.sleep(delay/5);

        InvocationEvent invocation = new InvocationEvent(this, () -> { }, (Object) notify, false);
        eventQ1.postEvent(invocation);

        while(!invocation.isDispatched())
            synchronized (notifierLock) {
                notifierLock.wait(delay);
            }

        while (notify.getState() != Thread.State.TERMINATED)
            Thread.sleep(delay/5);

        if (!notifierStatus) {
            throw new RuntimeException("Notifier object did not get notified" +
                    " When the run method of the Runnable returns ");
        }

        // Testing assertion 6:
        // 6.To test whether the threads are invoked in the right order
        //   When InvocationEvents are nested.
        Thread thread = new Thread(){
            public void run() {
                InvocationEvent evt = new InvocationEvent(this, () -> { childInvoked = true; }, (Object) this, false);
                new EventQueue().postEvent(evt);
                synchronized (this) {
                    try {
                        wait(delay);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                threadStatus = true;
            }
        };

        invocation = new InvocationEvent(this, thread, lock, false);

        eventQ1.postEvent(invocation);

        while (!invocation.isDispatched())
            synchronized (lock) {
                lock.wait(delay);
            }

        if (!threadStatus || !childInvoked) {
            throw new RuntimeException("Nesting of InvocationEvents when dispatched," +
                    " did not invoke the run() of the Runnables properly ");
        }
    }

    public static void main(String[] args) throws Exception {
        new InvocationEventTest().doTest();
    }
}