# HG changeset patch # User yan # Date 1398076514 -14400 # Node ID d6acfe6e6bd85aa086d4ab79cdfd2286bdea4f4f # Parent d3d9e027b19019ec293618550010877d056f40c2 8039279: Move awt tests to openjdk repository Reviewed-by: pchelko, alexsch Contributed-by: Dmitriy Ermashov diff -r d3d9e027b190 -r d6acfe6e6bd8 jdk/test/java/awt/Frame/SetMaximizedBounds/SetMaximizedBounds.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/awt/Frame/SetMaximizedBounds/SetMaximizedBounds.java Mon Apr 21 14:35:14 2014 +0400 @@ -0,0 +1,88 @@ +/* + * 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.*; + +/* + * @test + * @summary When Frame.setExtendedState(Frame.MAXIMIZED_BOTH) + * is called for a Frame after been called setMaximizedBounds() with + * certain value, Frame bounds must equal to this value. + * + * @library ../../../../lib/testlibrary + * @build ExtendedRobot + * @run main SetMaximizedBounds + */ + +public class SetMaximizedBounds { + + Frame frame; + Rectangle bound; + boolean supported; + ExtendedRobot robot; + static Rectangle max = new Rectangle(100,100,400,400); + + public void doTest() throws Exception { + robot = new ExtendedRobot(); + + EventQueue.invokeAndWait( () -> { + frame = new Frame( "TestFrame "); + frame.setLayout(new FlowLayout()); + + if (Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.MAXIMIZED_BOTH)) { + supported = true; + frame.setMaximizedBounds(max); + } else { + supported = false; + } + + frame.setSize(200, 200); + frame.setVisible(true); + }); + + robot.waitForIdle(2000); + if (supported) { + EventQueue.invokeAndWait( () -> { + frame.setExtendedState(Frame.MAXIMIZED_BOTH); + }); + robot.waitForIdle(2000); + bound = frame.getBounds(); + if(!bound.equals(max)) + throw new RuntimeException("The bounds of the Frame do not equal to what" + + " is specified when the frame is in Frame.MAXIMIZED_BOTH state"); + } else { + System.out.println("Frame.MAXIMIZED_BOTH not supported"); + } + + frame.dispose(); + } + + public static void main(String[] args) throws Exception { + String os = System.getProperty("os.name").toLowerCase(); + System.out.println(os); + if (os.contains("windows") || os.contains("os x")) + new SetMaximizedBounds().doTest(); + else + System.out.println("Platform "+os+" is not supported. Supported platforms are Windows and OS X."); + } +} diff -r d3d9e027b190 -r d6acfe6e6bd8 jdk/test/java/awt/GridLayout/ChangeGridSize/ChangeGridSize.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/awt/GridLayout/ChangeGridSize/ChangeGridSize.java Mon Apr 21 14:35:14 2014 +0400 @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2006, 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.*; + +/* + * @test + * @summary Have different components having different preferred sizes + * added to a grid layout. Change the rows and columns of the + * grid layout and check the components are re-laid out. + * The strategy followed is to calculate the component location + * depending on the preferred sizes and gaps and click the cornors + * of the components to check if events are triggered + * @library ../../../../lib/testlibrary/ + * @build ExtendedRobot + * @run main ChangeGridSize + * @run main ChangeGridSize -hg 20 -vg 20 + */ + +public class ChangeGridSize { + + private int width = 200; + private int height = 200; + private final int hGap, vGap; + private final int rows = 3; + private final int columns = 2; + private final int componentCount = 6; + + private Button[] buttons; + private Frame frame; + + private ExtendedRobot robot; + private GridLayout layout; + + private volatile boolean actionPerformed = false; + + public ChangeGridSize(int hGap, int vGap) throws Exception { + this.hGap = hGap; + this.vGap = vGap; + robot = new ExtendedRobot(); + EventQueue.invokeAndWait( () -> { + frame = new Frame("Test frame"); + frame.setSize(width, height); + layout = new GridLayout(rows + 3, columns - 1, hGap, vGap); + frame.setLayout(layout); + + buttons = new Button[componentCount]; + for (int i = 0; i < componentCount; i++) { + buttons[i] = new Button("Button" + i); + frame.add(buttons[i]); + buttons[i].addActionListener( (event) -> { actionPerformed = true; }); + } + frame.setVisible(true); + }); + } + + public static void main(String[] args) throws Exception { + int hGap = 0; + int vGap = 0; + for (int i = 0; i < args.length; i++) { + switch (args[i]) { + case "-hg": + hGap = Integer.parseInt(args[++i]); + break; + case "-vg": + vGap = Integer.parseInt(args[++i]); + break; + } + } + new ChangeGridSize(hGap, vGap).doTest(); + } + + private void resizeFrame() throws Exception { + EventQueue.invokeAndWait(() -> { + Insets insets = frame.getInsets(); + double dH = (height-insets.top-insets.bottom - vGap*(rows-1)) % rows; + double dW = (width-insets.left-insets.right - hGap*(columns-1)) % columns; + height -= dH; + width -= dW; + frame.setSize(width, height); + frame.revalidate(); + }); + robot.waitForIdle(); + } + + private void changeGridSize() throws Exception { + EventQueue.invokeAndWait(() -> { + layout.setRows(rows); + layout.setColumns(columns); + + frame.revalidate(); + }); + robot.waitForIdle(); + } + + public void testBoundaries(int topLeftX, int topLeftY, int bottomRightX, int bottomRightY) throws Exception { + + actionPerformed = false; + robot.mouseMove(topLeftX, topLeftY); + robot.delay(500); + robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); + robot.delay(500); + robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK); + robot.waitForIdle(3000); + + if(!actionPerformed) + throw new RuntimeException("Clicking on the left top of button did not trigger action event"); + + actionPerformed = false; + robot.mouseMove(bottomRightX, bottomRightY); + robot.delay(500); + robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); + robot.delay(500); + robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK); + robot.waitForIdle(3000); + + if(!actionPerformed) + throw new RuntimeException("Clicking on the bottom right of button did not trigger action event"); + } + + private void doTest() throws Exception { + robot.waitForIdle(); + changeGridSize(); + resizeFrame(); + + int availableWidth = width - frame.getInsets().left - + frame.getInsets().right; + int componentWidth = (availableWidth + hGap) / columns - hGap; + int availableHeight = height - frame.getInsets().top - + frame.getInsets().bottom; + int componentHeight = (availableHeight + vGap) / rows - vGap; + + for (int i = 0; i < buttons.length; i++) { + if (buttons[i].getSize().width != componentWidth || + buttons[i].getSize().height != componentHeight) { + throw new RuntimeException( + "FAIL: Button " + i + " not of proper size" + + "Expected: " + componentWidth + "*" + componentHeight + + "Actual: " + buttons[i].getSize().width + "*" + buttons[i].getSize().height); + } + } + + // Components are visible. They should trigger events. + // Now you can check for the actual size shown. + int currentRow = 1; + int currentColumn = 0; + for (int i = 0; i < buttons.length; i++) { + currentColumn++; + if (currentColumn > columns) { + currentColumn = 1; + currentRow++; + } + + int topPosX = frame.getLocationOnScreen().x + + frame.getInsets().left + + (currentColumn - 1) * (componentWidth + hGap); + int topPosY = frame.getLocationOnScreen().y + + frame.getInsets().top + + (currentRow - 1) * (componentHeight + vGap); + + int bottomPosX = topPosX + componentWidth - 1; + int bottomPosY = topPosY + componentHeight - 1; + testBoundaries(topPosX, topPosY, bottomPosX, bottomPosY); + } + + frame.dispose(); + } +} diff -r d3d9e027b190 -r d6acfe6e6bd8 jdk/test/java/awt/GridLayout/ComponentPreferredSize/ComponentPreferredSize.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/awt/GridLayout/ComponentPreferredSize/ComponentPreferredSize.java Mon Apr 21 14:35:14 2014 +0400 @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2006, 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.InputEvent; + +/* + * @test + * @summary Have different components having different preferred sizes + * added to a grid layout having various values of row/columns. + * Check if the compnents are correctly laid out. + * The strategy followed is to calculate the component location + * depending on the preferred sizes and gaps and click the cornors + * of the components to check if events are triggered + * @library ../../../../lib/testlibrary/ + * @build ExtendedRobot + * @run main ComponentPreferredSize + * @run main ComponentPreferredSize -hg 20 -vg 20 + */ + +public class ComponentPreferredSize { + + private int width = 200; + private int height = 200; + private final int hGap, vGap; + private final int rows = 3; + private final int columns = 2; + private final int componentCount = 6; + + private Button[] buttons; + private Frame frame; + + private ExtendedRobot robot; + private GridLayout layout; + + private volatile boolean actionPerformed = false; + + public ComponentPreferredSize(int hGap, int vGap) throws Exception { + this.hGap = hGap; + this.vGap = vGap; + robot = new ExtendedRobot(); + EventQueue.invokeAndWait( () -> { + frame = new Frame("Test frame"); + frame.setSize(width, height); + layout = new GridLayout(rows, columns, hGap, vGap); + frame.setLayout(layout); + + buttons = new Button[componentCount]; + for (int i = 0; i < componentCount; i++) { + buttons[i] = new Button("Button" + i); + buttons[i].setPreferredSize(new Dimension((int) Math.random() * 100, + (int) Math.random() * 100)); + frame.add(buttons[i]); + buttons[i].addActionListener((event) -> {actionPerformed = true;}); + } + + frame.setVisible(true); + }); + } + + public static void main(String[] args) throws Exception { + int hGap = 0; + int vGap = 0; + for (int i = 0; i < args.length; i++) { + switch (args[i]) { + case "-hg": + hGap = Integer.parseInt(args[++i]); + break; + case "-vg": + vGap = Integer.parseInt(args[++i]); + break; + } + } + new ComponentPreferredSize(hGap, vGap).doTest(); + } + + private void resizeFrame() throws Exception { + EventQueue.invokeAndWait(() -> { + Insets insets = frame.getInsets(); + double dH = (height-insets.top-insets.bottom - vGap*(rows-1)) % rows; + double dW = (width-insets.left-insets.right - hGap*(columns-1)) % columns; + height -= dH; + width -= dW; + frame.setSize(width, height); + frame.revalidate(); + }); + robot.waitForIdle(); + } + + public void testBoundaries(int topLeftX, int topLeftY, int bottomRightX, int bottomRightY) throws Exception { + + actionPerformed = false; + robot.mouseMove(topLeftX, topLeftY); + robot.delay(500); + robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); + robot.delay(500); + robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK); + robot.waitForIdle(3000); + + if(!actionPerformed) + throw new RuntimeException("Clicking on the left top of button did not trigger action event"); + + actionPerformed = false; + robot.mouseMove(bottomRightX, bottomRightY); + robot.delay(500); + robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); + robot.delay(500); + robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK); + robot.waitForIdle(3000); + + if(!actionPerformed) + throw new RuntimeException("Clicking on the bottom right of button did not trigger action event"); + } + + private void doTest() throws Exception { + robot.waitForIdle(); + resizeFrame(); + + int availableWidth = width - frame.getInsets().left - + frame.getInsets().right; + int componentWidth = (availableWidth + hGap) / columns - hGap; + int availableHeight = height - frame.getInsets().top - + frame.getInsets().bottom; + int componentHeight = (availableHeight + vGap) / rows - vGap; + + for (int i = 0; i < buttons.length; i++) { + if (buttons[i].getSize().width != componentWidth || + buttons[i].getSize().height != componentHeight) { + throw new RuntimeException( + "FAIL: Button " + i + " not of proper size" + + "Expected: " + componentWidth + "*" + componentHeight + + "Actual: " + buttons[i].getSize().width + "*" + buttons[i].getSize().height); + } + } + + // Components are visible. They should trigger events. + // Now you can check for the actual size shown. + int currentRow = 1; + int currentColumn = 0; + for (int i = 0; i < buttons.length; i++) { + currentColumn++; + if (currentColumn > columns) { + currentColumn = 1; + currentRow++; + } + + int topPosX = frame.getLocationOnScreen().x + + frame.getInsets().left + + (currentColumn - 1) * (componentWidth + hGap); + int topPosY = frame.getLocationOnScreen().y + + frame.getInsets().top + + (currentRow - 1) * (componentHeight + vGap); + + int bottomPosX = topPosX + componentWidth - 1; + int bottomPosY = topPosY + componentHeight - 1; + testBoundaries(topPosX, topPosY, bottomPosX, bottomPosY); + } + + frame.dispose(); + } +} diff -r d3d9e027b190 -r d6acfe6e6bd8 jdk/test/java/awt/Robot/ModifierRobotKey/ModifierRobotKeyTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/awt/Robot/ModifierRobotKey/ModifierRobotKeyTest.java Mon Apr 21 14:35:14 2014 +0400 @@ -0,0 +1,230 @@ +/* + * 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.assertTrue; + +/* + * @test + * @summary Make sure that modifier key mask is set when robot press + * some key with one or more modifiers. + * + * @library ../../../../lib/testlibrary/ + * @build ExtendedRobot + * @run main ModifierRobotKeyTest + */ + +public class ModifierRobotKeyTest extends KeyAdapter { + + private boolean focusGained = false; + private boolean startTest = false; + private ExtendedRobot robot; + private Frame frame; + private Canvas canvas; + + private volatile boolean tempPress = false; + + private int[] textKeys, modifierKeys, inputMasks; + private boolean[] modifierStatus, textStatus; + + private final static int waitDelay = 5000; + private Object tempLock = new Object(); + private Object keyLock = new Object(); + + public static void main(String[] args) throws Exception { + ModifierRobotKeyTest test = new ModifierRobotKeyTest(); + test.doTest(); + } + + public ModifierRobotKeyTest() throws Exception { + modifierKeys = new int[3]; + modifierKeys[0] = KeyEvent.VK_SHIFT; + modifierKeys[1] = KeyEvent.VK_CONTROL; + modifierKeys[2] = KeyEvent.VK_ALT; + + inputMasks = new int[3]; + inputMasks[0] = InputEvent.SHIFT_MASK; + inputMasks[1] = InputEvent.CTRL_MASK; + inputMasks[2] = InputEvent.ALT_MASK; + + modifierStatus = new boolean[modifierKeys.length]; + + textKeys = new int[2]; + textKeys[0] = KeyEvent.VK_A; + + String os = System.getProperty("os.name").toLowerCase(); + + if (os.contains("solaris") || os.contains("sunos")) + textKeys[1] = KeyEvent.VK_S; + else if (os.contains("os x")) + textKeys[1] = KeyEvent.VK_K; + else + textKeys[1] = KeyEvent.VK_I; + + textStatus = new boolean[textKeys.length]; + + EventQueue.invokeAndWait( () -> { initializeGUI(); }); + } + + public void keyPressed(KeyEvent event) { + + tempPress = true; + synchronized (tempLock) { tempLock.notifyAll(); } + + if (! startTest) { + return; + } + for (int x = 0; x < inputMasks.length; x++) { + if ((event.getModifiers() & inputMasks[x]) != 0) { + System.out.println("Modifier set: " + event.getKeyModifiersText(inputMasks[x])); + modifierStatus[x] = true; + } + } + for (int x = 0; x < textKeys.length; x++) { + if (event.getKeyCode() == textKeys[x]) { + System.out.println("Text set: " + event.getKeyText(textKeys[x])); + textStatus[x] = true; + } + } + + synchronized (keyLock) { keyLock.notifyAll(); } + } + + private void initializeGUI() { + frame = new Frame("Test frame"); + canvas = new Canvas(); + canvas.addFocusListener(new FocusAdapter() { + public void focusGained(FocusEvent event) { focusGained = true; } + }); + canvas.addKeyListener(this); + frame.setLayout(new BorderLayout()); + frame.add(canvas); + frame.setSize(200, 200); + frame.setVisible(true); + } + + public void doTest() throws Exception { + robot = new ExtendedRobot(); + + robot.mouseMove((int) frame.getLocationOnScreen().getX() + frame.getSize().width / 2, + (int) frame.getLocationOnScreen().getY() + frame.getSize().height / 2); + robot.click(MouseEvent.BUTTON1_MASK); + robot.waitForIdle(); + + assertTrue(focusGained, "FAIL: Canvas gained focus!"); + + for (int i = 0; i < modifierKeys.length; i++) { + for (int j = 0; j < textKeys.length; j++) { + tempPress = false; + robot.keyPress(modifierKeys[i]); + robot.waitForIdle(); + if (! tempPress) { + synchronized (tempLock) { tempLock.wait(waitDelay); } + } + assertTrue(tempPress, "FAIL: keyPressed triggered for i=" + i); + + resetStatus(); + startTest = true; + robot.keyPress(textKeys[j]); + robot.waitForIdle(); + if (! modifierStatus[i] || ! textStatus[j]) { + synchronized (keyLock) { keyLock.wait(waitDelay); } + } + + + assertTrue(modifierStatus[i] && textStatus[j], + "FAIL: KeyEvent not proper!"+ + "Key checked: i=" + i + "; j=" + j+ + "ModifierStatus = " + modifierStatus[i]+ + "TextStatus = " + textStatus[j]); + startTest = false; + robot.keyRelease(textKeys[j]); + robot.waitForIdle(); + robot.keyRelease(modifierKeys[i]); + robot.waitForIdle(); + } + } + + for (int i = 0; i < modifierKeys.length; i++) { + for (int j = i + 1; j < modifierKeys.length; j++) { + for (int k = 0; k < textKeys.length; k++) { + tempPress = false; + robot.keyPress(modifierKeys[i]); + robot.waitForIdle(); + if (! tempPress) { + synchronized (tempLock) { tempLock.wait(waitDelay); } + } + + assertTrue(tempPress, "FAIL: MultiKeyTest: keyPressed triggered for i=" + i); + + tempPress = false; + robot.keyPress(modifierKeys[j]); + robot.waitForIdle(); + if (! tempPress) { + synchronized (tempLock) { tempLock.wait(waitDelay); } + } + assertTrue(tempPress, "FAIL: MultiKeyTest keyPressed triggered for j=" + j); + + resetStatus(); + startTest = true; + robot.keyPress(textKeys[k]); + robot.waitForIdle(); + if (! modifierStatus[i] || ! modifierStatus[j] || ! textStatus[k]) { + synchronized (keyLock) { + keyLock.wait(waitDelay); + } + } + assertTrue(modifierStatus[i] && modifierStatus[j] && textStatus[k], + "FAIL: KeyEvent not proper!"+ + "Key checked: i=" + i + "; j=" + j + "; k=" + k+ + "Modifier1Status = " + modifierStatus[i]+ + "Modifier2Status = " + modifierStatus[j]+ + "TextStatus = " + textStatus[k]); + + startTest = false; + robot.keyRelease(textKeys[k]); + robot.waitForIdle(); + robot.keyRelease(modifierKeys[j]); + robot.waitForIdle(); + robot.keyRelease(modifierKeys[i]); + robot.waitForIdle(); + } + } + } + + frame.dispose(); + } + + private void resetStatus() { + for (int i = 0; i < modifierStatus.length; i++) { + modifierStatus[i] = false; + } + for (int i = 0; i < textStatus.length; i++) { + textStatus[i] = false; + } + } + +} diff -r d3d9e027b190 -r d6acfe6e6bd8 jdk/test/java/awt/Toolkit/LockingKeyStateTest/LockingKeyStateTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/awt/Toolkit/LockingKeyStateTest/LockingKeyStateTest.java Mon Apr 21 14:35:14 2014 +0400 @@ -0,0 +1,126 @@ +/* + * Copyright (c) 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.KeyEvent; + +/* + @test + @summary verify LOCK buttons toogle + @author Yuri.Nesterenko, Dmitriy.Ermashov + @library ../../../../lib/testlibrary + @build ExtendedRobot + @run main LockingKeyStateTest +*/ + +public class LockingKeyStateTest { + + Frame frame; + ExtendedRobot robot; + + // Note that Kana lock you may actually toggle only if you have one. + static int[] lockingKeys = { KeyEvent.VK_CAPS_LOCK, KeyEvent.VK_NUM_LOCK, + KeyEvent.VK_SCROLL_LOCK, KeyEvent.VK_KANA_LOCK }; + boolean[] getSupported = new boolean[lockingKeys.length]; + boolean[] setSupported = new boolean[lockingKeys.length]; + boolean[] state0 = new boolean[lockingKeys.length]; + + Toolkit toolkit = Toolkit.getDefaultToolkit(); + + LockingKeyStateTest() throws Exception { + robot = new ExtendedRobot(); + EventQueue.invokeAndWait( this::createGui ); + } + + void toggleAllTrue(){toggleAll(true);} + void toggleAllFalse(){toggleAll(false);} + void toggleAll(boolean b) { + for(int i = 0; i < lockingKeys.length; i++) { + if(setSupported[i]) { + toolkit.setLockingKeyState(lockingKeys[i], b); + } + } + } + + void checkAllTrue(){checkAll(true);} + void checkAllFalse(){checkAll(false);} + void checkAll(boolean b) { + for(int i = 0; i < lockingKeys.length; i++) { + if(getSupported[i] && setSupported[i]) { + if (!(toolkit.getLockingKeyState(lockingKeys[i]) == b)) + throw new RuntimeException("State of "+KeyEvent.getKeyText(lockingKeys[i])+" is not "+b); + System.out.println("OK, state of "+KeyEvent.getKeyText(lockingKeys[i])+" is "+b); + } + } + } + + void restoreAll() { + for(int i = 0; i < lockingKeys.length; i++) { + if(setSupported[i] && getSupported[i]) { + toolkit.setLockingKeyState(lockingKeys[i], state0[i]); + } + } + } + + public void createGui() { + for(int i = 0; i < lockingKeys.length; i++) { + getSupported[i] = false; + setSupported[i] = false; + try { + state0[i] = toolkit.getLockingKeyState(lockingKeys[i]); + getSupported[i] = true; + toolkit.setLockingKeyState(lockingKeys[i], state0[i]); + setSupported[i] = true; + } catch (UnsupportedOperationException uoe) { + } + System.out.println(" State get/set of "+KeyEvent.getKeyText(lockingKeys[i])+" is supported? "+ + getSupported[i]+", "+setSupported[i]); + } + frame = new Frame("LockingKeyStateTest Title"); + frame.setSize(200,200); + frame.setVisible(true); + } + + void doTest() throws Exception{ + robot.waitForIdle(); + robot.mouseMove(frame.getLocationOnScreen().x + frame.getWidth() / 2, + frame.getLocationOnScreen().y + frame.getHeight() / 2); + robot.click(); + + EventQueue.invokeAndWait( this::toggleAllTrue ); + robot.waitForIdle(2000); + EventQueue.invokeAndWait( this::checkAllTrue ); + EventQueue.invokeAndWait( this::toggleAllFalse ); + robot.waitForIdle(2000); + EventQueue.invokeAndWait( this::checkAllFalse ); + EventQueue.invokeAndWait( this::restoreAll ); + robot.waitForIdle(); + + frame.dispose(); + } + + public static void main(String argv[]) throws Exception { + LockingKeyStateTest af = new LockingKeyStateTest(); + af.doTest(); + } +}