diff -r 4adc75e0c4e5 -r a617d3450e3e jdk/test/java/awt/Modal/helpers/TestFrame.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/awt/Modal/helpers/TestFrame.java Thu Jun 19 12:44:41 2014 +0400 @@ -0,0 +1,369 @@ +/* + * Copyright (c) 2007, 2014, 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. + */ + +import java.awt.*; +import java.awt.event.*; + +import static jdk.testlibrary.Asserts.*; + + + +public class TestFrame extends Frame implements ActionListener, + FocusListener, WindowFocusListener, WindowListener { + + public Button closeButton, openButton, dummyButton; + + public Flag closeClicked, openClicked, dummyClicked; + public Flag closeGained, openGained, dummyGained; + public Flag closeLost, openLost, dummyLost; + public Flag focusGained, focusLost; + public Flag activated; + + public Panel topPanel; + + public static int delay = 500; + public static int keyDelay = 100; + + public TestFrame() { + super(); + initializeGUI(); + } + + private void initFlags() { + closeClicked = new Flag(); + openClicked = new Flag(); + dummyClicked = new Flag(); + closeGained = new Flag(); + openGained = new Flag(); + dummyGained = new Flag(); + closeLost = new Flag(); + openLost = new Flag(); + dummyLost = new Flag(); + focusGained = new Flag(); + focusLost = new Flag(); + activated = new Flag(); + } + + public void resetStatus() { + activated.reset(); + focusGained.reset(); + closeGained.reset(); + openGained.reset(); + closeClicked.reset(); + openClicked.reset(); + } + + private void initializeGUI() { + + initFlags(); + this.setTitle("Frame"); + + this.addWindowFocusListener(this); + this.addWindowListener(this); + + this.setLayout(new GridLayout(3, 1)); + + topPanel = new Panel(); + topPanel.setFocusable(false); + this.add(topPanel); + + Panel p = new Panel(); + p.setLayout(new GridLayout(1, 3)); + + closeButton = new Button("Close"); + closeButton.addActionListener(this); + closeButton.addFocusListener(this); + + openButton = new Button("Open"); + openButton.addActionListener(this); + openButton.addFocusListener(this); + + dummyButton = new Button("Dummy"); + dummyButton.addActionListener(this); + dummyButton.addFocusListener(this); + + p.add(closeButton); + p.add(openButton); + p.add(dummyButton); + + this.add(p); + + Panel bottomPanel = new Panel(); + bottomPanel.setFocusable(false); + this.add(bottomPanel); + + setSize(150, 150); + } + + public void doOpenAction() {} + public void doCloseAction() {} + public void doDummyAction() {} + + @Override + public void actionPerformed(ActionEvent event) { + if (closeButton.equals(event.getSource())) { + closeClicked.flagTriggered(); + doCloseAction(); + } else if (openButton.equals(event.getSource())) { + openClicked.flagTriggered(); + doOpenAction(); + } else if (dummyButton.equals(event.getSource())) { + dummyClicked.flagTriggered(); + doDummyAction(); + } + } + + @Override + public void focusGained(FocusEvent event) { + if (closeButton.equals(event.getSource())) { + closeGained.flagTriggered(); + } else if (openButton.equals(event.getSource())) { + openGained.flagTriggered(); + } else if (dummyButton.equals(event.getSource())) { + dummyGained.flagTriggered(); + } + } + + @Override + public void focusLost(FocusEvent event) { + if (closeButton.equals(event.getSource())) { + closeLost.flagTriggered(); + } else if (openButton.equals(event.getSource())) { + openLost.flagTriggered(); + } else if (dummyButton.equals(event.getSource())) { + dummyLost.flagTriggered(); + } + } + + @Override + public void windowGainedFocus(WindowEvent event) { + focusGained.flagTriggered(); + } + + @Override + public void windowLostFocus(WindowEvent event) { + focusLost.flagTriggered(); + } + + @Override + public void windowActivated(WindowEvent e) { + activated.flagTriggered(); + } + + @Override + public void windowClosed(WindowEvent e) {} + + @Override + public void windowClosing(WindowEvent e) { + assertTrue(false, "user closed window"); + } + + @Override + public void windowDeactivated(WindowEvent e) {} + @Override + public void windowDeiconified(WindowEvent e) {} + @Override + public void windowIconified(WindowEvent e) {} + @Override + public void windowOpened(WindowEvent e) {} + + public void clickButton(Button b, ExtendedRobot robot) { + try { + Flag.waitTillShown(b); + } catch (InterruptedException e) {} + + if ((closeButton.equals(b) || openButton.equals(b) || + dummyButton.equals(b)) && robot != null) { + robot.mouseMove((int) b.getLocationOnScreen().x + b.getSize().width / 2, + (int) b.getLocationOnScreen().y + b.getSize().height / 2); + robot.delay(delay); + robot.click(); + robot.delay(delay); + } + } + + public void clickOpenButton(ExtendedRobot robot) throws Exception { + openClicked.reset(); + clickButton(openButton, robot); + openClicked.waitForFlagTriggered(); + assertTrue(openClicked.flag(), + "clicking the frame Open button did not trigger an action"); + } + + public void clickCloseButton(ExtendedRobot robot) throws Exception { + closeClicked.reset(); + clickButton(closeButton, robot); + closeClicked.waitForFlagTriggered(); + assertTrue(closeClicked.flag(), + "clicking the frame Close button did not trigger an action"); + } + + public void clickDummyButton(ExtendedRobot robot) throws Exception { + clickDummyButton(robot, Flag.ATTEMPTS); + } + + public void clickDummyButton(ExtendedRobot robot, + int amountOfAttempts) throws Exception { + dummyClicked.reset(); + clickButton(dummyButton, robot); + + dummyClicked.waitForFlagTriggered(); + assertTrue(dummyClicked.flag(), + "clicking the frame Dummy button did not trigger an action"); + } + + public void clickInside(ExtendedRobot robot) throws Exception { + try { + Flag.waitTillShown(topPanel); + } catch (InterruptedException e) {} + + if (robot != null) { + robot.mouseMove((int) topPanel.getLocationOnScreen().x + topPanel.getSize().width / 2, + (int) topPanel.getLocationOnScreen().y + topPanel.getSize().height / 2); + robot.delay(delay); + robot.click(); + robot.delay(delay); + } + } + + public void transferFocusToFrame(ExtendedRobot robot, + String message, + Button b) throws Exception { + focusGained.reset(); + clickInside(robot); + + focusGained.waitForFlagTriggered(); + assertTrue(focusGained.flag(), + "Clicking inside the Frame did not make it focused. " + message); + + if (b != null) { + assertTrue(b.hasFocus(), "Button " + b.getLabel() + + " did not gain focus when Frame brought to top"); + } + } + + public void transferFocusToBlockedFrame(ExtendedRobot robot, + String message, + Button b) throws Exception { + focusGained.reset(); + clickInside(robot); + + robot.waitForIdle(delay); + + assertFalse(focusGained.flag(), + "Clicking inside a blocked Frame made it focused. " + message); + + robot.waitForIdle(delay); + if (b != null) { + assertFalse(b.hasFocus(), "Button " + b.getLabel() + + " present in a blocked frame gained focus"); + } + } + + public void checkBlockedFrame( + ExtendedRobot robot, String message) throws Exception { + + dummyGained.reset(); + dummyClicked.reset(); + focusGained.reset(); + + clickButton(dummyButton, robot); + + robot.waitForIdle(delay); + + assertFalse(dummyClicked.flag(), + "DummyButton on blocked Window triggered action when clicked. " + message); + + assertFalse(dummyGained.flag(), + "DummyButton on blocked Window gained focus when clicked. " + message); + + assertFalse(focusGained.flag(), + "A blocked Dialog gained focus when component clicked. " + message); + } + + public void checkUnblockedFrame(ExtendedRobot robot, + String message) throws Exception { + dummyGained.reset(); + dummyClicked.reset(); + clickButton(dummyButton, robot); + + dummyGained.waitForFlagTriggered(); + assertTrue(dummyGained.flag(), + "DummyButton on Frame did not gain focus on clicking. " + message); + + dummyClicked.waitForFlagTriggered(); + assertTrue(dummyClicked.flag(), + "DummyButton on Frame did not trigger action on clicking. " + message); + + closeGained.reset(); + robot.type(KeyEvent.VK_TAB); + + closeGained.waitForFlagTriggered(); + assertTrue(closeGained.flag(), + "FAIL: Tab navigation did not happen properly on Frame. First " + + "button did not gain focus on tab press. " + message); + } + + public void checkCloseButtonFocusGained() { + checkCloseButtonFocusGained(Flag.ATTEMPTS); + } + + public void checkCloseButtonFocusGained(int attempts) { + + try { + closeGained.waitForFlagTriggered(attempts); + } catch (InterruptedException e) {} + + if (closeGained.flag()) { + Component focusOwner = + KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); + assertTrue(closeButton.equals(focusOwner), + "close button gained focus, but it is not the current focus owner"); + } else { + assertTrue(false, "frame Close button did not gain focus"); + } + } + + public void checkOpenButtonFocusGained() { + try { + openGained.waitForFlagTriggered(); + } catch (InterruptedException e) {} + + if (openGained.flag()) { + Component focusOwner = + KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); + assertTrue(openButton.equals(focusOwner), + "open button gained focus, but it is not the current focus owner"); + } else { + assertTrue(false, "frame Open button did not gain focus"); + } + } + + public void checkOpenButtonFocusLost() { + try { + openLost.waitForFlagTriggered(); + } catch (InterruptedException e) {} + + assertTrue(openLost.flag(), "frame Open button did not lose focus"); + } +}