| /* | |
| * Copyright (c) 2003, 2022, 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"); | |
| 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 exception " + 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 exception " + 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; | |
| } | |
| } |