classlib/modules/awt/src/test/impl/boot/java/awt/KeyboardFocusManagerTest.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package java.awt;

import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeListenerProxy;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.beans.VetoableChangeListenerProxy;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import junit.framework.TestCase;

public class KeyboardFocusManagerTest extends TestCase {

    boolean                listenerCalled, newListenerCalled, vlistenerCalled;
    KeyboardFocusManager   kfm       = new MyKeyboardManager();

    SimpleComponent        comp      = new SimpleComponent();
    SimpleComponent        comp1     = new SimpleComponent();
    PropertyChangeEvent    event, newEvent, vetoedEvent;
    PropertyChangeListener listener  = new PropertyChangeListener() {

                                         public void propertyChange(
                                                 PropertyChangeEvent e) {
                                             listenerCalled = true;
                                             event = e;
                                         }

                                     };
    VetoableChangeListener vlistener = new VetoableChangeListener() {
                                         String vetoedPropName = "activeWindow";

                                         public void vetoableChange(
                                                 PropertyChangeEvent e)
                                                 throws PropertyVetoException {
                                             event = e;
                                             vlistenerCalled = true;
                                             String propName = e
                                                     .getPropertyName();
                                             if (propName
                                                     .equals(vetoedPropName)
                                                     && e.getNewValue() != null) {
                                                 vetoedEvent = e;
                                                 throw new PropertyVetoException(
                                                         propName
                                                                 + " change is vetoed!",
                                                         e);
                                             }
                                         }

                                     };

    public static void main(String[] args) {
        junit.textui.TestRunner.run(KeyboardFocusManagerTest.class);
    }

    @SuppressWarnings("serial")
    public class SimpleComponent extends Component {
    }

    class MyKeyboardManager extends DefaultKeyboardFocusManager {

    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        listenerCalled = vlistenerCalled = false;
        clearVetoableChangeListeners();
        clearPropertyChangeListeners();
        kfm.clearGlobalFocusOwner();
        kfm.setGlobalActiveWindow(null);
        kfm.setGlobalFocusedWindow(null);
        kfm.setGlobalPermanentFocusOwner(null);
        event = vetoedEvent = newEvent = null;
    }

