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