jdk/test/java/awt/Modal/MultipleDialogs/MultipleDialogs1Test.java
changeset 28536 e68477f552c4
child 40128 e635645d2a8a
equal deleted inserted replaced
28535:74115b2c211f 28536:e68477f552c4
       
     1 /*
       
     2  * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved.
       
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       
     4  *
       
     5  * This code is free software; you can redistribute it and/or modify it
       
     6  * under the terms of the GNU General Public License version 2 only, as
       
     7  * published by the Free Software Foundation.
       
     8  *
       
     9  * This code is distributed in the hope that it will be useful, but WITHOUT
       
    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
       
    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
       
    12  * version 2 for more details (a copy is included in the LICENSE file that
       
    13  * accompanied this code).
       
    14  *
       
    15  * You should have received a copy of the GNU General Public License version
       
    16  * 2 along with this work; if not, write to the Free Software Foundation,
       
    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
       
    18  *
       
    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
       
    20  * or visit www.oracle.com if you need additional information or have any
       
    21  * questions.
       
    22  */
       
    23 
       
    24 /*
       
    25  * @test
       
    26  * @bug 8054358
       
    27  * @summary Check whether a set of dialogs created with a toolkit excluded Frame
       
    28  *          parent has a proper modal blocking behavior. Also show a document modal
       
    29  *          dialog and check if it blocks the document properly.
       
    30  *
       
    31  * @library ../helpers ../../../../lib/testlibrary/
       
    32  * @build ExtendedRobot
       
    33  * @build Flag
       
    34  * @build TestDialog
       
    35  * @build TestFrame
       
    36  * @run main/timeout=500 MultipleDialogs1Test
       
    37  */
       
    38 
       
    39 
       
    40 import java.awt.*;
       
    41 import java.util.ArrayList;
       
    42 import java.util.List;
       
    43 import java.util.Collections;
       
    44 import java.util.Iterator;
       
    45 
       
    46 public class MultipleDialogs1Test {
       
    47 
       
    48     private volatile CustomFrame frame;
       
    49     private List<CustomDialog> dialogList;
       
    50 
       
    51     private static int delay = 500;
       
    52     private int dialogCount = -1;
       
    53 
       
    54     public void createGUI() {
       
    55 
       
    56         final int n = 8;
       
    57         dialogList = new ArrayList<>();
       
    58 
       
    59         frame = new CustomFrame();
       
    60         frame.setLocation(50, 50);
       
    61         frame.setModalExclusionType(Dialog.ModalExclusionType.TOOLKIT_EXCLUDE);
       
    62         frame.setVisible(true);
       
    63 
       
    64         int x = 250, y = 50;
       
    65 
       
    66         CustomDialog dlg;
       
    67 
       
    68         for (int i = 0; i < n - 1; ++i) {
       
    69 
       
    70             dlg = new CustomDialog(frame);
       
    71             dlg.setLocation(x, y);
       
    72             x += 200;
       
    73 
       
    74             if (x > 600) {
       
    75                 x = 50;
       
    76                 y += 200;
       
    77             }
       
    78 
       
    79             Dialog.ModalityType type;
       
    80 
       
    81             if (i % 3 == 0) {
       
    82                 type = Dialog.ModalityType.MODELESS;
       
    83             } else if (i % 3 == 1) {
       
    84                 type = Dialog.ModalityType.APPLICATION_MODAL;
       
    85             } else {
       
    86                 type = Dialog.ModalityType.TOOLKIT_MODAL;
       
    87             }
       
    88 
       
    89             dlg.setModalityType(type);
       
    90             dialogList.add(dlg);
       
    91         }
       
    92 
       
    93         dlg = new CustomDialog(frame);
       
    94         dlg.setLocation(x, y);
       
    95         dlg.setModalityType(Dialog.ModalityType.DOCUMENT_MODAL);
       
    96         dialogList.add(dlg);
       
    97     }
       
    98 
       
    99     public void doTest() throws Exception {
       
   100 
       
   101         try {
       
   102             EventQueue.invokeAndWait(this::createGUI);
       
   103 
       
   104             ExtendedRobot robot = new ExtendedRobot();
       
   105             robot.waitForIdle(delay);
       
   106 
       
   107             List<CustomDialog> dialogs = Collections.synchronizedList(dialogList);
       
   108 
       
   109             final int n = dialogs.size();
       
   110 
       
   111             synchronized(dialogs) {
       
   112                 for (int i = 0; i < n - 1; ++i) {
       
   113 
       
   114                     frame.clickOpenButton(robot);
       
   115                     robot.waitForIdle(delay);
       
   116 
       
   117                     dialogs.get(i).checkUnblockedDialog(
       
   118                         robot, i + ": This is " + getType(i) + ".");
       
   119 
       
   120                     frame.checkUnblockedFrame(robot, i + ": Other dialogs are visible.");
       
   121 
       
   122                     if (i > 0) {
       
   123                         for (int j = 0; j < i; j++) {
       
   124                             dialogs.get(j).checkUnblockedDialog(robot, j + ": A toolkit modality " +
       
   125                                 "excluded frame is a parent of this dialog.");
       
   126                         }
       
   127                     }
       
   128                 } // i
       
   129 
       
   130                 frame.clickOpenButton(robot);
       
   131                 robot.waitForIdle(delay);
       
   132 
       
   133                 dialogs.get(n - 1).checkUnblockedDialog(
       
   134                     robot, (n - 1) + ": This is " + getType(n - 1) + ".");
       
   135 
       
   136                 frame.checkBlockedFrame(robot,
       
   137                     "A document modal dialog with Frame parent is visible.");
       
   138 
       
   139                 for (int i = 0; i < n - 1; ++i) {
       
   140                     dialogs.get(i).checkUnblockedDialog(robot,
       
   141                         i + ": A document modal dialog should not block " +
       
   142                         "this dialog. The parent is modality excluded.");
       
   143                 }
       
   144 
       
   145                 dialogs.get(n - 1).clickCloseButton(robot);
       
   146                 robot.waitForIdle(delay);
       
   147 
       
   148                 for (int i = 0; i < n - 1; ++i) {
       
   149                     dialogs.get(i).checkUnblockedDialog(robot, i + ": A document modal " +
       
   150                         "dialog which blocked this dialog was closed.");
       
   151                 }
       
   152                 frame.checkUnblockedFrame(robot,
       
   153                     "A blocking document modal dialog was closed.");
       
   154                 robot.waitForIdle(delay);
       
   155             } // synchronized
       
   156 
       
   157         } finally {
       
   158             EventQueue.invokeAndWait(this::closeAll);
       
   159         }
       
   160     }
       
   161 
       
   162     private String getType(int i) {
       
   163 
       
   164         switch (dialogList.get(i).getModalityType()) {
       
   165             case APPLICATION_MODAL:
       
   166                 return "an application modal dialog";
       
   167             case DOCUMENT_MODAL:
       
   168                 return "a document modal dialog";
       
   169             case TOOLKIT_MODAL:
       
   170                 return "a toolkit modal dialog";
       
   171         }
       
   172         return "a modeless dialog";
       
   173     }
       
   174 
       
   175     private void closeAll() {
       
   176 
       
   177         if (frame != null) { frame.dispose(); }
       
   178         if (dialogList != null) {
       
   179             Iterator<CustomDialog> it = dialogList.iterator();
       
   180             while (it.hasNext()) { it.next().dispose(); }
       
   181         }
       
   182     }
       
   183 
       
   184     class CustomFrame extends TestFrame {
       
   185 
       
   186         @Override
       
   187         public void doOpenAction() {
       
   188             if ((dialogList != null) && (dialogList.size() > dialogCount)) {
       
   189                 dialogCount++;
       
   190                 CustomDialog d = dialogList.get(dialogCount);
       
   191                 if (d != null) { d.setVisible(true); }
       
   192             }
       
   193         }
       
   194     }
       
   195 
       
   196     class CustomDialog extends TestDialog {
       
   197 
       
   198         public CustomDialog(Frame  f) { super(f); }
       
   199         public CustomDialog(Dialog d) { super(d); }
       
   200 
       
   201         @Override
       
   202         public void doCloseAction() { this.dispose(); }
       
   203     }
       
   204 
       
   205 
       
   206     public static void main(String[] args) throws Exception {
       
   207         (new MultipleDialogs1Test()).doTest();
       
   208     }
       
   209 }