    /*
     * @see TestCase#tearDown()
     */
    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
    }

    void clearPropertyChangeListeners() {
        if (kfm != null) {
            PropertyChangeListener[] listeners = kfm
                    .getPropertyChangeListeners();
            if (listeners != null) {
                for (PropertyChangeListener element : listeners) {
                    kfm.removePropertyChangeListener(element);
                }
            }
        }
    }

    void clearVetoableChangeListeners() {
        if (kfm != null) {
            VetoableChangeListener[] listeners = kfm
                    .getVetoableChangeListeners();
            if (listeners != null) {
                for (VetoableChangeListener element : listeners) {
                    kfm.removeVetoableChangeListener(element);
                }
            }
        }
    }

    /*
     * Class under test for void addPropertyChangeListener(java.lang.String,
     * java.beans.PropertyChangeListener)
     */
    public final void testAddPropertyChangeListenerString() {
        assertNotNull(kfm);

        String propName = "focusOwner";
        kfm.addPropertyChangeListener(propName, listener);
        PropertyChangeListener[] listeners = kfm
                .getPropertyChangeListeners(propName);
        assertNotNull(listeners);
        int len = listeners.length;
        assertEquals(1, len);
        assertSame(listener, listeners[0]);
        assertFalse(listenerCalled);
        kfm.setGlobalActiveWindow(new Frame());
        assertFalse(listenerCalled);
        kfm.setGlobalFocusOwner(comp);
        assertTrue(listenerCalled);
        assertNotNull(event);
        assertSame(kfm, event.getSource());
        assertNull(event.getOldValue());
        assertSame(comp, event.getNewValue());
        assertEquals(propName, event.getPropertyName());
        listenerCalled = false;
        kfm.setGlobalFocusOwner(comp1);
        assertTrue(listenerCalled);
        assertNotNull(event);
        assertSame(comp, event.getOldValue());
        assertSame(comp1, event.getNewValue());

    }

    /*
     * Class under test for void
     * addPropertyChangeListener(java.beans.PropertyChangeListener)
     */
    // TODO: FIXME
    public final void testAddPropertyChangeListener() {
        assertNotNull(kfm);

        kfm.addPropertyChangeListener(listener);
        PropertyChangeListener[] listeners = kfm.getPropertyChangeListeners();
        assertNotNull(listeners);
        int len = listeners.length;
        assertEquals(1, len);
        assertSame(listener, listeners[0]);
        assertFalse(listenerCalled);
        Frame f = new Frame();
        kfm.setGlobalFocusedWindow(f);
        assertTrue(listenerCalled);
        assertNotNull(event);
        assertNull(event.getOldValue());
        assertSame(f, event.getNewValue());
        assertEquals("focusedWindow", event.getPropertyName());
        listenerCalled = false;
        event = null;
        kfm.setGlobalFocusOwner(comp);
        assertTrue(listenerCalled);
        assertNotNull(event);
        // assertNull(event.getOldValue());
        assertSame(comp, event.getNewValue());
        assertEquals("focusOwner", event.getPropertyName());
        listenerCalled = false;
        event = null;
        kfm.setGlobalFocusOwner(comp1);
        assertTrue(listenerCalled);
        assertNotNull(event);
        assertSame(comp, event.getOldValue());
        assertSame(comp1, event.getNewValue());
        kfm.addPropertyChangeListener("newproperty", listener);
        len = kfm.getPropertyChangeListeners().length;
        assertEquals(2, len);
    }

    /*
     * Class under test for void
     * addVetoableChangeListener(java.beans.VetoableChangeListener)
     */
    // public final void testAddRemoveVetoableChangeListener() {
    // assertNotNull(kfm);
    // kfm.addVetoableChangeListener(vlistener);
    // VetoableChangeListener[] listeners = kfm.getVetoableChangeListeners();
    // assertNotNull(listeners);
    // int len = listeners.length;
    // assertEquals(1, len);
    // assertSame(vlistener, listeners[0]);
    // assertFalse(vlistenerCalled);
    // //test non-vetoed property change:
    // kfm.setGlobalFocusOwner(comp);
    // assertTrue(vlistenerCalled);
    // assertNotNull(event);
    // assertNull(event.getOldValue());
    // assertSame(comp, event.getNewValue());
    // assertEquals("focusOwner", event.getPropertyName());
    // //verify that change wasn't vetoed:
    // assertSame(comp, kfm.getFocusOwner());
    // //test vetoed property change:
    // Frame f = new Frame();
    // vlistenerCalled = false;
    // event = null;
    // kfm.setGlobalActiveWindow(f);
    // assertTrue(vlistenerCalled);
    // assertNotNull(event);
    // //check first that vetoed change was reported to listener:
    // assertSame(f, vetoedEvent.getNewValue());
    // assertNull(vetoedEvent.getOldValue());
    // assertEquals("activeWindow", vetoedEvent.getPropertyName());
    // //then check that the last change was
    // //back to old value:
    // assertSame(f, event.getOldValue());
    // assertNull(event.getNewValue());
    // assertEquals("activeWindow", event.getPropertyName());
    // //verify that the change was vetoed:
    // assertNull(kfm.getActiveWindow());
    // //verify removal of listener:
    // vlistenerCalled = false;
    // event = vetoedEvent = null;
    // kfm.removeVetoableChangeListener(null);
    // listeners = kfm.getVetoableChangeListeners();
    // assertEquals(1, listeners.length);
    // assertSame(vlistener, listeners[0]);
    // kfm.removeVetoableChangeListener(new VetoableChangeListenerProxy("q",
    // vlistener));
    // listeners = kfm.getVetoableChangeListeners();
    // assertEquals(1, listeners.length);
    // assertSame(vlistener, listeners[0]);
    // kfm.removeVetoableChangeListener(vlistener);
    // listeners = kfm.getVetoableChangeListeners();
    // assertEquals(0, listeners.length);
    // kfm.setGlobalActiveWindow(f);
    // assertFalse(vlistenerCalled);
    // assertSame(f, kfm.getActiveWindow());
    //
    // }
    /*
     * Class under test for void addVetoableChangeListener(java.lang.String,
     * java.beans.VetoableChangeListener)
     */
    public final void testAddRemoveVetoableChangeListenerString() {
        assertNotNull(kfm);
        String propName = "focusedWindow";
        kfm.addVetoableChangeListener(propName, vlistener);
        VetoableChangeListener[] listeners = kfm
                .getVetoableChangeListeners(propName);
        assertNotNull(listeners);
        int len = listeners.length;
        assertEquals(1, len);
        assertSame(vlistener, listeners[0]);
        assertFalse(vlistenerCalled);
        Frame f = new Frame();
        kfm.setGlobalActiveWindow(f);
        assertFalse(vlistenerCalled);
        assertSame(f, kfm.getActiveWindow());
        kfm.setGlobalFocusedWindow(f);
        assertTrue(vlistenerCalled);
        assertNotNull(event);
        assertSame(kfm, event.getSource());
        assertNull(event.getOldValue());
        assertSame(f, event.getNewValue());
        assertEquals(propName, event.getPropertyName());
        assertSame(f, kfm.getFocusedWindow());
        vlistenerCalled = false;
        event = vetoedEvent = null;
        kfm.removeVetoableChangeListener("q", vlistener);
        listeners = kfm.getVetoableChangeListeners(propName);
        assertNotNull(listeners);
        assertEquals(1, listeners.length);
        kfm.removeVetoableChangeListener(propName, vlistener);
        listeners = kfm.getVetoableChangeListeners(propName);
        assertNotNull(listeners);
        assertEquals(0, listeners.length);
        kfm.setGlobalFocusedWindow(null);
        assertFalse(vlistenerCalled);
        assertNull(kfm.getFocusedWindow());
        kfm.setGlobalActiveWindow(null);
        assertFalse(vlistenerCalled);
        assertNull(kfm.getActiveWindow());
        propName = "activeWindow";
        kfm.addVetoableChangeListener(propName, vlistener);
        listeners = kfm.getVetoableChangeListeners(propName);
        assertNotNull(listeners);
        assertEquals(1, listeners.length);
        kfm.setGlobalActiveWindow(f);
        assertTrue(vlistenerCalled);
        assertNull(kfm.getActiveWindow());
    }

    /*
     * Class under test for java.beans.PropertyChangeListener[]
     * getPropertyChangeListeners()
     */
    public final void testGetPropertyChangeListeners() {
        PropertyChangeListener[] listeners = kfm.getPropertyChangeListeners();
        assertNotNull(listeners);
        assertEquals(0, listeners.length);
        kfm.addPropertyChangeListener(listener);
        assertEquals(0, listeners.length);
        listeners = kfm.getPropertyChangeListeners();
        assertEquals(1, listeners.length);
        assertSame(listener, listeners[0]);
        String propName = "currentFocusCycleRoot";
        kfm.addPropertyChangeListener(propName, listener);
        listeners = kfm.getPropertyChangeListeners();
        assertEquals(2, listeners.length);
        assertNotSame(listener, listeners[1]);
        assertTrue(listeners[1] instanceof PropertyChangeListenerProxy);
        PropertyChangeListenerProxy proxy = (PropertyChangeListenerProxy) listeners[1];
        assertEquals(propName, proxy.getPropertyName());
        assertSame(listener, proxy.getListener());
    }

    /*
     * Class under test for java.beans.PropertyChangeListener[]
     * getPropertyChangeListeners(java.lang.String)
     */
    public final void testGetPropertyChangeListenersString() {
        String propName = "defaultFocusTraversalPolicy";
        PropertyChangeListener[] listeners = kfm
                .getPropertyChangeListeners(propName);
        assertNotNull(listeners);
        assertEquals(0, listeners.length);

        kfm.addPropertyChangeListener("focusedWindow", listener);
        int len = kfm.getPropertyChangeListeners(propName).length;
        assertEquals(0, len);
        kfm.addPropertyChangeListener(propName, listener);
        listeners = kfm.getPropertyChangeListeners(propName);
        len = listeners.length;
        assertEquals(1, len);
        assertSame(listener, listeners[0]);
        listeners = kfm.getPropertyChangeListeners("property");
        assertEquals(0, listeners.length);
    }

    /*
     * Class under test for java.beans.VetoableChangeListener[]
     * getVetoableChangeListeners(java.lang.String)
     */
    public final void testGetVetoableChangeListenersString() {
        String propName = "permanentFocusOwner";
        VetoableChangeListener[] listeners = kfm
                .getVetoableChangeListeners(propName);
        assertNotNull(listeners);
        assertEquals(0, listeners.length);

        kfm.addPropertyChangeListener("focusedWindow", listener);
        int len = kfm.getVetoableChangeListeners(propName).length;
        assertEquals(0, len);
        kfm.addVetoableChangeListener(propName, vlistener);
        listeners = kfm.getVetoableChangeListeners(propName);
        len = listeners.length;
        assertEquals(1, len);
        assertSame(vlistener, listeners[0]);
        listeners = kfm.getVetoableChangeListeners("q");
        assertEquals(0, listeners.length);
    }

    /*
     * Class under test for java.beans.VetoableChangeListener[]
     * getVetoableChangeListeners()
     */
    public final void testGetVetoableChangeListeners() {
        VetoableChangeListener[] listeners = kfm.getVetoableChangeListeners();
        assertNotNull(listeners);
        assertEquals(0, listeners.length);
        kfm.addVetoableChangeListener(vlistener);
        assertEquals(0, listeners.length);
        listeners = kfm.getVetoableChangeListeners();
        assertEquals(1, listeners.length);
        assertSame(vlistener, listeners[0]);
        String propName = "focusOwner";
        kfm.addVetoableChangeListener(propName, vlistener);
        listeners = kfm.getVetoableChangeListeners();
        assertEquals(2, listeners.length);
        assertNotSame(vlistener, listeners[1]);
        assertTrue(listeners[1] instanceof VetoableChangeListenerProxy);
        VetoableChangeListenerProxy proxy = (VetoableChangeListenerProxy) listeners[1];
        assertEquals(propName, proxy.getPropertyName());
        assertSame(vlistener, proxy.getListener());
    }

    /*
     * Class under test for void removePropertyChangeListener(java.lang.String,
     * java.beans.PropertyChangeListener)
     */
    public final void testRemovePropertyChangeListenerString() {
        String propName = "forwardDefaultFocusTraversalKeys";
        kfm.removePropertyChangeListener(propName, null);
        PropertyChangeListener[] listeners = kfm
                .getPropertyChangeListeners(propName);
        assertNotNull(listeners);
        assertEquals(0, listeners.length);
        kfm.addPropertyChangeListener(propName, listener);
        listeners = kfm.getPropertyChangeListeners(propName);
        assertEquals(1, listeners.length);
        Set<AWTKeyStroke> forSet = new HashSet<AWTKeyStroke>();
        forSet.add(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_ENTER, 0));
        kfm.setDefaultFocusTraversalKeys(
                KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, forSet);
        assertTrue(listenerCalled);
        listenerCalled = false;
        kfm.removePropertyChangeListener("property", listener);
        listeners = kfm.getPropertyChangeListeners(propName);
        assertEquals(1, listeners.length);
        kfm.removePropertyChangeListener(propName, listener);
        listeners = kfm.getPropertyChangeListeners(propName);
        assertEquals(0, listeners.length);
        forSet.add(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_ENTER,
                InputEvent.CTRL_DOWN_MASK));
        kfm.setDefaultFocusTraversalKeys(
                KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, forSet);
        assertFalse(listenerCalled);
    }

    /*
     * Class under test for void
     * removePropertyChangeListener(java.beans.PropertyChangeListener)
     */
    // public final void testRemovePropertyChangeListener() {
    // String propName = "backwardDefaultFocusTraversalKeys";
    // kfm.removePropertyChangeListener(listener);
    // PropertyChangeListener[] listeners = kfm.getPropertyChangeListeners();
    // assertNotNull(listeners);
    // assertEquals(0, listeners.length);
    // kfm.addPropertyChangeListener(propName, listener);
    // listeners = kfm.getPropertyChangeListeners();
    // assertEquals(1, listeners.length);
    // Set backSet = new HashSet();
    // backSet.add(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_SPACE,
    // KeyEvent.CTRL_DOWN_MASK));
    // kfm.setDefaultFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
    // backSet);
    // assertTrue(listenerCalled);
    // listenerCalled = false;
    // kfm.removePropertyChangeListener(listeners[0]);
    // listeners = kfm.getPropertyChangeListeners();
    // assertEquals(0, listeners.length);
    // backSet.add(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_SPACE, 0));
    // kfm.setDefaultFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
    // backSet);
    // assertFalse(listenerCalled);
    // kfm.addPropertyChangeListener(listener);
    // listeners = kfm.getPropertyChangeListeners();
    // assertEquals(1, listeners.length);
    // kfm.firePropertyChange("property", new Integer(0), new Integer(1));
    // assertTrue(listenerCalled);
    // listenerCalled = false;
    // kfm.removePropertyChangeListener(listener);
    // listeners = kfm.getPropertyChangeListeners();
    // assertEquals(0, listeners.length);
    // kfm.firePropertyChange("property", new Integer(1), new Integer(0));
    // assertFalse(listenerCalled);
    //
    // }
    public final void testSetCurrentKeyboardFocusManager() {
        String propName = "managingFocus";
        PropertyChangeListener newListener = new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent e) {
                newListenerCalled = true;
                newEvent = e;
            }

        };

        KeyboardFocusManager oldFocusManager = KeyboardFocusManager
                .getCurrentKeyboardFocusManager();
        assertNotSame(oldFocusManager, kfm);
        oldFocusManager.addPropertyChangeListener(propName, listener);
        kfm.addPropertyChangeListener(propName, newListener);
        KeyboardFocusManager.setCurrentKeyboardFocusManager(kfm);
        assertSame(KeyboardFocusManager.getCurrentKeyboardFocusManager(), kfm);
        assertTrue(listenerCalled);
        assertNotNull(event);
        assertSame(event.getSource(), oldFocusManager);
        assertEquals(propName, event.getPropertyName());
        assertEquals(event.getOldValue(), new Boolean(true));
        assertEquals(event.getNewValue(), new Boolean(false));
        assertTrue(newListenerCalled);
        assertNotNull(newEvent);
        assertSame(newEvent.getSource(), kfm);
        assertEquals(propName, newEvent.getPropertyName());
        assertEquals(newEvent.getOldValue(), new Boolean(false));
        assertEquals(newEvent.getNewValue(), new Boolean(true));
    }

    public void testSetDefaultFocusTraversalKeys() {
        final KeyboardFocusManager mgr = new DefaultKeyboardFocusManager();
        Set<AWTKeyStroke> s;
        Set<AWTKeyStroke> s1;

        try {
            mgr.setDefaultFocusTraversalKeys(-1, createSet());
        } catch (IllegalArgumentException ex) {
            // expected
        }

        try {
            mgr.setDefaultFocusTraversalKeys(
                    KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, null);
        } catch (IllegalArgumentException ex) {
            // expected
        }

        try {
            mgr.setDefaultFocusTraversalKeys(
                    KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
                    createSet((AWTKeyStroke) null));
        } catch (IllegalArgumentException ex) {
            // expected
        }

        try {
            mgr.setDefaultFocusTraversalKeys(
                    KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
                    createSet(AWTKeyStroke.getAWTKeyStroke(KeyEvent.KEY_TYPED,
                            0)));
        } catch (IllegalArgumentException ex) {
            // expected
        }

        try {
            mgr
                    .setDefaultFocusTraversalKeys(
                            KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
                            createSet(AWTKeyStroke.getAWTKeyStroke(
                                    KeyEvent.VK_TAB, 0)));
        } catch (IllegalArgumentException ex) {
            // expected
        }

        s = createSet(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, 0));
        s1 = mgr
                .getDefaultFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
        mgr.addPropertyChangeListener(listener);
        mgr.setDefaultFocusTraversalKeys(
                KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, s);
        assertEquals(
                s,
                mgr
                        .getDefaultFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS));
        assertNotNull(event);
        assertSame(s, event.getNewValue());
        assertSame(s1, event.getOldValue());
    }

    public void testGetDefaultFocusTraversalKeys() {
        final KeyboardFocusManager mgr = new DefaultKeyboardFocusManager();

        assertNotNull(mgr
                .getDefaultFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS));
        assertNotNull(mgr
                .getDefaultFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS));
        assertNotNull(mgr
                .getDefaultFocusTraversalKeys(KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS));
        assertNotNull(mgr
                .getDefaultFocusTraversalKeys(KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS));

        assertEquals(
                createSet(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, 0),
                        AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB,
                                InputEvent.CTRL_DOWN_MASK)),
                mgr
                        .getDefaultFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS));
        assertEquals(
                createSet(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB,
                        InputEvent.SHIFT_DOWN_MASK), AWTKeyStroke
                        .getAWTKeyStroke(KeyEvent.VK_TAB,
                                InputEvent.SHIFT_DOWN_MASK
                                        | InputEvent.CTRL_DOWN_MASK)),
                mgr
                        .getDefaultFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS));
        assertTrue(mgr.getDefaultFocusTraversalKeys(
                KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS).isEmpty());
        assertTrue(mgr.getDefaultFocusTraversalKeys(
                KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS).isEmpty());

        try {
            mgr.getDefaultFocusTraversalKeys(
                    KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS).add(null);
            fail("UnsupportedOperationException was not thrown"); //$NON-NLS-1$
        } catch (UnsupportedOperationException ex) {
            // expected
        }
    }

    private static Set<AWTKeyStroke> createSet(final AWTKeyStroke... keystrokes) {
        final Set<AWTKeyStroke> s = new LinkedHashSet<AWTKeyStroke>();

        for (AWTKeyStroke stroke : keystrokes) {
            s.add(stroke);
        }
        return s;
    }
}