| /* |
| * Copyright (c) 2003, 2019, 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 |
| @key headful |
| @bug 4632143 |
| @summary Unit test for the RFE window/frame/dialog always on top |
| @author dom@sparc.spb.su: area=awt.toplevel |
| @run main/othervm/timeout=600 AutoTestOnTop |
| */ |
| |
| import java.awt.AWTEvent; |
| import java.awt.AWTException; |
| import java.awt.Component; |
| import java.awt.Dialog; |
| import java.awt.EventQueue; |
| import java.awt.Frame; |
| import java.awt.IllegalComponentStateException; |
| import java.awt.Point; |
| import java.awt.Robot; |
| import java.awt.Toolkit; |
| import java.awt.Window; |
| import java.awt.event.AWTEventListener; |
| import java.awt.event.FocusEvent; |
| import java.awt.event.InputEvent; |
| import java.awt.event.MouseEvent; |
| import java.awt.event.PaintEvent; |
| import java.awt.event.WindowAdapter; |
| import java.awt.event.WindowEvent; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.Vector; |
| |
| import javax.swing.JDialog; |
| import javax.swing.JFrame; |
| import javax.swing.JWindow; |
| |
| /** |
| * @author tav@sparc.spb.su |
| * @author dom@sparc.spb.su |
| * Tests that always-on-top windows combine correctly with different kinds of window in different styles and conditions. |
| * |
| * !!! WARNING !!! |
| * The test fails sometimes because the toFront() method doesn't guarantee |
| * that after its invocation the frame will be placed above all other windows. |
| */ |
| public class AutoTestOnTop { |
| private static final int X = 300; |
| private static final int Y = 300; |
| |
| static Window topw; |
| static Frame parentw = new Frame(); |
| static Window f; |
| static Frame parentf = new Frame(); |
| |
| static final Object uncheckedSrc = new Object(); // used when no need to check event source |
| static volatile Object eventSrc = uncheckedSrc; |
| static boolean dispatchedCond; |
| |
| static Semaphore STATE_SEMA = new Semaphore(); |
| static Semaphore VIS_SEMA = new Semaphore(); |
| static Vector errors = new Vector(); |
| |
| static boolean isUnix = false; |
| |
| static StringBuffer msgError = new StringBuffer(); |
| static StringBuffer msgCase = new StringBuffer(); |
| static StringBuffer msgAction = new StringBuffer(); |
| static StringBuffer msgFunc = new StringBuffer(); |
| static StringBuffer msgVisibility = new StringBuffer(); |
| |
| static volatile int stageNum; |
| static volatile int actNum; |
| static volatile int testResult = 0; |
| |
| static volatile boolean doCheckEvents; |
| static volatile boolean eventsCheckPassed; |
| static boolean[] eventsCheckInitVals = new boolean[] { // Whether events are checked for abcence or precence |
| true, true, true, true, true, false, false, false, false |
| }; |
| static String[] msgEventsChecks = new String[] { |
| null, null, null, null, null, |
| "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated", |
| "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated", |
| "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated", |
| "expected WindowEvent.WINDOW_STATE_CHANGED hasn't been generated", |
| }; |
| |
| static final int stagesCount = 7; |
| static final int actionsCount = 9; |
| |
| static Method[] preActions = new Method[actionsCount]; |
| static Method[] postActions = new Method[actionsCount]; |
| static Method[] isActionsAllowed = new Method[actionsCount]; |
| static Method[] checksActionEvents = new Method[actionsCount]; |
| |
| static Robot robot; |
| |
| static boolean doStartTest; |
| static String osName = System.getProperty("os.name"); |
| |
| |
| public static void main(String[] args) { |
| checkTesting(); |
| |
| } |
| |
| public static void performTesting() { |
| isUnix = osName.equals("Linux") || osName.equals("SunOS"); |
| |
| Toolkit.getDefaultToolkit().addAWTEventListener(new AWTEventListener() { |
| public void eventDispatched(AWTEvent e) { |
| if (e.getID() == MouseEvent.MOUSE_CLICKED) { |
| if (eventSrc != null & eventSrc != uncheckedSrc && e.getSource() != eventSrc) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": " + msgError); |
| testResult = -1; |
| } |
| if (eventSrc != null){ |
| synchronized (eventSrc) { |
| dispatchedCond = true; |
| eventSrc.notify(); |
| } |
| } |
| } |
| |
| if (doCheckEvents && (e.getSource() == topw || e.getSource() == f)) { |
| |
| //System.err.println("AWTEventListener: catched the event " + e); |
| |
| try { |
| checksActionEvents[actNum].invoke(null, new Object[] {e}); |
| } catch (InvocationTargetException ite) { |
| ite.printStackTrace(); |
| } catch (IllegalAccessException iae) { |
| iae.printStackTrace(); |
| } |
| return; |
| } |
| } |
| }, 0xffffffffffffffffL); |
| |
| Method[] allMethods; |
| |
| try { |
| allMethods = AutoTestOnTop.class.getDeclaredMethods(); |
| } catch (SecurityException se) { |
| throw new RuntimeException(se); |
| } |
| |
| for (int i = 0; i < allMethods.length; i++) { |
| String name = allMethods[i].getName(); |
| if (name.startsWith("preAction")) { |
| preActions[name.charAt(name.length() - 1) - '0'] = allMethods[i]; |
| } else if (name.startsWith("postAction")) { |
| postActions[name.charAt(name.length() - 1) - '0'] = allMethods[i]; |
| } else if (name.startsWith("isActionAllowed")) { |
| isActionsAllowed[name.charAt(name.length() - 1) - '0'] = allMethods[i]; |
| } else if (name.startsWith("checkActionEvents")) { |
| checksActionEvents[name.charAt(name.length() - 1) - '0'] = allMethods[i]; |
| } |
| } |
| |
| f = new Frame("Auxiliary Frame"); |
| f.setBounds(X, Y, 650, 100); |
| f.setVisible(true); |
| waitTillShown(f); |
| |
| try { |
| robot = new Robot(); |
| robot.setAutoDelay(100); |
| } catch (AWTException e) { |
| throw new RuntimeException("Error: unable to create robot", e); |
| } |
| |
| mainTest(); |
| |
| if (testResult != 0) { |
| System.err.println("The following errors were encountered: "); |
| for (int i = 0; i < errors.size(); i++) { |
| System.err.println(errors.get(i).toString()); |
| } |
| throw new RuntimeException("Test failed."); |
| } else { |
| System.err.println("Test PASSED."); |
| } |
| } |
| |
| public static void mainTest() { |
| // stageNum = 0; |
| // for (int i = 0; i < 5; i++) { |
| // actNum = 2; |
| // System.err.println("************************* A C T I O N " + actNum + " *************************"); |
| // doStage(stageNum, actNum); |
| // // pause(500); |
| // actNum = 3; |
| // System.err.println("************************* A C T I O N " + actNum + " *************************"); |
| // doStage(stageNum, actNum); |
| // // pause(500); |
| // } |
| for (stageNum = 0; stageNum < stagesCount; stageNum++) { |
| System.err.println("************************* S T A G E " + stageNum + " *************************"); |
| for (actNum = 0; actNum < actionsCount; actNum++) { |
| System.err.println("************************* A C T I O N " + actNum + " *************************"); |
| doStage(stageNum, actNum); |
| } // for thru actNum |
| } // fow thru stageNum |
| |
| eventSrc = null; |
| } |
| |
| private static void doStage(int stageNum, int actNum) { |
| try { |
| |
| if (!((Boolean)isActionsAllowed[actNum].invoke(null, new Object[0])).booleanValue()) { |
| System.err.println("Action skipped due to a platform limitations"); |
| return; |
| } |
| |
| STATE_SEMA.reset(); |
| createWindow(stageNum); |
| |
| //************************* |
| // Set window always-on-top |
| //************************* |
| |
| preActions[actNum].invoke(null, new Object[0]); |
| setAlwaysOnTop(topw, true); |
| waitForIdle(true); |
| |
| if (!topw.isAlwaysOnTopSupported()) return; |
| |
| postActions[actNum].invoke(null, new Object[0]); |
| waitForIdle(false); |
| |
| STATE_SEMA.reset(); |
| |
| testForAlwaysOnTop(); |
| |
| //***************************** |
| // Set window not always-on-top |
| //***************************** |
| |
| preActions[actNum].invoke(null, new Object[0]); |
| setAlwaysOnTop(topw, false); |
| waitForIdle(true); |
| postActions[actNum].invoke(null, new Object[0]); |
| waitForIdle(false); |
| STATE_SEMA.reset(); |
| |
| testForNotAlwaysOnTop(); |
| |
| } catch (InvocationTargetException ite) { |
| ite.printStackTrace(); |
| } catch (Exception ex) { |
| throw new RuntimeException(ex); |
| } |
| } |
| |
| private static void checkTesting() { |
| if (Toolkit.getDefaultToolkit().isAlwaysOnTopSupported()) { |
| performTesting(); |
| } |
| } |
| |
| public static void testForAlwaysOnTop() { |
| System.err.println("Checking for always-on-top " + topw); |
| |
| ensureInitialWinPosition(topw); |
| |
| // Check that always-on-top window is topmost. |
| // - Click on always-on-top window on the windows cross area. |
| clickOn(topw, f, 10, 50, "setting " + msgVisibility + |
| " window (1) always-on-top didn't make it topmost"); |
| |
| // Check that we can't change z-order of always-on-top window. |
| // - a) Try to put the other window on the top. |
| f.toFront(); |
| clickOn(uncheckedSrc, f, 450, 50, ""); // coz toFront() works not always |
| pause(300); |
| |
| // - b) Click on always-on-top window on the windows cross area. |
| clickOn(topw, f, 10, 50, "setting " + msgVisibility + |
| " window (1) always-on-top didn't make it such"); |
| |
| // Ask for always-on-top property |
| if (isAlwaysOnTop(topw) != true) |
| error("Test failed: stage #" + stageNum + ", action #" + actNum + ": " + msgCase + ": " + msgAction + |
| ": isAlwaysOnTop() returned 'false' for window (1) set always-on-top at state " |
| + msgVisibility); |
| } |
| |
| public static void testForNotAlwaysOnTop() { |
| System.err.println("Checking for non always-on-top of " + topw); |
| ensureInitialWinPosition(topw); |
| |
| if (msgVisibility.equals("visible") && actNum != 2) { |
| // Check that the window remains topmost. |
| // - click on the window on the windows cross area. |
| clickOn(topw, f, 10, 50, "setting " + msgVisibility + |
| " window (1) not always-on-top didn't keep it topmost"); |
| } |
| |
| // Check that we can change z-order of not always-on-top window. |
| // - a) try to put the other window on the top. |
| f.toFront(); |
| clickOn(uncheckedSrc, f, 450, 50, ""); // coz toFront() works not always |
| pause(300); |
| |
| // - b) click on not always-on-top window on the windows cross area. |
| clickOn(f, f, 10, 50, "setting " + msgVisibility + |
| " window (1) not always-on-top didn't make it such"); |
| |
| // Ask for always-on-top property |
| if (isAlwaysOnTop(topw) != false) |
| error("Test failed: stage #" + stageNum + ", action #" + actNum + ": " + msgCase + ": " + msgAction + |
| ": isAlwaysOnTop() returned 'true' for window (1) set not always-on-top at state " |
| + msgVisibility); |
| } |
| |
| |
| private static void createWindow(int stageNum) { |
| // Free native resourses |
| if (topw != null) { |
| topw.dispose(); |
| } |
| |
| switch (stageNum) { |
| case 0: |
| topw = new Frame("Top Frame"); |
| msgCase.replace(0, msgCase.length(), "Frame (1) over Frame (2)"); |
| break; |
| case 1: |
| topw = new JFrame("Top JFrame"); |
| msgCase.replace(0, msgCase.length(), "JFrame (1) over Frame (2)"); |
| break; |
| case 2: |
| topw = new Dialog(parentw, "Top Dialog"); |
| msgCase.replace(0, msgCase.length(), "Dialog (1) over Frame (2)"); |
| break; |
| case 3: |
| topw = new JDialog(parentw, "Top JDialog"); |
| msgCase.replace(0, msgCase.length(), "JDialog (1) over Frame (2)"); |
| break; |
| case 4: |
| topw = new Frame("Top Frame"); |
| f.dispose(); |
| f = new Dialog(parentf, "Auxiliary Dialog"); |
| f.setBounds(X, Y, 650, 100); |
| f.setVisible(true); |
| waitTillShown(f); |
| msgCase.replace(0, msgCase.length(), "Frame (1) over Dialog (2)"); |
| break; |
| case 5: |
| topw = new Window(parentw); |
| msgCase.replace(0, msgCase.length(), "Window (1) over Frame (2)"); |
| break; |
| case 6: |
| topw = new JWindow(parentw); |
| msgCase.replace(0, msgCase.length(), "JWindow (1) over Frame (2)"); |
| break; |
| } |
| topw.addWindowStateListener(new WindowAdapter() { |
| public void windowStateChanged(WindowEvent e) { |
| System.err.println("* " + e); |
| STATE_SEMA.raise(); |
| } |
| }); |
| topw.setSize(300, 100); |
| } |
| |
| /** |
| * 0: setting always-on-top to invisible window |
| * 1: setting always-on-top to visible window |
| * 2: always-on-top on visible non-focusable window |
| * 3: always-on-top on visible, dragging topw after that |
| * 4: always-on-top on visible, dragging f after that |
| * 5: always-on-top on (visible, maximized), make normal after that |
| * 6: always-on-top on (visible, iconified), make normal after that |
| * 7: always-on-top on visible, iconify/deiconify after that |
| * 8: always-on-top on visible, maximize/restore after that |
| */ |
| public static void preAction_0() { |
| topw.setVisible(false); |
| } |
| public static void postAction_0() { |
| if (topw.isShowing()) { |
| error("Test failed: stage #" + stageNum + ", action #" + actNum + ": " + msgCase + |
| ": no actions with windows: changing always-on-top property at window (1) state 'invisible' makes window (1) visible"); |
| } |
| setWindowVisible("no actions with windows", "invisible"); |
| } |
| public static boolean isActionAllowed_0() { |
| // Window on Linux is always always-on-top! |
| return !((stageNum == 5 || stageNum == 6) && isUnix) && (stageNum < stagesCount); |
| } |
| public static void checkActionEvents_0(AWTEvent e) { |
| System.err.println(e.toString()); |
| } |
| |
| public static void preAction_1() { |
| setWindowVisible("no actions with windows", "visible"); |
| } |
| public static void postAction_1() {} |
| public static boolean isActionAllowed_1() { |
| return !((stageNum == 5 || stageNum == 6) && isUnix) && (stageNum < stagesCount ); |
| } |
| public static void checkActionEvents_1(AWTEvent e) { |
| System.err.println(e.toString()); |
| if (e instanceof PaintEvent) { |
| return; |
| } |
| eventsCheckPassed = false; |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc + |
| ": unexpected event " + e + " was generated"); |
| } |
| |
| public static void preAction_2() { |
| setWindowVisible("when window (1) set not focusable", "visible"); |
| topw.setFocusableWindowState(false); |
| f.toFront(); |
| pause(300); |
| } |
| public static void postAction_2() {} |
| public static boolean isActionAllowed_2() { |
| return !((stageNum == 5 || stageNum == 6) && isUnix) && (stageNum < stagesCount); |
| } |
| public static void checkActionEvents_2(AWTEvent e) { |
| System.err.println(e.toString()); |
| if ( (e.getID() >= FocusEvent.FOCUS_FIRST && e.getID() <= FocusEvent.FOCUS_LAST) || |
| (e.getID() == WindowEvent.WINDOW_LOST_FOCUS && e.getID() == WindowEvent.WINDOW_GAINED_FOCUS)) { |
| eventsCheckPassed = false; |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + |
| msgAction + ": after call " + msgFunc + |
| ": unexpected event " + e + " was generated"); |
| } |
| } |
| |
| public static void preAction_3() { |
| setWindowVisible("after dragging", "visible"); |
| } |
| public static void postAction_3() { |
| Point p = topw.getLocationOnScreen(); |
| int x = p.x + 150, y = p.y + 5; |
| |
| try { // Take a pause to avoid double click |
| Thread.sleep(500); // when called one after another. |
| } catch (InterruptedException ie) { |
| ie.printStackTrace(); |
| } catch (IllegalComponentStateException e) { |
| e.printStackTrace(); |
| } |
| |
| // Drag the window. |
| robot.mouseMove(x, y); |
| robot.mousePress(InputEvent.BUTTON1_MASK); |
| robot.mouseMove(X + 150, Y + 100); |
| robot.mouseMove(x, y); |
| robot.mouseRelease(InputEvent.BUTTON1_MASK); |
| } |
| public static boolean isActionAllowed_3() { |
| return (stageNum < 5); |
| } |
| public static void checkActionEvents_3(AWTEvent e) { |
| System.err.println(e.toString()); |
| } |
| |
| public static void preAction_4() { |
| setWindowVisible("after dragging window (2)", "visible"); |
| } |
| public static void postAction_4() { |
| Point p = f.getLocationOnScreen(); |
| int x = p.x + 400, y = p.y + 5; |
| |
| try { // Take a pause to avoid double click |
| Thread.sleep(500); // when called one after another. |
| } catch (InterruptedException ie) { |
| ie.printStackTrace(); |
| } catch (IllegalComponentStateException e) { |
| e.printStackTrace(); |
| } |
| |
| // Drag the window. |
| robot.mouseMove(x, y); |
| robot.mousePress(InputEvent.BUTTON1_MASK); |
| robot.mouseMove(X + 400, Y + 100); |
| robot.mouseMove(x, y); |
| robot.mouseRelease(InputEvent.BUTTON1_MASK); |
| |
| ensureInitialWinPosition(f); |
| } |
| public static boolean isActionAllowed_4() { |
| return !((stageNum == 5 || stageNum == 6) && isUnix); |
| } |
| public static void checkActionEvents_4(AWTEvent e) { |
| System.err.println(e.toString()); |
| } |
| |
| // Metacity has a bug not allowing to set a window to NORMAL state!!! |
| |
| public static void preAction_5() { |
| setWindowVisible("at state 'maximized'", "visible"); |
| ((Frame)topw).setExtendedState(Frame.MAXIMIZED_BOTH); |
| waitForStateChange(); |
| } |
| public static void postAction_5() { |
| ((Frame)topw).setExtendedState(Frame.NORMAL); |
| waitForStateChange(); |
| } |
| public static boolean isActionAllowed_5() { |
| return (stageNum < 2); |
| } |
| public static void checkActionEvents_5(AWTEvent e) { |
| System.err.println("=" + e.toString()); |
| if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) { |
| eventsCheckPassed = true; |
| } |
| } |
| |
| public static void preAction_6() { |
| setWindowVisible("at state 'iconified'", "visible"); |
| System.err.println("Iconifying " + topw); |
| ((Frame)topw).setExtendedState(Frame.ICONIFIED); |
| if (!waitForStateChange()) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc + |
| ": state change to ICONIFIED hasn't been generated"); |
| } |
| } |
| public static void postAction_6() { |
| System.err.println("Restoring " + topw); |
| ((Frame)topw).setExtendedState(Frame.NORMAL); |
| if (!waitForStateChange()) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc + |
| ": state change to NORMAL hasn't been generated"); |
| } |
| } |
| public static boolean isActionAllowed_6() { |
| return (stageNum < 2 ); |
| } |
| public static void checkActionEvents_6(AWTEvent e) { |
| System.err.println("+" + e.toString()); |
| if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) { |
| eventsCheckPassed = true; |
| } |
| } |
| |
| public static void preAction_7() { |
| setWindowVisible("before state 'iconified'", "visible"); |
| } |
| public static void postAction_7() { |
| System.err.println("Setting iconified"); |
| ((Frame)topw).setExtendedState(Frame.ICONIFIED); |
| if (!waitForStateChange()) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc + |
| ": state change to ICONIFIED hasn't been generated"); |
| } |
| System.err.println("Setting normal"); |
| ((Frame)topw).setExtendedState(Frame.NORMAL); |
| if (!waitForStateChange()) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc + |
| ": state change to NORMAL hasn't been generated"); |
| } |
| } |
| public static boolean isActionAllowed_7() { |
| return (stageNum < 2); |
| } |
| public static void checkActionEvents_7(AWTEvent e) { |
| System.err.println(e.toString()); |
| if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) { |
| eventsCheckPassed = true; |
| } |
| } |
| |
| public static void preAction_8() { |
| setWindowVisible("before state 'maximized'", "visible"); |
| } |
| public static void postAction_8() { |
| ((Frame)topw).setExtendedState(Frame.MAXIMIZED_BOTH); |
| if (!waitForStateChange()) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc + |
| ": state change to MAXIMIZED hasn't been generated"); |
| } |
| ((Frame)topw).setExtendedState(Frame.NORMAL); |
| if (!waitForStateChange()) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " + msgFunc + |
| ": state change to NORMAL hasn't been generated"); |
| } |
| } |
| public static boolean isActionAllowed_8() { |
| return (stageNum < 2); |
| } |
| public static void checkActionEvents_8(AWTEvent e) { |
| System.err.println(e.toString()); |
| if (e.getID() == WindowEvent.WINDOW_STATE_CHANGED) { |
| eventsCheckPassed = true; |
| } |
| } |
| |
| //*************************************************************************** |
| |
| private static void setWindowVisible(String mAction, String mVisibility) { |
| msgAction.replace(0, msgAction.length(), mAction); |
| msgVisibility.replace(0, msgVisibility.length(), mVisibility); |
| |
| topw.setVisible(true); |
| pause(100); // Needs for Sawfish |
| topw.setLocation(X, Y); |
| waitTillShown(topw); |
| f.toFront(); |
| pause(300); |
| } |
| |
| private static void clickOn(Object src, Window relwin, int x, int y, String errorStr) { |
| Point p = relwin.getLocationOnScreen(); |
| int counter = 10; |
| while (--counter > 0) { |
| eventSrc = src; |
| msgError.replace(0, msgError.length(), errorStr); |
| |
| robot.mouseMove(p.x + x, p.y + y); |
| robot.mousePress(InputEvent.BUTTON1_MASK); |
| robot.mouseRelease(InputEvent.BUTTON1_MASK); |
| |
| synchronized (eventSrc) { |
| if (!dispatchedCond) { |
| try { |
| eventSrc.wait(1000); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| } |
| } |
| if (!dispatchedCond) { |
| //System.err.println("clickOn: MOUSE_CLICKED event losed, trying to generate it again..."); |
| continue; |
| } |
| dispatchedCond = false; |
| } |
| break; |
| } // end while |
| if (counter <= 0) { |
| eventSrc = uncheckedSrc; |
| error("Test: internal error: could't catch MOUSE_CLICKED event. Skip testing this stage"); |
| } |
| } |
| |
| private static void setAlwaysOnTop(Window w, boolean value) { |
| System.err.println("Setting always on top on " + w + " to " + value); |
| robot.mouseMove(X - 50, Y - 50); // Move out of the window |
| msgFunc.replace(0, msgCase.length(), "setAlwaysOnTop()"); |
| try { |
| w.setAlwaysOnTop(value); |
| } catch (Exception e) { |
| error("Test failed: stage#" + stageNum + "action #" + actNum + ": " + msgCase + ": " + msgAction + |
| ": setAlwaysOnTop(" + value + ") called at state " + msgVisibility + |
| " threw exeption " + e); |
| } |
| } |
| |
| private static boolean isAlwaysOnTop(Window w) { |
| robot.mouseMove(X - 50, Y - 50); // Move out of the window |
| msgFunc.replace(0, msgCase.length(), "isAlwaysOnTop()"); |
| boolean result = false; |
| try { |
| result = w.isAlwaysOnTop(); |
| } catch (Exception e) { |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + |
| ": isAlwaysOnTop() called at state " + msgVisibility + |
| " threw exeption " + e); |
| } |
| return result; |
| } |
| |
| private static void waitTillShown(Component c) { |
| while (true) { |
| try { |
| Thread.sleep(100); |
| c.getLocationOnScreen(); |
| break; |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| break; |
| } |
| } |
| } |
| |
| private static void waitForIdle(boolean doCheck) { |
| try { |
| robot.waitForIdle(); |
| EventQueue.invokeAndWait( new Runnable() { |
| public void run() {} // Dummy implementation |
| } ); |
| } catch(InterruptedException ite) { |
| System.err.println("waitForIdle, non-fatal exception caught:"); |
| ite.printStackTrace(); |
| } catch(InvocationTargetException ine) { |
| System.err.println("waitForIdle, non-fatal exception caught:"); |
| ine.printStackTrace(); |
| } |
| doCheckEvents = doCheck; |
| |
| if (doCheck) { |
| eventsCheckPassed = eventsCheckInitVals[actNum]; // Initialize |
| } else if (!eventsCheckPassed && |
| msgEventsChecks[actNum] != null) { |
| |
| |
| // Some expected event hasn't been catched, |
| // so give it one more chance... |
| doCheckEvents = true; |
| pause(500); |
| doCheckEvents = false; |
| |
| if (!eventsCheckPassed) { |
| testResult = -1; |
| error("Test failed: stage #" + stageNum + ", action # " + actNum + ": " + msgCase + ": " + msgAction + ": after call " |
| + msgFunc + ": " + msgEventsChecks[actNum]); |
| } |
| } |
| } |
| |
| private static boolean waitForStateChange() { |
| System.err.println("------- Waiting for state change"); |
| try { |
| STATE_SEMA.doWait(3000); |
| } catch (InterruptedException ie) { |
| System.err.println("Wait interrupted: " + ie); |
| } |
| boolean state = STATE_SEMA.getState(); |
| STATE_SEMA.reset(); |
| robot.delay(1000); // animation normal <--> maximized states |
| return state; |
| } |
| |
| private static void ensureInitialWinPosition(Window w) { |
| int counter = 30; |
| while (w.getLocationOnScreen().y != Y && --counter > 0) { |
| try { |
| Thread.sleep(100); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| break; |
| } |
| } |
| if (counter <= 0) { |
| w.setLocation(X, Y); |
| pause(100); |
| System.err.println("Test: window set to initial position forcedly"); |
| } |
| } |
| |
| private static void pause(int mls) { |
| try { |
| Thread.sleep(mls); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| private static void error(String msg) { |
| errors.add(msg); |
| System.err.println(msg); |
| } |
| } |
| |
| class Semaphore { |
| boolean state = false; |
| int waiting = 0; |
| public Semaphore() { |
| } |
| public synchronized void doWait() throws InterruptedException { |
| if (state) { |
| return; |
| } |
| waiting++; |
| wait(); |
| waiting--; |
| } |
| public synchronized void doWait(int timeout) throws InterruptedException { |
| if (state) { |
| return; |
| } |
| waiting++; |
| wait(timeout); |
| waiting--; |
| } |
| public synchronized void raise() { |
| state = true; |
| if (waiting > 0) { |
| notifyAll(); |
| } |
| } |
| |
| public synchronized void doNotify() { |
| notifyAll(); |
| } |
| public synchronized boolean getState() { |
| return state; |
| } |
| |
| public synchronized void reset() { |
| state = false; |
| } |
| } |
