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

/*
  @test
  @bug 6424157
  @author Artem Ananiev: area=eventqueue
  @run main PreserveDispatchThread
*/

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

public class PreserveDispatchThread {

    private static volatile Frame f;
    private static volatile Dialog d;

    private static volatile boolean isEDT = true;

    public static void main(String[] args) throws Exception {
        f = new Frame("F");
        f.setSize(320, 340);
        f.setLocationRelativeTo(null);
        f.setVisible(true);

        try {
            test1();
            if (!isEDT) {
                throw new RuntimeException("Test FAILED (test1): event dispatch thread is changed");
            }

            test2();
            if (!isEDT) {
                throw new RuntimeException("Test FAILED (test2): event dispatch thread is changed");
            }

            test3();
            if (!isEDT) {
                throw new RuntimeException("Test FAILED (test3): event dispatch thread is changed");
            }
        } finally {
            if (d != null) {
                d.dispose();
            }
            f.dispose();
        }
    }

    /*
     * Tests that push/pop doesn't change the dispatch thread if
     * called on EDT.
     */
    private static void test1() throws Exception {
        EventQueue.invokeAndWait(new Runnable() {
            @Override
            public void run() {
                TestEventQueue teq = new TestEventQueue();
                EventQueue seq = Toolkit.getDefaultToolkit().getSystemEventQueue();
                try {
                    seq.push(teq);
                    d = new TestDialog();
                    d.setVisible(true);
                    checkEDT();
                } finally {
                    teq.pop();
                }
                checkEDT();
            }
        });
    }

    /*
     * Tests that push/pop doesn't change the dispatch thread if
     * called on the main thread.
     */
    private static void test2() throws Exception {
        TestEventQueue teq = new TestEventQueue();
        EventQueue seq = Toolkit.getDefaultToolkit().getSystemEventQueue();
        try {
            seq.push(teq);
            EventQueue.invokeAndWait(new Runnable() {
                @Override
                public void run() {
                    checkEDT();
                    d = new TestDialog();
                    d.setVisible(true);
                    checkEDT();
                }
            });
        } finally {
            teq.pop();
        }
    }

    private static final Object test3Lock = new Object();
    private static boolean test3Sync = false;

    /*
     * A complex test: several nested invokeLater() are called and
     * in every runnable a check for EDT is performed. At the ent
     * of the test we wait for all the runnables to be processed
     * and the dialog is disposed; otherwise the last EDT check can
     * be later than this method returns and the whole test is passed.
     */
    private static void test3() throws Exception {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                d = new Dialog(f, true);
                d.setSize(240, 180);
                d.setLocationRelativeTo(f);
                EventQueue.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        d.setVisible(true);
                        checkEDT();
                    }
                });
                EventQueue.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        TestEventQueue teq = new TestEventQueue();
                        EventQueue seq = Toolkit.getDefaultToolkit().getSystemEventQueue();
                        try {
                            seq.push(teq);
                            checkEDT();
                            EventQueue.invokeLater(new Runnable() {
                                @Override
                                public void run() {
                                    d.dispose();
                                    checkEDT();
                                    synchronized (test3Lock) {
                                        test3Sync = true;
                                        test3Lock.notify();
                                    }
                                }
                            });
                        } finally {
                            teq.pop();
                        }
                        checkEDT();
                    }
                });
                checkEDT();
            }
        });
        synchronized (test3Lock) {
            while (!test3Sync) {
                try {
                    test3Lock.wait();
                } catch (InterruptedException ie) {
                    break;
                }
            }
        }
        // Make sure all the nested invokeLater/invokeAndWait are processed
        EventQueue.invokeAndWait(new Runnable() {
            @Override
            public void run() {
            }
        });
    }

    private static void checkEDT() {
        isEDT = isEDT && EventQueue.isDispatchThread();
    }

    private static class TestEventQueue extends EventQueue {
        public TestEventQueue() {
            super();
        }
        public void pop() {
            super.pop();
        }
    }

    private static class TestDialog extends Dialog {
        private volatile boolean dialogShown = false;
        private volatile boolean paintCalled = false;
        public TestDialog() {
            super(f, true);
            setSize(240, 180);
            setLocationRelativeTo(f);
            addComponentListener(new ComponentAdapter() {
                @Override
                public void componentShown(ComponentEvent e) {
                    if (paintCalled) {
                        dispose();
                    }
                    dialogShown = true;
                }
            });
        }
        @Override
        public void paint(Graphics g) {
            if (dialogShown) {
                dispose();
            }
            paintCalled = true;
        }
    }

}