home | career | drupal | java | mac | mysql | perl | scala | uml | unix

Groovy example source code file (SwingBuilderTest.groovy)

This example Groovy source code file (SwingBuilderTest.groovy) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Groovy tags/keywords

a, a, awt, b, border, c, d, event, gui, id, metallookandfeel, metallookandfeel, self, string, swing, swingbuilder, swingbuilder, text, title, title

The Groovy SwingBuilderTest.groovy source code

/*
 * Copyright 2003-2008 the original author or authors.
 *
 * Licensed 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 groovy.swing

import javax.swing.JPopupMenu.Separator as JPopupMenu_Separator
import javax.swing.JToolBar.Separator as JToolBar_Separator

import groovy.ui.Console
import java.awt.*
import java.awt.event.InputEvent
import java.awt.event.KeyEvent
import java.text.SimpleDateFormat
import javax.swing.*
import javax.swing.border.TitledBorder
import javax.swing.plaf.metal.MetalLookAndFeel
import javax.swing.text.DateFormatter
import javax.swing.text.NumberFormatter
import java.awt.event.ActionEvent

class SwingBuilderTest extends GroovySwingTestCase {

    void testWidgetId() {
      testInEDT {

        def swing = new SwingBuilder()
        def localVar = null

        swing.panel {
            label('byAttr', id:'byAttr')
            byExpr = label('byExpr')
            localVar = label('localVar')
        }
        swing[SwingBuilder.DELEGATE_PROPERTY_OBJECT_ID] = 'key'
        swing.panel {
            label('byKey', key:'byKey')
        }

        assert localVar != null
        assert swing.getVariables().containsKey('byAttr')
        assert swing.getVariables().containsKey('byExpr')
        assert !swing.getVariables().containsKey('localVar')
        assert swing.getVariables().containsKey('byKey')
      }
    }

    void testNamedWidgetCreation() {
      testInEDT {
        def topLevelWidgets = [
            frame: [JFrame.class, true],
            dialog: [JDialog.class, true],
            window: [JWindow.class, false],
            fileChooser: [JFileChooser.class, false],
            optionPane: [JOptionPane.class, false]
        ]
        def swing = new SwingBuilder()
        topLevelWidgets.each{ name, widgetInfo ->
            if (widgetInfo[1])
                swing."$name"(id:"${name}Id".toString(), title:"This is my $name")
            else
                swing."$name"(id:"${name}Id".toString())
            def widget = swing."${name}Id"
            assert widget.class == widgetInfo[0]
            if (widgetInfo[1]) assert widget.title == "This is my $name"
        }
      }
    }

    void testLayoutCreation() {
      testInEDT {

        def layouts = [
            borderLayout: BorderLayout.class,
            cardLayout: CardLayout.class,
            flowLayout: FlowLayout.class,
            gridBagLayout: GridBagLayout.class,
            gridLayout: GridLayout.class,
//            overlayLayout: OverlayLayout.class,
            springLayout: SpringLayout.class,
//            boxLayout: BoxLayout.class
        ]
        def swing = new SwingBuilder()
        layouts.each{ name, expectedLayoutClass ->
            def frame = swing.frame(){
               "$name"()
            }
            assert frame.contentPane.layout.class == expectedLayoutClass
        }
      }
    }

    void testGridBagFactory() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.frame {
            gridBagLayout()
            label(fill:BOTH)
        }
        shouldFail {
            swing.frame {
                flowLayout()
                label(fill:BOTH)
            }
        }
        shouldFail {
            swing.frame {
                label(fill:GridBagConstraints.BOTH)
            }
        }
      }
    }

    void testBorderLayout() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.frame {
          borderLayout()
          label("x", constraints:NORTH)
        }

        // test that BorderLayout.NORTH is not implied
        shouldFail(MissingPropertyException) {
            swing.frame {
              label("x", constraints:NORTH)
            }
        }
      }
    }

    void testLayoutConstraintsProperty() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.frame {
          borderLayout(constraintsProperty:'direction')
          label("x", direction:NORTH)
        }
      }
    }

    void testWidgetCreation() {
      testInEDT {

        def widgets = [
            button: JButton.class,
            checkBox: JCheckBox.class,
            checkBoxMenuItem: JCheckBoxMenuItem.class,
            colorChooser: JColorChooser.class,
            comboBox: JComboBox.class,
            desktopPane: JDesktopPane.class,
            editorPane: JEditorPane.class,
            formattedTextField: JFormattedTextField.class,
            internalFrame: JInternalFrame.class,
            label: JLabel.class,
            layeredPane: JLayeredPane.class,
            list: JList.class,
            menu: JMenu.class,
            menuBar: JMenuBar.class,
            menuItem: JMenuItem.class,
            panel: JPanel.class,
            passwordField: JPasswordField.class,
            popupMenu: JPopupMenu.class,
            progressBar: JProgressBar.class,
            radioButton: JRadioButton.class,
            radioButtonMenuItem: JRadioButtonMenuItem.class,
            scrollBar: JScrollBar.class,
            scrollPane: JScrollPane.class,
            separator: JSeparator.class,
            slider: JSlider.class,
            spinner: JSpinner.class,
            splitPane: JSplitPane.class,
            tabbedPane: JTabbedPane.class,
            table: JTable.class,
            textArea: JTextArea.class,
            textPane: JTextPane.class,
            textField: JTextField.class,
            toggleButton: JToggleButton.class,
            toolBar: JToolBar.class,
            tree: JTree.class,
            viewport: JViewport.class,
        ]
        def swing = new SwingBuilder()
        widgets.each{ name, expectedLayoutClass ->
            def frame = swing.frame(){
               "$name"(id:"${name}Id".toString())
            }
            assert swing."${name}Id".class == expectedLayoutClass
        }
      }
    }

    void testButtonGroup() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.panel {
            buttonGroup(id:'group1')
            buttonGroup(id:'group2')
            checkBox(id:'cb1a', buttonGroup:group1)
            checkBox(id:'cb1b', buttonGroup:group1)
            checkBox(id:'cb2a', buttonGroup:group2)
            checkBox(id:'cb2b', buttonGroup:group2)

        }

        def statusCBs = {[swing.cb1a.selected, swing.cb1b.selected, swing.cb2a.selected, swing.cb2b.selected]}

        assert statusCBs() == [false, false, false, false]

        swing.cb1a.selected = true
        assert statusCBs() == [true, false, false, false]

        swing.cb1b.selected = true
        assert statusCBs() == [false, true, false, false]

        swing.cb2a.selected = true
        assert statusCBs() == [false, true, true, false]

        swing.cb2b.selected = true
        assert statusCBs() == [false, true, false, true]

      }
    }

    void testButtonGroupOnlyForButtons() {
      testInEDT {
        def swing = new SwingBuilder()

        def buttonGroup = swing.buttonGroup()
        shouldFail(MissingPropertyException) {
            swing.label(buttonGroup:buttonGroup)
        }
      }
    }

    void testWidget() {
      testInEDT {

        def swing = new SwingBuilder()
        def label = swing.label("By Value:")
        def widgetByValue = swing.widget(label)
        assert widgetByValue != null
        def widgetByLabel = swing.widget(widget: label)
        assert widgetByLabel != null
      }
    }

    void testSplitPane() {
      testInEDT {

        def swing = new SwingBuilder()
        def buttonGroup = swing.buttonGroup()
        def frame = swing.frame(){
            splitPane(id:'hsplit', orientation: JSplitPane.HORIZONTAL_SPLIT) {
                button(id:'left', buttonGroup:buttonGroup)
                button(id:'right', buttonGroup:buttonGroup)
            }
            splitPane(id:'vsplit', orientation: JSplitPane.VERTICAL_SPLIT) {
                button(id:'top')
                button(id:'bottom')
            }
        }
        assert swing.hsplit.leftComponent == swing.left
        assert swing.hsplit.rightComponent == swing.right
        assert swing.vsplit.topComponent == swing.top
        assert swing.vsplit.bottomComponent == swing.bottom
      }
    }

    void testNestedWindows() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.window (id:'root') {
            window(id:'child1')
            frame(id:'child2') {
                window(id:'child2_1')
            }
        }
        swing.window (id:'root2')

        //assert swing.root.owner == null
        assert swing.child1.owner == swing.root
        assert swing.child2.owner == null // it's a frame, frames have no owners
        assert swing.child2_1.owner == swing.child2

        assert swing.root2.owner != swing.root
        assert swing.root2.owner != swing.child1
        assert swing.root2.owner != swing.child2
        assert swing.root2.owner != swing.child2_1

        swing.panel {
            swing.frame()
            swing.window()
            swing.dialog()
        }
      }
    }

    void testFrames() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.frame(id:'frame') {
            button('test', id:'button', defaultButton:true)
        }
        assert swing.frame.rootPane.defaultButton == swing.button
        assert swing.button.defaultButton
      }
    }

    void testDialogs() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.dialog(id:'d1')
        swing.frame(id:'f') { dialog(id:'fd') }
        swing.dialog(id:'d') { dialog(id:'dd') }
        swing.dialog(id:'d2')

        //assert swing.d1.owner == null
        assert swing.fd.owner == swing.f
        assert swing.dd.owner == swing.d

        assert swing.d2.owner != swing.dd
        assert swing.d2.owner != swing.fd
        assert swing.d2.owner != swing.d
        assert swing.d2.owner != swing.f
        assert swing.d2.owner != swing.d1
      }
    }

    void testWindows() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.window()
        swing.frame{ window() }
        swing.dialog{ window() }
      }
    }

    void testNodeCreation() {
      testInEDT {

        def swing = new SwingBuilder()
        def frame = swing.frame(){
            // 4 valid parameter combinations
            button()
            button('Text')
            button(label:'Label')
            button(label:'Label', 'Text')
        }
        shouldFail(){
            frame = swing.frame(){
                // invalid parameter
                button(new Date())
            }
        }
      }
    }

    void testSetMnemonic() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.panel(layout:new BorderLayout()) {
            label(id:'label0', text:'Name0', mnemonic:48)
            label(id:'label1', text:'Name1', mnemonic:'N')
        }
        int expected0 = '0'
        int expected1 = 'N'
        assert swing.label0.displayedMnemonic == expected0
        assert swing.label1.displayedMnemonic == expected1
        swing.menuBar{
            menu{
                menuItem {
                    action(id:'actionId', name:'About', mnemonic:'A')
                }
            }
        }
        int expected2 = 'A'
        int actual = swing.actionId.getValue(Action.MNEMONIC_KEY)
        assert  actual == expected2
      }
    }

    void testBuilderProperties() {
      testInEDT {

        def swing = new SwingBuilder()
        assert swing.class.name == SwingBuilder.class.name
      }
    }

    void testFormattedTextField() {
      testInEDT {

        def swing = new SwingBuilder()
        def dummy = new Date()
        def field = swing.formattedTextField(value:dummy)
        assert field.value == dummy
        assert field.formatter.class == DateFormatter.class
        def dummyFormatter = new SimpleDateFormat()
        field = swing.formattedTextField(format:dummyFormatter)
        assert field.formatter.class == DateFormatter.class
        field = swing.formattedTextField()
        field.value = 3
        assert field.formatter.class == NumberFormatter.class
      }
    }

    void testTabbedPane() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.tabbedPane(id:'tp') {
            panel(id:'p1', name:'Title 1')
            panel(id:'p2')
            panel(id:'p3', title:'Title 3')
            panel(id:'p4', title:'Title 4', name:'Name 4')
            panel(id:'p5', title:'Title 5', tabIcon: imageIcon(Console.ICON_PATH, id:'i5'))
            panel(id:'p6', title:'Title 6', tabDisabledIcon: imageIcon(Console.ICON_PATH, id:'i6'))
            panel(id:'p7', title:'Title 7', tabToolTip:'tip 7')
            panel(id:'p8', title:'Title 8', tabBackground:Color.GREEN)
            panel(id:'p9', title:'Title 9', tabForeground:Color.GREEN)
            panel(id:'pA', title:'Title A', tabEnabled:false)
            panel(id:'pB', title:'Title B', tabMnemonic: 'T')
            panel(id:'pC', title:'Title C', tabDisplayedMnemonicIndex: 2)
            panel(id:'pD', title:'Title D', tabMnemonic: "${'T'}")
        }

        assert swing.tp.tabCount == 13
        assert swing.tp.indexOfComponent(swing.p1) == 0
        assert swing.tp.indexOfComponent(swing.p2) == 1
        assert swing.tp.indexOfComponent(swing.p3) == 2
        assert swing.tp.indexOfComponent(swing.p4) == 3
        assert swing.tp.indexOfTab('Title 1') == 0
        assert swing.tp.indexOfTab('Title 3') == 2
        assert swing.tp.indexOfTab('Title 4') == 3
        assert swing.tp.getIconAt(4) == swing.i5
        assert swing.tp.getDisabledIconAt(5) == swing.i6
        assert swing.tp.getToolTipTextAt(6) == 'tip 7'
        assert swing.tp.getBackgroundAt(7) == Color.GREEN
        assert swing.tp.getForegroundAt(8) == Color.GREEN
        assert swing.tp.isEnabledAt(9) == false
        assert swing.tp.getMnemonicAt(10) == 0x54
        assert swing.tp.getDisplayedMnemonicIndexAt(11) == 2
        assert swing.tp.getMnemonicAt(12) == 0x54

        swing.tabbedPane(id:'tp', selectedComponent:swing.p2) {
            panel(p1, name:'Title 1')
            panel(p2)
            panel(p3)
        }
        assert swing.tp.selectedIndex == 1
        assert swing.tp.selectedComponent == swing.p2

        swing.tabbedPane(id:'tp', selectedIndex:1) {
            panel(p1, name:'Title 1')
            panel(p2)
            panel(p3)
        }
        assert swing.tp.selectedIndex == 1
        assert swing.tp.selectedComponent == swing.p2

        swing.tabbedPane(id:'r') {
            label(id:'a', text:'a', title:'ta')
            tabbedPane(id:'st', title:'st') {
                label(id:'sa', text:'sa', title:'sta')
                label(id:'sb', text:'sb', title:'stb')
            }
        }
        assert swing.a.parent == swing.r
        assert swing.st.parent == swing.r
        assert swing.r.indexOfTab('ta') == swing.r.indexOfComponent(swing.a)
        assert swing.r.indexOfTab('st') == swing.r.indexOfComponent(swing.st)
        assert swing.sa.parent == swing.st
        assert swing.sb.parent == swing.st
        assert swing.st.indexOfTab('sta') == swing.st.indexOfComponent(swing.sa)
        assert swing.st.indexOfTab('stb') == swing.st.indexOfComponent(swing.sb)

        // insure we don't collide with bind node work        
        // GROOVY-3288
        def model=[wordValue:'word']
        swing.tabbedPane {
          panel( title: "a") {
              textField( id: 'wordValue', columns: 20)
          }
          bean( model, word: bind{ wordValue.text } )
        }
        // no asserts, the above is pass/fai;  
      }
    }

    void testTabbedPaneRenamedProperties() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.tabbedPane(id:'tp',
            titleProperty :'xTitle',
            tabIconProperty:'xTabIcon',
            tabDisabledIconProperty:'xTabDisabledIcon',
            tabToolTipProperty:'xTabToolTip',
            tabBackgroundProperty:'xTabBackground',
            tabForegroundProperty:'xTabForeground',
            tabEnabledProperty:'xTabEnabled',
            tabMnemonicProperty:'xTabMnemonic',
            tabDisplayedMnemonicIndexProperty:'xTabDisplayedMnemonicIndex'
        ) {
            panel(id:'p1', name:'Title 1')
            panel(id:'p2')
            panel(id:'p3', xTitle:'Title 3')
            panel(id:'p4', xTitle:'Title 4', name:'Name 4')
            panel(id:'p5', xTitle:'Title 5', xTabIcon: imageIcon(Console.ICON_PATH, id:'i5'))
            panel(id:'p6', xTitle:'Title 6', xTabDisabledIcon: imageIcon(Console.ICON_PATH, id:'i6'))
            panel(id:'p7', xTitle:'Title 7', xTabToolTip:'tip 7')
            panel(id:'p8', xTitle:'Title 8', xTabBackground:Color.GREEN)
            panel(id:'p9', xTitle:'Title 9', xTabForeground:Color.GREEN)
            panel(id:'pA', xTitle:'Title A', xTabEnabled:false)
            panel(id:'pB', xTitle:'Title B', xTabMnemonic: 'T')
            panel(id:'pC', xTitle:'Title C', xTabDisplayedMnemonicIndex: 2)
            panel(id:'pD', xTitle:'Title D', xTabMnemonic: "${'T'}")
        }

        assert swing.tp.tabCount == 13
        assert swing.tp.indexOfComponent(swing.p1) == 0
        assert swing.tp.indexOfComponent(swing.p2) == 1
        assert swing.tp.indexOfComponent(swing.p3) == 2
        assert swing.tp.indexOfComponent(swing.p4) == 3
        assert swing.tp.indexOfTab('Title 1') == 0
        assert swing.tp.indexOfTab('Title 3') == 2
        assert swing.tp.indexOfTab('Title 4') == 3
        assert swing.tp.getIconAt(4) == swing.i5
        assert swing.tp.getDisabledIconAt(5) == swing.i6
        assert swing.tp.getToolTipTextAt(6) == 'tip 7'
        assert swing.tp.getBackgroundAt(7) == Color.GREEN
        assert swing.tp.getForegroundAt(8) == Color.GREEN
        assert swing.tp.isEnabledAt(9) == false
        assert swing.tp.getMnemonicAt(10) == 0x54
        assert swing.tp.getDisplayedMnemonicIndexAt(11) == 2
        assert swing.tp.getMnemonicAt(12) == 0x54
      }
    }

    void testScrollPane() {
      testInEDT {

        def swing = new SwingBuilder()
        shouldFail {
            swing.scrollPane {
                button("OK")
                button("Cancel")
            }
        }
      }
    }

    void testComboBox() {
      testInEDT {

        def swing = new SwingBuilder()
        Object[] objects = ['a','b']
        def list = ['c', 'd', 'e']
        def vector = new Vector(['f', 'g', 'h', 'i'])
        assert swing.comboBox(items:objects).itemCount == 2
        assert swing.comboBox(items:list).itemCount == 3
        assert swing.comboBox(items:vector).itemCount == 4
        assert swing.comboBox().itemCount == 0
      }
    }

    void testList() {
      testInEDT {

        def swing = new SwingBuilder()
        Object[] objects = ['a','b']
        def list = ['c', 'd', 'e']
        def vector = new Vector(['f', 'g', 'h', 'i'])
        assert swing.list(items:objects).model.size == 2
        assert swing.list(items:list   ).model.size == 3
        assert swing.list(items:vector ).model.size == 4
        assert swing.list(             ).model.size == 0
        assert swing.list(listData:objects).model.size == 2
        assert swing.list(listData:list   ).model.size == 3
        assert swing.list(listData:vector ).model.size == 4
        assert swing.list(listData:"list" ).model.size == 4
        assert swing.list(listData:[a:1,b:2].collect{ k, v -> v}).model.size == 2
      }
    }

    void testMisplacedActionsAreIgnored() {
      testInEDT {

        def swing = new SwingBuilder()
        // labels don't support actions; should be ignored
        swing.label{
            action(id:'actionId', Name:'about', mnemonic:'A', closure:{x->x})
            map()
        }
        swing.panel{
            borderLayout{
                // layouts don't support actions, will be ignored
                action(id:'actionId')
            }
        }
      }
    }

    void testBoxLayout() {
      testInEDT {

        def swing = new SwingBuilder()
        def message = shouldFail{
            swing.boxLayout()
        }
        assert message.contains('Must be nested inside a Container')
        // default is X_AXIS
        swing.panel(id:'panel'){
            boxLayout(id:'layout1')
        }
        // can also set explicit axis
        swing.frame(id:'frame'){
            boxLayout(id:'layout2', axis:BoxLayout.Y_AXIS)
        }
      }
    }

    void testKeystrokesWithinActions() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.panel{
            button(id:'buttonId'){
                action(id:'action1', keyStroke:'ctrl W')
                action(id:'action2',
                    keyStroke:KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, InputEvent.ALT_MASK))
                action(id:'action3', keyStroke:"${'ctrl Z'}")
            }
        }
        def component = swing.buttonId
        def expected1 = swing.action1.toString()
        def expected2 = swing.action2.toString()
        def expected3 = swing.action3.toString()
        def keys = component.actionMap.allKeys().toList()
        assert keys.contains(expected1)
        assert keys.contains(expected2)
        assert keys.contains(expected3)
        def inputMap = component.inputMap
        def values = inputMap.allKeys().toList().collect{ inputMap.get(it) }
        assert values.contains(expected1)
        assert values.contains(expected2)
        assert values.contains(expected3)
      }
    }

    void testActionClosures() {
      testInEDT {

        def swing = new SwingBuilder()
        def testTarget = 'blank'
        swing.actions {
            action(id:'a', closure: {testTarget = 'A'})
            action(id:'b') {testTarget = 'B' }
            action(id:'c', closure: {evt -> testTarget = 'C'})
            action(id:'d') {evt -> testTarget = 'D' }
        }

        ActionEvent evt = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, "")
        assert testTarget == 'blank'
        swing.a.actionPerformed(evt)
        assert testTarget == 'A'
        swing.b.actionPerformed(evt)
        assert testTarget == 'B'
        swing.c.actionPerformed(evt)
        assert testTarget == 'C'
        swing.d.actionPerformed(evt)
        assert testTarget == 'D'

        // negative tests
        swing.actions {
            action(id:'z')
            shouldFail(RuntimeException) {
                action(id:'y', closure:{testTarget = 'Y'}) {testTarget = 'YY'}
            }
            shouldFail(RuntimeException) {
                action([actionPerformed: {testTarget = 'X'} ] as AbstractAction, id:'x') { testTarget = 'XX'}
            }
        }
        shouldFail(NullPointerException) {
            swing.z.actionPerformed(evt)
        }

      }
    }

    void testSetAccelerator() {
      testInEDT {

        def swing = new SwingBuilder()
        def help = swing.action(accelerator:'F1')
        def about = swing.action(accelerator:KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, InputEvent.CTRL_MASK))
        assert help.getValue(Action.ACCELERATOR_KEY).toString()
                             .indexOf(KeyEvent.getKeyText(KeyEvent.VK_F1)) > -1
        def aboutKeyStroke = about.getValue(Action.ACCELERATOR_KEY)
        assert aboutKeyStroke.keyCode == KeyEvent.VK_SPACE
        assert(aboutKeyStroke.modifiers & InputEvent.CTRL_MASK) != 0
      }
    }

    private verifyAccel(action, int mustHave = 0) {
        int mods = action.getValue(Action.ACCELERATOR_KEY).modifiers
        assert mods != 0
        assert (mods & mustHave) == mustHave
        // don't assert (modd % musthave) != 0 because mustHave may be the platform shortcut modifer
        return action
    }

    void testSetAcceleratorShortcuts() {
      testInEDT {

        def swing = new SwingBuilder()
        char q = 'Q'
        swing.actions {
            verifyAccel(action(accelerator: shortcut(q)))
            verifyAccel(action(accelerator: shortcut(q, InputEvent.SHIFT_DOWN_MASK)), InputEvent.SHIFT_DOWN_MASK)
            verifyAccel(action(accelerator: shortcut(KeyEvent.VK_NUMPAD5)))
            verifyAccel(action(accelerator: shortcut(KeyEvent.VK_NUMPAD5, InputEvent.SHIFT_DOWN_MASK)), InputEvent.SHIFT_DOWN_MASK)
            verifyAccel(action(accelerator: shortcut('DELETE')))
            verifyAccel(action(accelerator: shortcut('DELETE', InputEvent.SHIFT_DOWN_MASK)), InputEvent.SHIFT_DOWN_MASK)
        }
      }
    }

    void testBorderLayoutConstraints() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.internalFrame(id:'frameId',
                border:BorderFactory.createTitledBorder(BorderFactory.createLoweredBevelBorder())) {
            swing.frameId.contentPane.layout = new BorderLayout()
            vbox(id:'vboxId', constraints:BorderLayout.NORTH)
            hbox(id:'hboxId', constraints:BorderLayout.WEST)
            rigidArea(id:'area1', constraints:BorderLayout.EAST, size:[3,4] as Dimension)
            rigidArea(id:'area2', constraints:BorderLayout.SOUTH, width:30, height:40)
            scrollPane(id:'scrollId', constraints:BorderLayout.CENTER,
                border:BorderFactory.createRaisedBevelBorder()) {
                panel() {
                    glue()
                    vglue()
                    hglue()
                    vstrut()
                    vstrut(height:8)
                    hstrut()
                    hstrut(width:8)
                    rigidArea(id:'area3')
                }
            }
        }
        assert swing.vboxId.parent == swing.frameId.contentPane
        assert swing.hboxId.parent == swing.frameId.contentPane
        assert swing.scrollId.parent == swing.frameId.contentPane
      }
    }

    void testSetConstraints() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.panel(layout:new BorderLayout()) {
            label(text:'Name', constraints:BorderLayout.CENTER)
        }
      }
    }

    void testSetToolTipText() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.panel(layout:new BorderLayout()) {
            label(id:'labelId', text:'Name', toolTipText:'This is the name field')
        }

      }
    }

    void testTableLayout() {
      testInEDT {

        def swing = new SwingBuilder()
        def msg = shouldFailWithCause(RuntimeException){
            def frame = swing.frame(){
                tr()
            }
        }
        assert msg =~ /'tr' must be within a 'tableLayout'/
        msg = shouldFailWithCause(RuntimeException){
            def frame = swing.frame(){
                tableLayout(){
                    td()
                }
            }
        }
        assert msg =~ /'td' must be within a 'tr'/
        swing.frame(id:'frame'){
            tableLayout(){
                tr {
                    td {
                        label(id:'label')
                    }
                }
            }
        }

        assert swing.label.parent
        assert swing.label.parent.parent
        assert swing.label.parent.parent.parent
        assert swing.label.parent.parent.parent.parent
        assert swing.frame == swing.label.parent.parent.parent.parent.parent
      }
    }

    void testAttributeOrdering() {
      testInEDT {

        def swing = new SwingBuilder()

        def frame = swing.frame(
            size:[500,500],
            locationRelativeTo:null
        )
        def locationFirst = frame.location

        frame = swing.frame(
            locationRelativeTo:null,
            size:[500,500]
        )
        def locationLast = frame.location

        // setLocationReativeTo(null) places the component in the center of
        // the screen, relative to it's size, so centering it after sizing it
        // should result in a 250,250 offset from centering it before sizing it
        assert locationFirst != locationLast
      }
    }

    void testWidgetPassthroughConstraints() {
      testInEDT {

        def swing = new SwingBuilder()
        def foo = swing.button('North')
        def frame = swing.frame {
            borderLayout()
            widget(foo, constraints: BorderLayout.NORTH)
            // a failed test throws MissingPropertyException by now
        }
      }
    }

    void testGROOVY1837ReuseAction() {
      testInEDT {

        def swing = new SwingBuilder()

        def testAction = swing.action(name:'test', mnemonic:'A', accelerator:'ctrl R')
        assert testAction.getValue(Action.MNEMONIC_KEY) != null
        assert testAction.getValue(Action.ACCELERATOR_KEY) != null

        swing.action(testAction)
        assert testAction.getValue(Action.MNEMONIC_KEY) != null
        assert testAction.getValue(Action.ACCELERATOR_KEY) != null
      }
    }

    void testSeparators() {
      testInEDT {

        def swing = new SwingBuilder()
        swing.frame {
            menu("test") {
                separator(id:"menuSep")
            }
            toolBar {
                separator(id:"tbSep")
            }
            separator(id:"sep")
        }
        assert swing.menuSep instanceof JPopupMenu_Separator
        assert swing.tbSep instanceof JToolBar_Separator
        assert swing.sep instanceof JSeparator
      }
    }

    void testCollectionNodes() {
      testInEDT {

        def swing = new SwingBuilder()
        def collection = swing.actions {
            action(id:'test')
        }
        assert collection.contains(swing.test)
      }
    }

    void testFactoryCornerCases() {
      testInEDT {

        def swing = new SwingBuilder()

        // change in 1.6, bad node names throw exceptions instead of being ignored
        shouldFail(MissingMethodException) {
            swing.bogusWidget() == null
        }

        swing.registerFactory("nullWidget",
            [newInstance:{builder, name, value, props -> null}] as AbstractFactory)
        assert swing.nullWidget() == null
      }
    }

    void testFactoryLogging() {
      testInEDT {

        def logger = java.util.logging.Logger.getLogger(SwingBuilder.class.name)
        def oldLevel = logger.getLevel()
        logger.setLevel(java.util.logging.Level.FINE)
        def swing = new SwingBuilder()
        swing.label()
        logger.setLevel(oldLevel)
      }
    }

    void testEnhancedValueArguments() {
      testInEDT {

        def swing = new SwingBuilder()

        // elements that take an action, icon, string, GString,
        // or their own type as a value arg
        def anAction = swing.action(name:"test action")
        def icon = new javax.swing.plaf.metal.MetalComboBoxIcon()
        def richActionItems = [
            'button',
            'checkBox',
            'radioButton',
            'toggleButton',
            'menuItem',
            'checkBoxMenuItem',
            'radioButtonMenuItem'
        ]

        richActionItems.each {name ->
            swing."$name"(anAction, id:"${name}Action".toString())
            swing."$name"(icon, id:"${name}Icon".toString())
            swing."$name"("string", id:"${name}String".toString())
            swing."$name"("${'g'}string", id:"${name}GString".toString())
            swing."$name"(swing."${name}Action", id:"${name}Self".toString())

            assert swing."${name}Action"
            assert swing."${name}Icon"
            assert swing."${name}String".text == 'string'
            assert swing."${name}GString".text == 'gstring'
            assert swing."${name}Self" == swing."${name}Action"
            shouldFail {
                swing."$name"(['bad'])
            }
        }

        // elements that take no value argument
        def noValueItems = [
            "actions",
            "boxLayout",
            "formattedTextField",
            "glue",
            "hbox",
            "hglue",
            "hstrut",
            "map",
            "rigidArea",
            "separator",
            "vbox",
            "vglue",
            "vstrut",
        ]

        noValueItems.each {name ->
            //println name
            shouldFail {
                swing.frame {
                    "$name"(swing."$name"(), id:"${name}Self".toString())
                }
            }
        }

         // elements that only take their own type as a value argument
        def selfItems = [
            "action",
            "borderLayout",
            "boundedRangeModel",
            "box",
            "buttonGroup",
            "cardLayout",
            //"closureColumn",
            "colorChooser",
            "comboBox",
            //"container",
            "desktopPane",
            "dialog",
            "fileChooser",
            "flowLayout",
            "frame",
            "gbc",
            "gridBagConstraints",
            "gridBagLayout",
            "gridLayout",
            "internalFrame",
            "layeredPane",
            // "list", // list acceps JList, Vector, Object[], List
            "menuBar",
            "optionPane",
            //"overlayLayout",
            "panel",
            "popupMenu",
            "progressBar",
            //"propertyColumn",
            "scrollBar",
            "scrollPane",
            "slider",
            "spinner",
            "spinnerDateModel",
            "spinnerListModel",
            "spinnerNumberModel",
            "splitPane",
            "springLayout",
            "tabbedPane",
            "table",
            "tableColumn",
            "tableLayout",
            "tableModel",
            //"td",
            "toolBar",
            //"tr",
            "tree",
            "viewport",
            //"widget",
            "window",
        ]
        selfItems.each {name ->
            //println name
            swing.frame {
                "$name"(swing."$name"(), id:"${name}Self".toString())
            }

            shouldFail {
                swing.frame {
                    swing."$name"(icon)
                }
            }
        }

         // elements take their own type as a value argument or a [g]string as a text property
        def textItems = [
            "editorPane",
            "label",
            "menu",
            "passwordField",
            "textArea",
            "textField",
            "textPane",
        ]
        textItems.each {name ->
            swing.frame {
                "$name"(swing."$name"(), id:"${name}Self".toString())
                "$name"('text', id:"${name}Text".toString())
                "$name"("${'g'}string", id:"${name}GString".toString())
            }
            assert swing."${name}Text".text == 'text'
            assert swing."${name}GString".text == 'gstring'

            shouldFail {
                swing.frame {
                    swing."$name"(icon)
                }
            }
        }

        // leftovers...
        swing.frame {
            action(action:anAction)
            box(axis:BoxLayout.Y_AXIS)
            hstrut(5)
            vstrut(5)
            tableModel(tableModel:tableModel())
            container(id:'c', panel()) {
                widget(id:'w', label("label"))
                bean("anything")
            }
            container(container:panel()) {
                widget(widget:label("label"))
                bean(bean:"anything")
            }
        }
        assert swing.w.parent == swing.c
        shouldFail {
            swing.actions(property:'fails')
        }
        shouldFail {
            swing.widget()
        }
        shouldFail {
            swing.widget(label('label')) {
                label('No Content For You!')
            }
        }
        shouldFail {
            swing.container()
        }
        shouldFail {
            swing.bean()
        }
        shouldFail {
            swing.bean("anything") {
                label('Nothing')
            }
        }
      }
    }

    boolean instancePass

    void markPassed() {
        instancePass = true
    }

    void testEDT() {
        if (headless) return
        def swing = new SwingBuilder()

        boolean pass = false
        swing.edt { pass = SwingUtilities.isEventDispatchThread() }
        assert pass

        pass = false
        swing.edt { swing.edt { pass = SwingUtilities.isEventDispatchThread() } }
        assert pass

        instancePass = false
        swing.edt this.&markPassed
        assert instancePass
    }

    void testDoLater() {
        if (headless) return
        def swing = new SwingBuilder()

        boolean pass = false
        swing.doLater {sleep 100; pass = true }
        assert !pass
        // check for pass changing up to 3 times, then call it a failed test
        int maxFailures = 3
        while (maxFailures > 0) {
            sleep 200
            if (pass) break
            maxFailures--
        }
        assert pass

        // doLater in the EDT is still a do later
        pass = false
        swing.edt { swing.doLater {sleep 100; pass = true } }
        assert !pass
        // check for pass changing up to 3 times, then call it a failed test
        maxFailures = 3
        while (maxFailures > 0) {
            sleep 200
            if (pass) break
            maxFailures--
        }
        assert pass

        instancePass = false
        swing.doLater this.&markPassed
        // check for pass changing up to 3 times, then call it a failed test
        maxFailures = 3
        while (maxFailures > 0) {
            sleep 50
            if (instancePass) break
            maxFailures--
        }
        assert instancePass
    }

    void testDoOutside() {
      testInEDT {
        def swing = new SwingBuilder()

        boolean pass = false
        swing.doOutside {sleep 100; pass = true }
        assert !pass
        // check for pass changing up to 3 times, then call it a failed test
        int maxFailures = 3
        while (maxFailures > 0) {
            sleep 200
            if (pass) break
            maxFailures--
        }
        assert pass

        pass = false
        swing.edt {
            swing.doOutside {sleep 100; pass = true }
            assert !pass
            // check for pass changing up to 3 times, then call it a failed test
            int myMaxFailures = 3
            while (myMaxFailures > 0) {
                sleep 200
                if (pass) break
                myMaxFailures--
            }
            assert pass
        }

        instancePass = false
        swing.doOutside this.&markPassed
        // check for pass changing up to 3 times, then call it a failed test
        maxFailures = 3
        while (maxFailures > 0) {
            sleep 50
            if (instancePass) break
            maxFailures--
        }
        assert instancePass
      }
    }

    void testJumbledThreading() {
        if (headless) return;

        def swing = new SwingBuilder()
        Closure threadTest = {c ->
            boolean notifyReached = false;
            Throwable caughtThrowable = null
            Thread t = Thread.start {
                try {
                    c()
                } catch (Throwable throwable) {
                    caughtThrowable = throwable
                }
                notifyReached = true
                synchronized(swing) { swing.notifyAll() }
            }

            synchronized(swing) { swing.wait(2000); }
            if (!notifyReached && t.isAlive()) {
                Thread.start {
                    sleep(1000)
                    exit(0)
                }
                fail("EDT Deadlock")
            }
            if (caughtThrowable) {
                throw caughtThrowable
            }
            assert swing.l.parent != null
            notifyReached = false
        }

        threadTest {
            swing.frame {
                edt {
                    label('label', id:'l')
                }
            }
        }

        threadTest {
            swing.edt {
                swing.frame {
                    edt {
                        label('label', id:'l')
                    }
                }
            }
        }

        // full build in EDT shold be fine
        threadTest {
            swing.edt {
                swing.frame {
                    label('label', id:'l')
                }
            }
        }

        // nested build(Closure) call.
        // Bad form, but it shouldn't break stuff
        threadTest {
            swing.frame {
                build {
                    label('label', id:'l')
                }
            }
        }

        // insure the legacy static build(Closure) call still works.
        def oldSwing = swing
        threadTest {
            swing = SwingBuilder.build {
                frame {
                    label('label', id:'l')
                }
            }
        }
        assert swing != oldSwing
    }

    void testParallelBuild() {
        if (headless) return;

        def swing = new SwingBuilder()
        def p
        def l

        Thread t1 = Thread.start {
            p = swing.panel() {
                sleep(100)
                label('child')
            }
        }
        Thread t2 = Thread.start {
            sleep(50)
            l = swing.label('loner')
        }

        t1.join()
        t2.join()

        assert l.parent == null
    }

    void testDispose() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.frame(id:'frame').pack()
        swing.dialog(id:'dialog').pack()
        swing.window(id:'window').pack()

        //TODO check bind and model
        assert swing.frame.isDisplayable()
        assert swing.dialog.isDisplayable()
        assert swing.window.isDisplayable()
        swing.dispose()

        //TODO check bind and model
        assert !swing.frame.isDisplayable()
        assert !swing.dialog.isDisplayable()
        assert !swing.window.isDisplayable()

      }
    }

    void testPackAndShow() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.frame(id:'frame', pack:true)
        swing.dialog(id:'dialog', pack:true)
        swing.window(id:'window', pack:true)

        assert swing.frame.isDisplayable()
        assert swing.dialog.isDisplayable()
        assert swing.window.isDisplayable()
        swing.dispose()

        swing.frame(id:'frame', show:true)
        swing.dialog(id:'dialog', show:true)
        swing.window(id:'window', show:true)

        assert swing.frame.visible
        assert swing.dialog.visible
        assert swing.window.visible
        swing.dispose()

        swing.frame(id:'frame', pack:true, show:true)
        swing.dialog(id:'dialog', pack:true, show:true)
        swing.window(id:'window', pack:true, show:true)

        assert swing.frame.visible
        assert swing.dialog.visible
        assert swing.window.visible
        swing.dispose()
      }
    }

    void testContainment() {
      testInEDT {
        def swing = new SwingBuilder()

        def topLevel = [
            "window",
            "frame",
            "dialog",
            "internalFrame",
        ]

        def containers = [
            "hbox",
            "box",
            "desktopPane",
            "layeredPane",
            "panel",
            "popupMenu",
            //"scrollPane",
            "splitPane",
            "tabbedPane",
            "toolBar",
            "viewport",
        ]

        def components = [
            "comboBox",
            "formattedTextField",
            "glue",
            "hbox",
            "hglue",
            "hstrut",
            "rigidArea",
            "separator",
            "vbox",
            "vglue",
            "vstrut",
            "box",
            "colorChooser",
            "desktopPane",
            "fileChooser",
            "internalFrame",
            "layeredPane",
            "list",
            "menu",
            //"menuBar",
            "optionPane",
            "panel",
            //"popupMenu",
            "progressBar",
            "scrollBar",
            "scrollPane",
            "slider",
            "spinner",
            "splitPane",
            "tabbedPane",
            "table",
            "toolBar",
            "tree",
            "viewport",
            "editorPane",
            "label",
            "passwordField",
            "textArea",
            "textField",
            "textPane",
        ]


        topLevel.each {parentWidget ->
            components.each { childWidget ->
                //println "$parentWidget / $childWidget"
                def child
                def parent = swing."$parentWidget" { child = "$childWidget"() }
                assert parent.contentPane == child.parent
            }
        }

        containers.each {parentWidget ->
            components.each { childWidget ->
                //println "$parentWidget / $childWidget"
                def child
                def parent = swing."$parentWidget" { child = "$childWidget"() }
                assert parent == child.parent
            }
        }

        components.each { childWidget ->
            //println "scrollPane / $childWidget"

            def child
            def parent = swing.scrollPane { child = "$childWidget"() }
            if (childWidget == 'viewport') {
                assert parent.viewport == child
            } else {
                assert parent.viewport == child.parent
            }
        }
      }
    }

    void testMenus() {
      testInEDT {
        def swing = new SwingBuilder()

        def frame = swing.frame {
            menuBar(id:'bar') {
                menu('menu', id:'menu') {
                    menuItem('item', id:'item')
                    checkBoxMenuItem('check', id:'check')
                    radioButtonMenuItem('radio', id:'radio')
                    separator(id:'sep')
                    menu('subMenu', id:'subMenu') {
                        menuItem('item', id:'subitem')
                        checkBoxMenuItem('check', id:'subcheck')
                        radioButtonMenuItem('radio', id:'subradio')
                        separator(id:'subsep')
                        menu('subSubMenu', id:'subSubMenu')
                    }
                }
            }
        }

        assert frame.JMenuBar == swing.bar
        assert swing.bar.menuCount == 1
        assert swing.bar.getMenu(0) == swing.menu

        assert swing.menu.itemCount == 5
        assert swing.menu.getItem(0) == swing.item
        assert swing.menu.getItem(1) == swing.check
        assert swing.menu.getItem(2) == swing.radio
        assert swing.menu.getItem(3) == null // not a menu item
        assert swing.menu.getMenuComponent(3) == swing.sep
        assert swing.menu.getItem(4) == swing.subMenu
        shouldFail { swing.menu.getItem(5) }

        assert swing.subMenu.itemCount == 5
        assert swing.subMenu.getItem(0) == swing.subitem
        assert swing.subMenu.getItem(1) == swing.subcheck
        assert swing.subMenu.getItem(2) == swing.subradio
        assert swing.subMenu.getItem(3) == null // not a menu item
        assert swing.subMenu.getMenuComponent(3) == swing.subsep
        assert swing.subMenu.getItem(4) == swing.subSubMenu
      }
    }

    void testLookAndFeel() {
      testInEDT {
        def swing = new SwingBuilder()

        def oldLAF = UIManager.getLookAndFeel()
        try {
            // test LAFs guaranteed to be everywhere
            swing.lookAndFeel('metal')
            swing.lookAndFeel('system')
            swing.lookAndFeel('crossPlatform')

            // test alternate invocations...
            swing.lookAndFeel(new javax.swing.plaf.metal.MetalLookAndFeel())
            shouldFail() {
                swing.lookAndFeel(this)
            }
            swing.lookAndFeel('javax.swing.plaf.metal.MetalLookAndFeel')
            swing.lookAndFeel("${'j'}avax.swing.plaf.metal.MetalLookAndFeel")
            shouldFail() {
                swing.lookAndFeel('BogusLookAndFeel')
            }

            // test Metal Themeing and aux attributes
            swing.lookAndFeel('metal', theme: 'steel', boldFonts: false)
            shouldFail {
                swing.lookAndFeel('metal', theme: 'steel', boldFonts: false, bogusAttribute: 'bad bad bad')
            }

            // test setup via attribute alone
            swing.lookAndFeel(lookAndFeel:'metal', theme: 'steel', boldFonts: false)

            // test Look and Feel Closure
            swing.lookAndFeel('metal') { laf ->
                assert laf instanceof MetalLookAndFeel
            }
            swing.lookAndFeel('metal', boldFonts: true) { laf ->
                assert laf instanceof MetalLookAndFeel
            }
            swing.lookAndFeel(lookAndFeel:'metal', boldFonts: true) { laf ->
                assert laf instanceof MetalLookAndFeel
            }
            shouldFail {
                swing.lookAndFeel() {laf ->
                    "do" + "Nothing"
                }
            }
        } finally {
            UIManager.setLookAndFeel(oldLAF)
        }
      }
   }

    void testMultiLookAndFeel() {
      testInEDT {
        def swing = new SwingBuilder()

        def oldLAF = UIManager.getLookAndFeel()
        try {
            def mlaf = new MetalLookAndFeel()
            assert swing.lookAndFeel('metal', 'bogus') instanceof MetalLookAndFeel
            assert swing.lookAndFeel('bogus', 'metal') instanceof MetalLookAndFeel
            assert swing.lookAndFeel(['metal'], 'bogus') instanceof MetalLookAndFeel
            assert swing.lookAndFeel('bogus', ['metal']) instanceof MetalLookAndFeel
            assert swing.lookAndFeel(['metal', [boldFonts:false]], 'bogus') instanceof MetalLookAndFeel
            assert swing.lookAndFeel('bogus', ['metal', [boldFonts:false]]) instanceof MetalLookAndFeel
            assert swing.lookAndFeel(mlaf , 'bogus') instanceof MetalLookAndFeel
            assert swing.lookAndFeel('bogus', mlaf ) instanceof MetalLookAndFeel
            assert swing.lookAndFeel([mlaf ], 'bogus') instanceof MetalLookAndFeel
            assert swing.lookAndFeel('bogus', [mlaf ]) instanceof MetalLookAndFeel
            assert swing.lookAndFeel([mlaf , [boldFonts:false]], 'bogus') instanceof MetalLookAndFeel
            assert swing.lookAndFeel('bogus', [mlaf , [boldFonts:false]]) instanceof MetalLookAndFeel
            assert swing.lookAndFeel('bogus', 'fake', 'impossible') == null
        } finally {
            UIManager.setLookAndFeel(oldLAF)
        }
      }
    }

    void testBorders() {
      testInEDT {
        def swing = new SwingBuilder()

        // classic smoke test, try every valid combination and look for smoke...
        swing.frame {
            lineBorder(color:Color.BLACK, parent:true)
            lineBorder(color:Color.BLACK, thickness:4, parent:true)
            lineBorder(color:Color.BLACK, roundedCorners:true, parent:true)
            lineBorder(color:Color.BLACK, thickness:4, roundedCorners:true, parent:true)
            raisedBevelBorder(parent:true)
            raisedBevelBorder(highlight:Color.GREEN, shadow:Color.PINK, parent:true)
            raisedBevelBorder(highlightOuter:Color.GREEN, highlightInner:Color.RED, shadowOuter:Color.PINK, shadowInner:Color.BLUE, parent:true)
            loweredBevelBorder(parent:true)
            loweredBevelBorder(highlight:Color.GREEN, shadow:Color.PINK, parent:true)
            loweredBevelBorder(highlightOuter:Color.GREEN, highlightInner:Color.RED, shadowOuter:Color.PINK, shadowInner:Color.BLUE, parent:true)
            etchedBorder(parent:true)
            etchedBorder(highlight:Color.GREEN, shadow:Color.PINK, parent:true)
            loweredEtchedBorder(parent:true)
            loweredEtchedBorder(highlight:Color.GREEN, shadow:Color.PINK, parent:true)
            raisedEtchedBorder(parent:true)
            raisedEtchedBorder(highlight:Color.GREEN, shadow:Color.PINK, parent:true)
            titledBorder("Title 1", parent:true)
            titledBorder(title:"Title 2", parent:true)
            titledBorder("Title 3", position:'bottom', parent:true)
            titledBorder(title:"Title 4", position:'aboveBottom', parent:true)
            titledBorder("Title 5", position:TitledBorder.ABOVE_TOP, parent:true)
            titledBorder(title:"Title 6", position:TitledBorder.BOTTOM, parent:true)
            titledBorder("Title 7", justification:'right', parent:true)
            titledBorder(title:"Title 8", justification:'acenter', parent:true)
            titledBorder("Title 9", justification:TitledBorder.TRAILING, parent:true)
            titledBorder(title:"Title A", justification:TitledBorder.LEADING, parent:true)
            titledBorder("Title B", border:lineBorder(color:Color.RED, thickness:6), parent:true)
            titledBorder(title:"Title C", border:lineBorder(color:Color.BLUE, thickness:6), parent:true)
            titledBorder("Title D", color:Color.CYAN, parent:true)
            titledBorder(title:"Title E", border:lineBorder(color:Color.BLUE, thickness:6), parent:true)
            emptyBorder(6, parent:true)
            emptyBorder([3,5,6,9], parent:true)
            emptyBorder(top:6, left:5, bottom:6, right:9, parent:true)
            compoundBorder([titledBorder("single")], parent:true)
            compoundBorder([titledBorder("outer"), titledBorder("inner")], parent:true)
            compoundBorder(outer:titledBorder("outer"), inner:titledBorder("inner"), parent:true)
            compoundBorder([titledBorder("outer"), titledBorder("middle"), titledBorder("inner")], parent:true)
            matteBorder(Color.MAGENTA, size:7, parent:true)
            matteBorder(7, color:Color.MAGENTA, parent:true)
            matteBorder(javax.swing.plaf.metal.MetalIconFactory.getCheckBoxIcon(), size:9, parent:true)
            matteBorder(9, icon:javax.swing.plaf.metal.MetalIconFactory.getCheckBoxIcon(), parent:true)

            lineBorder(color:Color.BLACK)
            lineBorder(color:Color.BLACK, thickness:4)
            lineBorder(color:Color.BLACK, roundedCorners:true)
            lineBorder(color:Color.BLACK, thickness:4, roundedCorners:true)
            raisedBevelBorder()
            raisedBevelBorder(highlight:Color.GREEN, shadow:Color.PINK)
            raisedBevelBorder(highlightOuter:Color.GREEN, highlightInner:Color.RED, shadowOuter:Color.PINK, shadowInner:Color.BLUE)
            loweredBevelBorder()
            loweredBevelBorder(highlight:Color.GREEN, shadow:Color.PINK)
            loweredBevelBorder(highlightOuter:Color.GREEN, highlightInner:Color.RED, shadowOuter:Color.PINK, shadowInner:Color.BLUE)
            etchedBorder()
            etchedBorder(highlight:Color.GREEN, shadow:Color.PINK)
            loweredEtchedBorder()
            loweredEtchedBorder(highlight:Color.GREEN, shadow:Color.PINK)
            raisedEtchedBorder()
            raisedEtchedBorder(highlight:Color.GREEN, shadow:Color.PINK)
            titledBorder("Title 1")
            titledBorder(title:"Title 2")
            titledBorder("Title 3", position:'bottom')
            titledBorder(title:"Title 4", position:'aboveBottom')
            titledBorder("Title 5", position:TitledBorder.ABOVE_TOP)
            titledBorder(title:"Title 6", position:TitledBorder.BOTTOM)
            titledBorder("Title 7", justification:'right')
            titledBorder(title:"Title 8", justification:'acenter')
            titledBorder("Title 9", justification:TitledBorder.TRAILING)
            titledBorder(title:"Title A", justification:TitledBorder.LEADING)
            titledBorder("Title B", border:lineBorder(color:Color.RED, thickness:6))
            titledBorder(title:"Title C", border:lineBorder(color:Color.BLUE, thickness:6))
            titledBorder("Title D", color:Color.CYAN)
            titledBorder(title:"Title E", border:lineBorder(color:Color.BLUE, thickness:6))
            emptyBorder(6)
            emptyBorder([3,5,6,9])
            emptyBorder(top:6, left:5, bottom:6, right:9)
            compoundBorder([titledBorder("single")])
            compoundBorder([titledBorder("outer"), titledBorder("inner")])
            compoundBorder(outer:titledBorder("outer"), inner:titledBorder("inner"))
            compoundBorder([titledBorder("outer"), titledBorder("middle"), titledBorder("inner")])
            matteBorder(Color.MAGENTA, size:7)
            matteBorder(7, color:Color.MAGENTA)
            matteBorder(javax.swing.plaf.metal.MetalIconFactory.getCheckBoxIcon(), size:9)
            matteBorder(9, icon:javax.swing.plaf.metal.MetalIconFactory.getCheckBoxIcon())
        }
      }
    }

    void testBorderAttachment() {
      testInEDT {
        def swing = new SwingBuilder()

        swing.frame(id:'frame') {
           raisedBevelBorder()
        }
        assert swing.frame.contentPane.border == null

        swing.frame(id:'frame') {
           raisedBevelBorder(parent:true)
        }
        assert swing.frame.contentPane.border != null

        swing.panel(id:'panel') {
           raisedBevelBorder()
        }
        assert swing.panel.border == null

        swing.panel(id:'panel') {
           raisedBevelBorder(parent:true)
        }
        assert swing.panel.border != null
      }
    }

    void testImageIcon() {
      testInEDT {
        def swing = new SwingBuilder()

        String baseDir = new File("src/main").absolutePath

        String resource = Console.ICON_PATH
        GString gresource = "${Console.ICON_PATH}"
        String path = baseDir + resource
        String gpath = "$baseDir$resource"
        File file = new File(path)
        String relativeResource = file.name
        String grelativeResource = "$file.name"
        URL url = file.toURL()

        swing.imageIcon(path, id:'ii')
        assert swing.ii != null

        swing.imageIcon(file:path, id:'ii')
        assert swing.ii != null

        swing.imageIcon(path, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:path, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'


        swing.imageIcon(gpath, id:'ii')
        assert swing.ii != null

        swing.imageIcon(file:gpath, id:'ii')
        assert swing.ii != null

        swing.imageIcon(gpath, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:gpath, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'


        swing.imageIcon(url, id:'ii')
        assert swing.ii != null

        swing.imageIcon(url:url, id:'ii')
        assert swing.ii != null

        swing.imageIcon(url, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(url:url, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'


        swing.imageIcon(resource, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource:resource, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:resource, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'


        swing.imageIcon(resource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource:resource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:resource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(gresource, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource:gresource, id:'ii')
        assert swing.ii != null

        swing.imageIcon(gresource, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:gresource, description:'<none>', id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'



        swing.imageIcon(gresource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource:gresource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(gresource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:gresource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'


        swing.imageIcon(relativeResource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource:relativeResource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(relativeResource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:relativeResource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'


        swing.imageIcon(grelativeResource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(resource:grelativeResource, class:Console, id:'ii')
        assert swing.ii != null

        swing.imageIcon(grelativeResource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

        swing.imageIcon(file:grelativeResource, description:'<none>', class:Console, id:'ii')
        assert swing.ii != null
        assert swing.ii.description == '<none>'

      }
    }

    void testRenderer() {
      testInEDT {
        def swing = new SwingBuilder()

        int count = 0
        def lcr = swing.listCellRenderer {
            label()
            onRender {
                count++
            }
        }

        def f = swing.frame(pack:true, show:true) {
            ls = list(items:["one", "two"], cellRenderer:lcr)
        }
        assert count==2
        f.dispose()

        count = 0
        def lcr2 = swing.listCellRenderer {
            label()
            button()
            onRender {
                count++
                return (children[row%2])
            }
        }

        assert lcr2.getListCellRendererComponent(swing.ls, "x", 0, false, false) instanceof javax.swing.JLabel
        assert lcr2.getListCellRendererComponent(swing.ls, "x", 1, false, false) instanceof javax.swing.JButton

      }
    }

    void testNoParent() {
      testInEDT {
        def swing = new SwingBuilder()
        def panel = swing.panel {
            button(id: "b1")
            noparent {
              button(id: "b2")
            }
        }
        assert panel.componentCount == 1
        assert swing.b1.parent == panel
        assert !swing.b2.parent
      }
    }

    void testClientProperties() {
      testInEDT {
        def swing = new SwingBuilder()
        def button = swing.button(clientPropertyPropA: "A")
        assert button.getClientProperty("PropA") == "A"

        button = swing.button("clientPropertyPropWith.dotAnd:colon": ".&:")
        assert button.getClientProperty("PropWith.dotAnd:colon") == ".&:"

        button = swing.button(clientProperties: [prop1: "1", prop2: "2"])
        assert button.getClientProperty("prop1") == "1"
        assert button.getClientProperty("prop2") == "2"
      }
    }

    void testKeyStrokeAction() {
      testInEDT {
        def swing = new SwingBuilder()

        def noop = swing.action(name: "KeyAction", closure: {})

        // component as value
        def button = swing.button()
        swing.keyStrokeAction(button,
            actionKey: "asValue",
            keyStroke: "V",
            action: noop)
        assert button.getInputMap(JComponent.WHEN_FOCUSED).get(KeyStroke.getKeyStroke("V")) == "asValue"
        assert button.actionMap.get("asValue") == noop

        // component as property
        swing.keyStrokeAction(component: button,
            actionKey: "asProperty",
            keyStroke: "P",
            action: noop)
        assert button.getInputMap(JComponent.WHEN_FOCUSED).get(KeyStroke.getKeyStroke("P")) == "asProperty"
        assert button.actionMap.get("asProperty") == noop

        // nested in component
        button = swing.button {
            keyStrokeAction(actionKey: "nested",
               keyStroke: "N",
               action: noop)
        }
        assert button.getInputMap(JComponent.WHEN_FOCUSED).get(KeyStroke.getKeyStroke("N")) == "nested"
        assert button.actionMap.get("nested") == noop

        // nested in component + shortcut
        button = swing.button {
            keyStrokeAction(actionKey: "nested_shortcut",
               keyStroke: shortcut("N"),
               action: noop)
        }
        assert button.getInputMap(JComponent.WHEN_FOCUSED).get(swing.shortcut("N")) == "nested_shortcut"
        assert button.actionMap.get("nested_shortcut") == noop

        // kstroke as GString
        swing.keyStrokeAction(component: button,
            actionKey: "GringKeyStroke",
            keyStroke: "G",
            action: noop)
        assert button.getInputMap(JComponent.WHEN_FOCUSED).get(KeyStroke.getKeyStroke("G")) == "GringKeyStroke"
        assert button.actionMap.get("GringKeyStroke") == noop

      }
    }
}

Other Groovy examples (source code examples)

Here is a short list of links related to this Groovy SwingBuilderTest.groovy source code file:

new blog posts

 

Copyright 1998-2013 Alvin Alexander, alvinalexander.com
All Rights Reserved.