1 /*
2 * Copyright (c) 2003, 2019, 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 @key headful
27 @bug 4632143
28 @summary Unit test for the RFE window/frame/dialog always on top
29 @author dom@sparc.spb.su: area=awt.toplevel
30 @run main/othervm/timeout=600 AutoTestOnTop
31 */
32
33 import java.awt.AWTEvent;
34 import java.awt.AWTException;
35 import java.awt.Component;
36 import java.awt.Dialog;
37 import java.awt.EventQueue;
38 import java.awt.Frame;
39 import java.awt.IllegalComponentStateException;
40 import java.awt.Point;
41 import java.awt.Robot;
42 import java.awt.Toolkit;
43 import java.awt.Window;
44 import java.awt.event.AWTEventListener;
45 import java.awt.event.FocusEvent;
46 import java.awt.event.InputEvent;
47 import java.awt.event.MouseEvent;
48 import java.awt.event.PaintEvent;
49 import java.awt.event.WindowAdapter;
50 import java.awt.event.WindowEvent;
51 import java.lang.reflect.InvocationTargetException;
52 import java.lang.reflect.Method;
53 import java.util.Vector;
54
55 import javax.swing.JDialog;
56 import javax.swing.JFrame;
57 import javax.swing.JWindow;
58
59 /**
60 * @author tav@sparc.spb.su
61 * @author dom@sparc.spb.su
62 * Tests that always-on-top windows combine correctly with different kinds of window in different styles and conditions.
63 *
64 * !!! WARNING !!!
65 * The test fails sometimes because the toFront() method doesn't guarantee
66 * that after its invocation the frame will be placed above all other windows.
67 */
68 public class AutoTestOnTop {
69 private static final int X = 300;
70 private static final int Y = 300;
71
72 static Window topw;
73 static Frame parentw = new Frame();
74 static Window f;
75 static Frame parentf = new Frame();
76
77 static final Object uncheckedSrc = new Object(); // used when no need to check event source
78 static volatile Object eventSrc = uncheckedSrc;
79 static boolean dispatchedCond;
80
81 static Semaphore STATE_SEMA = new Semaphore();
82 static Semaphore VIS_SEMA = new Semaphore();
83 static Vector errors = new Vector();
84
85 static boolean isUnix = false;
86
87 static StringBuffer msgError = new StringBuffer();
88 static StringBuffer msgCase = new StringBuffer();
89 static StringBuffer msgAction = new StringBuffer();
90 static StringBuffer msgFunc = new StringBuffer();
91 static StringBuffer msgVisibility = new StringBuffer();
92
93 static volatile int stageNum;
94 static volatile int actNum;
95 static volatile int testResult = 0;
96
97 static volatile boolean doCheckEvents;
98 static volatile boolean eventsCheckPassed;
99 static boolean[] eventsCheckInitVals = new boolean[] { // Whether events are checked for abcence or precence
100 true, true, true, true, true, false, false, false, false
101 };
102 static String[] msgEventsChecks = new String[] {
103 null, null, null, null, null,
104 "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated",
105 "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated",
106 "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated",
107 "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated",
108 };
109
110 static final int stagesCount = 7;
111 static final int actionsCount = 9;
112
113 static Method[] preActions = new Method[actionsCount];
114 static Method[] postActions = new Method[actionsCount];
115 static Method[] isActionsAllowed = new Method[actionsCount];
116 static Method[] checksActionEvents = new Method[actionsCount];
117
118 static Robot robot;
119
120 static boolean doStartTest;
121 static String osName = System.getProperty("os.name");
122
123
124 public static void main(String[] args) {
125 checkTesting();
126
127 }
128
129 public static void performTesting() {
130 isUnix = osName.equals("Linux") || osName.equals("SunOS");
131
132 Toolkit.getDefaultToolkit().addAWTEventListener(new AWTEventListener() {
133 public void eventDispatched(AWTEvent e) {
134 if (e.getID() == MouseEvent.MOUSE_CLICKED) {
135 if (eventSrc != null & eventSrc != uncheckedSrc && e.getSource() != eventSrc) {
136 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": " + msgError);
137 testResult = -1;
138 }
139 if (eventSrc != null){
140 synchronized (eventSrc) {
141 dispatchedCond = true;
142 eventSrc.notify();
143 }
144 }
145 }
146
147 if (doCheckEvents && (e.getSource() == topw || e.getSource() == f)) {
148
149 //System.err.println("AWTEventListener: catched the event " + e);
150
151 try {
152 checksActionEvents[actNum].invoke(null, new Object[] {e});
153 } catch (InvocationTargetException ite) {
154 ite.printStackTrace();
155 } catch (IllegalAccessException iae) {
156 iae.printStackTrace();
157 }
158 return;
159 }
160 }
161 }, 0xffffffffffffffffL);
162
163 Method[] allMethods;
164
165 try {
166 allMethods = AutoTestOnTop.class.getDeclaredMethods();
167 } catch (SecurityException se) {
168 throw new RuntimeException(se);
169 }
170
171 for (int i = 0; i < allMethods.length; i++) {
172 String name = allMethods[i].getName();
173 if (name.startsWith("preAction")) {
174 preActions[name.charAt(name.length() - 1) - '0'] = allMethods[i];
175 } else if (name.startsWith("postAction")) {
176 postActions[name.charAt(name.length() - 1) - '0'] = allMethods[i];
177 } else if (name.startsWith("isActionAllowed")) {
178 isActionsAllowed[name.charAt(name.length() - 1) - '0'] = allMethods[i];
179 } else if (name.startsWith("checkActionEvents")) {
180 checksActionEvents[name.charAt(name.length() - 1) - '0'] = allMethods[i];
181 }
182 }
183
184 f = new Frame("Auxiliary Frame");
185 f.setBounds(X, Y, 650, 100);
186 f.setVisible(true);
187 waitTillShown(f);
188
189 try {
190 robot = new Robot();
191 robot.setAutoDelay(100);
192 } catch (AWTException e) {
193 throw new RuntimeException("Error: unable to create robot", e);
194 }
195
196 mainTest();
197
198 if (testResult != 0) {
199 System.err.println("The following errors were encountered: ");
200 for (int i = 0; i < errors.size(); i++) {
201 System.err.println(errors.get(i).toString());
202 }
203 throw new RuntimeException("Test failed.");
204 } else {
205 System.err.println("Test PASSED.");
206 }
207 }
208
209 public static void mainTest() {
210 // stageNum = 0;
211 // for (int i = 0; i < 5; i++) {
212 // actNum = 2;
213 // System.err.println("************************* A C T I O N " + actNum + " *************************");
214 // doStage(stageNum, actNum);
215 // // pause(500);
216 // actNum = 3;
217 // System.err.println("************************* A C T I O N " + actNum + " *************************");
218 // doStage(stageNum, actNum);
219 // // pause(500);
220 // }
221 for (stageNum = 0; stageNum < stagesCount; stageNum++) {
222 System.err.println("************************* S T A G E " + stageNum + " *************************");
223 for (actNum = 0; actNum < actionsCount; actNum++) {
224 System.err.println("************************* A C T I O N " + actNum + " *************************");
225 doStage(stageNum, actNum);
226 } // for thru actNum
227 } // fow thru stageNum
228
229 eventSrc = null;
230 }
231
232 private static void doStage(int stageNum, int actNum) {
233 try {
234
235 if (!((Boolean)isActionsAllowed[actNum].invoke(null, new Object[0])).booleanValue()) {
236 System.err.println("Action skipped due to a platform limitations");
237 return;
238 }
239
240 STATE_SEMA.reset();
241 createWindow(stageNum);
242
243 //*************************
244 // Set window always-on-top
245 //*************************
246
247 preActions[actNum].invoke(null, new Object[0]);
248 setAlwaysOnTop(topw, true);
249 waitForIdle(true);
250
251 if (!topw.isAlwaysOnTopSupported()) return;
252
253 postActions[actNum].invoke(null, new Object[0]);
254 waitForIdle(false);
255
256 STATE_SEMA.reset();
257
258 testForAlwaysOnTop();
259
260 //*****************************
261 // Set window not always-on-top
262 //*****************************
263
264 preActions[actNum].invoke(null, new Object[0]);
265 setAlwaysOnTop(topw, false);
266 waitForIdle(true);
267 postActions[actNum].invoke(null, new Object[0]);
268 waitForIdle(false);
269 STATE_SEMA.reset();
270
271 testForNotAlwaysOnTop();
272
273 } catch (InvocationTargetException ite) {
274 ite.printStackTrace();
275 } catch (Exception ex) {
276 throw new RuntimeException(ex);
277 }
278 }
279
280 private static void checkTesting() {
281 if (Toolkit.getDefaultToolkit().isAlwaysOnTopSupported()) {
282 performTesting();
283 }
284 }
285
286 public static void testForAlwaysOnTop() {
287 System.err.println("Checking for always-on-top " + topw);
288
289 ensureInitialWinPosition(topw);
290
291 // Check that always-on-top window is topmost.
292 // - Click on always-on-top window on the windows cross area.
293 clickOn(topw, f, 10, 50, "setting " + msgVisibility +
294 " window (1) always-on-top didn't make it topmost");
295
296 // Check that we can't change z-order of always-on-top window.
297 // - a) Try to put the other window on the top.
298 f.toFront();
299 clickOn(uncheckedSrc, f, 450, 50, ""); // coz toFront() works not always
300 pause(300);
301
302 // - b) Click on always-on-top window on the windows cross area.
303 clickOn(topw, f, 10, 50, "setting " + msgVisibility +
304 " window (1) always-on-top didn't make it such");
305
306 // Ask for always-on-top property
307 if (isAlwaysOnTop(topw) != true)
308 error("Test failed: stage #" + stageNum + ", action #" + actNum + ": " + msgCase + ": " + msgAction +
309 ": isAlwaysOnTop() returned 'false' for window (1) set always-on-top at state "
310 + msgVisibility);
311 }
312
313 public static void testForNotAlwaysOnTop() {
314 System.err.println("Checking for non always-on-top of " + topw);
315 ensureInitialWinPosition(topw);
316
317 if (msgVisibility.equals("visible") && actNum != 2) {
318 // Check that the window remains topmost.
319 // - click on the window on the windows cross area.
320 clickOn(topw, f, 10, 50, "setting " + msgVisibility +
321 " window (1) not always-on-top didn't keep it topmost");
322 }
323
324 // Check that we can change z-order of not always-on-top window.
325 // - a) try to put the other window on the top.
326 f.toFront();
327 clickOn(uncheckedSrc, f, 450, 50, ""); // coz toFront() works not always
328 pause(300);
329
330 // - b) click on not always-on-top window on the windows cross area.
331 clickOn(f, f, 10, 50, "setting " + msgVisibility +
332 " window (1) not always-on-top didn't make it such");
333
334 // Ask for always-on-top property
335 if (isAlwaysOnTop(topw) != false)
336 error("Test failed: stage #" + stageNum + ", action #" + actNum + ": " + msgCase + ": " + msgAction +
337 ": isAlwaysOnTop() returned 'true' for window (1) set not always-on-top at state "
338 + msgVisibility);
339 }
340
341
342 private static void createWindow(int stageNum) {
343 // Free native resourses
344 if (topw != null) {
345 topw.dispose();
346 }
347
348 switch (stageNum) {
349 case 0:
350 topw = new Frame("Top Frame");
351 msgCase.replace(0, msgCase.length(), "Frame (1) over Frame (2)");
352 break;
353 case 1:
354 topw = new JFrame("Top JFrame");
355 msgCase.replace(0, msgCase.length(), "JFrame (1) over Frame (2)");
356 break;
357 case 2:
358 topw = new Dialog(parentw, "Top Dialog");
359 msgCase.replace(0, msgCase.length(), "Dialog (1) over Frame (2)");
360 break;
361 case 3:
362 topw = new JDialog(parentw, "Top JDialog");
363 msgCase.replace(0, msgCase.length(), "JDialog (1) over Frame (2)");
364 break;
365 case 4:
366 topw = new Frame("Top Frame");
367 f.dispose();
368 f = new Dialog(parentf, "Auxiliary Dialog");
369 f.setBounds(X, Y, 650, 100);
370 f.setVisible(true);
371 waitTillShown(f);
372 msgCase.replace(0, msgCase.length(), "Frame (1) over Dialog (2)");
373 break;
374 case 5:
375 topw = new Window(parentw);
376 msgCase.replace(0, msgCase.length(), "Window (1) over Frame (2)");
377 break;
378 case 6:
379 topw = new JWindow(parentw);
380 msgCase.replace(0, msgCase.length(), "JWindow (1) over Frame (2)");
381 break;
382 }
383 topw.addWindowStateListener(new WindowAdapter() {
384 public void windowStateChanged(WindowEvent e) {
385 System.err.println("* " + e);
386 STATE_SEMA.raise();
387 }
388 });
389 topw.setSize(300, 100);
390 }
391
392 /**
393 * 0: setting always-on-top to invisible window
394 * 1: setting always-on-top to visible window
395 * 2: always-on-top on visible non-focusable window
396 * 3: always-on-top on visible, dragging topw after that
397 * 4: always-on-top on visible, dragging f after that
398 * 5: always-on-top on (visible, maximized), make normal after that
399 * 6: always-on-top on (visible, iconified), make normal after that
400 * 7: always-on-top on visible, iconify/deiconify after that
401 * 8: always-on-top on visible, maximize/restore after that
402 */
403 public static void preAction_0() {
404 topw.setVisible(false);
405 }
406 public static void postAction_0() {
407 if (topw.isShowing()) {
408 error("Test failed: stage #" + stageNum + ", action #" + actNum + ": " + msgCase +
409 ": no actions with windows: changing always-on-top property at window (1) state 'invisible' makes window (1) visible");
410 }
411 setWindowVisible("no actions with windows", "invisible");
412 }
413 public static boolean isActionAllowed_0() {
414 // Window on Linux is always always-on-top!
415 return !((stageNum == 5 || stageNum == 6) && isUnix) && (stageNum < stagesCount);
416 }
417 public static void checkActionEvents_0(AWTEvent e) {
418 System.err.println(e.toString());
419 }
420
421 public static void preAction_1() {
422 setWindowVisible("no actions with windows", "visible");
423 }
424 public static void postAction_1() {}
425 public static boolean isActionAllowed_1() {
426 return !((stageNum == 5 || stageNum == 6) && isUnix) && (stageNum < stagesCount );
427 }
428 public static void checkActionEvents_1(AWTEvent e) {
429 System.err.println(e.toString());
430 if (e instanceof PaintEvent) {
431 return;
432 }
433 eventsCheckPassed = false;
434 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc +
435 ": unexpected event " + e + " was generated");
436 }
437
438 public static void preAction_2() {
439 setWindowVisible("when window (1) set not focusable", "visible");
440 topw.setFocusableWindowState(false);
441 f.toFront();
442 pause(300);
443 }
444 public static void postAction_2() {}
445 public static boolean isActionAllowed_2() {
446 return !((stageNum == 5 || stageNum == 6) && isUnix) && (stageNum < stagesCount);
447 }
448 public static void checkActionEvents_2(AWTEvent e) {
449 System.err.println(e.toString());
450 if ( (e.getID() >= FocusEvent.FOCUS_FIRST && e.getID() <= FocusEvent.FOCUS_LAST) ||
451 (e.getID() == WindowEvent.WINDOW_LOST_FOCUS && e.getID() == WindowEvent.WINDOW_GAINED_FOCUS)) {
452 eventsCheckPassed = false;
453 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " +
454 msgAction + ": after call " + msgFunc +
455 ": unexpected event " + e + " was generated");
456 }
457 }
458
459 public static void preAction_3() {
460 setWindowVisible("after dragging", "visible");
461 }
462 public static void postAction_3() {
463 Point p = topw.getLocationOnScreen();
464 int x = p.x + 150, y = p.y + 5;
465
466 try { // Take a pause to avoid double click
467 Thread.sleep(500); // when called one after another.
468 } catch (InterruptedException ie) {
469 ie.printStackTrace();
470 } catch (IllegalComponentStateException e) {
471 e.printStackTrace();
472 }
473
474 // Drag the window.
475 robot.mouseMove(x, y);
476 robot.mousePress(InputEvent.BUTTON1_MASK);
477 robot.mouseMove(X + 150, Y + 100);
478 robot.mouseMove(x, y);
479 robot.mouseRelease(InputEvent.BUTTON1_MASK);
480 }
481 public static boolean isActionAllowed_3() {
482 return (stageNum < 5);
483 }
484 public static void checkActionEvents_3(AWTEvent e) {
485 System.err.println(e.toString());
486 }
487
488 public static void preAction_4() {
489 setWindowVisible("after dragging window (2)", "visible");
490 }
491 public static void postAction_4() {
492 Point p = f.getLocationOnScreen();
493 int x = p.x + 400, y = p.y + 5;
494
495 try { // Take a pause to avoid double click
496 Thread.sleep(500); // when called one after another.
497 } catch (InterruptedException ie) {
498 ie.printStackTrace();
499 } catch (IllegalComponentStateException e) {
500 e.printStackTrace();
501 }
502
503 // Drag the window.
504 robot.mouseMove(x, y);
505 robot.mousePress(InputEvent.BUTTON1_MASK);
506 robot.mouseMove(X + 400, Y + 100);
507 robot.mouseMove(x, y);
508 robot.mouseRelease(InputEvent.BUTTON1_MASK);
509
510 ensureInitialWinPosition(f);
511 }
512 public static boolean isActionAllowed_4() {
513 return !((stageNum == 5 || stageNum == 6) && isUnix);
514 }
515 public static void checkActionEvents_4(AWTEvent e) {
516 System.err.println(e.toString());
517 }
518
519 // Metacity has a bug not allowing to set a window to NORMAL state!!!
520
521 public static void preAction_5() {
522 setWindowVisible("at state 'maximized'", "visible");
523 ((Frame)topw).setExtendedState(Frame.MAXIMIZED_BOTH);
524 waitForStateChange();
525 }
526 public static void postAction_5() {
527 ((Frame)topw).setExtendedState(Frame.NORMAL);
528 waitForStateChange();
529 }
530 public static boolean isActionAllowed_5() {
531 return (stageNum < 2);
532 }
533 public static void checkActionEvents_5(AWTEvent e) {
534 System.err.println("=" + e.toString());
535 if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) {
536 eventsCheckPassed = true;
537 }
538 }
539
540 public static void preAction_6() {
541 setWindowVisible("at state 'iconified'", "visible");
542 System.err.println("Iconifying " + topw);
543 ((Frame)topw).setExtendedState(Frame.ICONIFIED);
544 if (!waitForStateChange()) {
545 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc +
546 ": state change to ICONIFIED hasn't been generated");
547 }
548 }
549 public static void postAction_6() {
550 System.err.println("Restoring " + topw);
551 ((Frame)topw).setExtendedState(Frame.NORMAL);
552 if (!waitForStateChange()) {
553 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc +
554 ": state change to NORMAL hasn't been generated");
555 }
556 }
557 public static boolean isActionAllowed_6() {
558 return (stageNum < 2 );
559 }
560 public static void checkActionEvents_6(AWTEvent e) {
561 System.err.println("+" + e.toString());
562 if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) {
563 eventsCheckPassed = true;
564 }
565 }
566
567 public static void preAction_7() {
568 setWindowVisible("before state 'iconified'", "visible");
569 }
570 public static void postAction_7() {
571 System.err.println("Setting iconified");
572 ((Frame)topw).setExtendedState(Frame.ICONIFIED);
573 if (!waitForStateChange()) {
574 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc +
575 ": state change to ICONIFIED hasn't been generated");
576 }
577 System.err.println("Setting normal");
578 ((Frame)topw).setExtendedState(Frame.NORMAL);
579 if (!waitForStateChange()) {
580 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc +
581 ": state change to NORMAL hasn't been generated");
582 }
583 }
584 public static boolean isActionAllowed_7() {
585 return (stageNum < 2);
586 }
587 public static void checkActionEvents_7(AWTEvent e) {
588 System.err.println(e.toString());
589 if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) {
590 eventsCheckPassed = true;
591 }
592 }
593
594 public static void preAction_8() {
595 setWindowVisible("before state 'maximized'", "visible");
596 }
597 public static void postAction_8() {
598 ((Frame)topw).setExtendedState(Frame.MAXIMIZED_BOTH);
599 if (!waitForStateChange()) {
600 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc +
601 ": state change to MAXIMIZED hasn't been generated");
602 }
603 ((Frame)topw).setExtendedState(Frame.NORMAL);
604 if (!waitForStateChange()) {
605 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc +
606 ": state change to NORMAL hasn't been generated");
607 }
608 }
609 public static boolean isActionAllowed_8() {
610 return (stageNum < 2);
611 }
612 public static void checkActionEvents_8(AWTEvent e) {
613 System.err.println(e.toString());
614 if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) {
615 eventsCheckPassed = true;
616 }
617 }
618
619 //***************************************************************************
620
621 private static void setWindowVisible(String mAction, String mVisibility) {
622 msgAction.replace(0, msgAction.length(), mAction);
623 msgVisibility.replace(0, msgVisibility.length(), mVisibility);
624
625 topw.setVisible(true);
626 pause(100); // Needs for Sawfish
627 topw.setLocation(X, Y);
628 waitTillShown(topw);
629 f.toFront();
630 pause(300);
631 }
632
633 private static void clickOn(Object src, Window relwin, int x, int y, String errorStr) {
634 Point p = relwin.getLocationOnScreen();
635 int counter = 10;
636 while (--counter > 0) {
637 eventSrc = src;
638 msgError.replace(0, msgError.length(), errorStr);
639
640 robot.mouseMove(p.x + x, p.y + y);
641 robot.mousePress(InputEvent.BUTTON1_MASK);
642 robot.mouseRelease(InputEvent.BUTTON1_MASK);
643
644 synchronized (eventSrc) {
645 if (!dispatchedCond) {
646 try {
647 eventSrc.wait(1000);
648 } catch (InterruptedException e) {
649 e.printStackTrace();
650 }
651 }
652 if (!dispatchedCond) {
653 //System.err.println("clickOn: MOUSE_CLICKED event losed, trying to generate it again...");
654 continue;
655 }
656 dispatchedCond = false;
657 }
658 break;
659 } // end while
660 if (counter <= 0) {
661 eventSrc = uncheckedSrc;
662 error("Test: internal error: could't catch MOUSE_CLICKED event. Skip testing this stage");
663 }
664 }
665
666 private static void setAlwaysOnTop(Window w, boolean value) {
667 System.err.println("Setting always on top on " + w + " to " + value);
668 robot.mouseMove(X - 50, Y - 50); // Move out of the window
669 msgFunc.replace(0, msgCase.length(), "setAlwaysOnTop()");
670 try {
671 w.setAlwaysOnTop(value);
672 } catch (Exception e) {
673 error("Test failed: stage#" + stageNum + "action #" + actNum + ": " + msgCase + ": " + msgAction +
674 ": setAlwaysOnTop(" + value + ") called at state " + msgVisibility +
675 " threw exeption " + e);
676 }
677 }
678
679 private static boolean isAlwaysOnTop(Window w) {
680 robot.mouseMove(X - 50, Y - 50); // Move out of the window
681 msgFunc.replace(0, msgCase.length(), "isAlwaysOnTop()");
682 boolean result = false;
683 try {
684 result = w.isAlwaysOnTop();
685 } catch (Exception e) {
686 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction +
687 ": isAlwaysOnTop() called at state " + msgVisibility +
688 " threw exeption " + e);
689 }
690 return result;
691 }
692
693 private static void waitTillShown(Component c) {
694 while (true) {
695 try {
696 Thread.sleep(100);
697 c.getLocationOnScreen();
698 break;
699 } catch (InterruptedException e) {
700 e.printStackTrace();
701 break;
702 }
703 }
704 }
705
706 private static void waitForIdle(boolean doCheck) {
707 try {
708 robot.waitForIdle();
709 EventQueue.invokeAndWait( new Runnable() {
710 public void run() {} // Dummy implementation
711 } );
712 } catch(InterruptedException ite) {
713 System.err.println("waitForIdle, non-fatal exception caught:");
714 ite.printStackTrace();
715 } catch(InvocationTargetException ine) {
716 System.err.println("waitForIdle, non-fatal exception caught:");
717 ine.printStackTrace();
718 }
719 doCheckEvents = doCheck;
720
721 if (doCheck) {
722 eventsCheckPassed = eventsCheckInitVals[actNum]; // Initialize
723 } else if (!eventsCheckPassed &&
724 msgEventsChecks[actNum] != null) {
725
726
727 // Some expected event hasn't been catched,
728 // so give it one more chance...
729 doCheckEvents = true;
730 pause(500);
731 doCheckEvents = false;
732
733 if (!eventsCheckPassed) {
734 testResult = -1;
735 error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call "
736 + msgFunc + ": " + msgEventsChecks[actNum]);
737 }
738 }
739 }
740
741 private static boolean waitForStateChange() {
742 System.err.println("------- Waiting for state change");
743 try {
744 STATE_SEMA.doWait(3000);
745 } catch (InterruptedException ie) {
746 System.err.println("Wait interrupted: " + ie);
747 }
748 boolean state = STATE_SEMA.getState();
749 STATE_SEMA.reset();
750 robot.delay(1000); // animation normal <--> maximized states
751 return state;
752 }
753
754 private static void ensureInitialWinPosition(Window w) {
755 int counter = 30;
756 while (w.getLocationOnScreen().y != Y && --counter > 0) {
757 try {
758 Thread.sleep(100);
759 } catch (InterruptedException e) {
760 e.printStackTrace();
761 break;
762 }
763 }
764 if (counter <= 0) {
765 w.setLocation(X, Y);
766 pause(100);
767 System.err.println("Test: window set to initial position forcedly");
768 }
769 }
770
771 private static void pause(int mls) {
772 try {
773 Thread.sleep(mls);
774 } catch (InterruptedException e) {
775 e.printStackTrace();
776 }
777 }
778
779 private static void error(String msg) {
780 errors.add(msg);
781 System.err.println(msg);
782 }
783 }
784
785 class Semaphore {
786 boolean state = false;
787 int waiting = 0;
788 public Semaphore() {
789 }
790 public synchronized void doWait() throws InterruptedException {
791 if (state) {
792 return;
793 }
794 waiting++;
795 wait();
796 waiting--;
797 }
798 public synchronized void doWait(int timeout) throws InterruptedException {
799 if (state) {
800 return;
801 }
802 waiting++;
803 wait(timeout);
804 waiting--;
805 }
806 public synchronized void raise() {
807 state = true;
808 if (waiting > 0) {
809 notifyAll();
810 }
811 }
812
813 public synchronized void doNotify() {
814 notifyAll();
815 }
816 public synchronized boolean getState() {
817 return state;
818 }
819
820 public synchronized void reset() {
821 state = false;
822 }
823 }