如何测试 Qt 应用程序

    set cashRadioButton [waitForObject $names::Make_Payment_Cash_QRadioButton]
    if {![property get $cashRadioButton checked]} {
        invoke clickButton $cashRadioButton
    }
    test verify [property get $cashRadioButton checked]

set lineedit [waitForObject ":Forename:_LineEdit"]
property set $lineedit text "A new text"
set text [property get $lineedit.text]
test log [toString $text]

set button [waitForObject ":Address Book - Add.OK_QPushButton"]
invoke $button setText "Changed Button Text"

set widget [invoke QApplication activeModalWidget]
if {![isNull $widget]} {
    set name [property get $widget objectName]
    if {[invoke $name isEmpty]} {
    set name "unnamed"
    }
    test log stdout "$name\n"
}

set label [waitForObject ":Address Book - Add.Forename:_QLabel"]
invoke $label setAlignment [enum Qt AlignLeft]

invoke clickButton ":Address Book - Add.OK_QPushButton"
invoke doubleClickItem ":CSV Table - before.csv.File_QTableWidget" \
        "10/0" 22 20 0 [enum Qt LeftButton]
invoke activateItem [waitForObjectItem ":Address Book_QMenuBar" "File"]
invoke activateItem [waitForObjectItem ":Address Book.File_QMenu" "Open..."]

proc tableItemChangedHandler {obj item} {
    set name [objectMap symbolicName $obj]
    set text [toString [invoke $item text]]
    test log "itemChanged was emitted by object \"$name\" on item \"$text\""
}

proc main {} {
    startApplication "addressbook"
    # ... various actions ... now the table widget exists

    invoke installSignalHandler \
        ":Address Book - MyAddresses.adr.File_QTableWidget" \
        "itemChanged(QTableWidgetItem*)" "tableItemChangedHandler"
    # ... the rest of the test ...
}

proc fileMenuHandler {obj action} {
    set name [objectMap symbolicName $obj]
    set text [toString [property get $action text]]
    test log "triggered emitted by object \"$name\" for action \"$text\""
}

proc modelIndexClickedHandler {obj index} {
    set name [objectMap symbolicName $obj]
    set text [toString [property get $index text]]
    test log "triggered emitted by object \"$name\" on index \"$text\""
}

proc cellClickedHandler {obj row column} {
    set name [objectMap symbolicName $obj]
    set row [toString $row]
    set column [toString $column]
    test log "clicked emitted by object \"$name\" on cell ($row, $column)"
}

invoke installSignalHandler \
    ":Address Book.File_QMenu" "triggered(QAction*)" "fileMenuHandler"
set table [waitForObject ":Address Book - MyAddresses.adr.File_QTableWidget"]
invoke installSignalHandler $table "clicked(QModelIndex)" \
    "modelIndexClickedHandler"
invoke installSignalHandler $table "cellClicked(int, int)" \
    "cellClickedHandler"

proc main {} {
    startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/paymentform/paymentform\""
    # Make sure the Cash radio button is checked so we start in the mode
    # we want to test
    set cashRadioButton [waitForObject $names::Make_Payment_Cash_QRadioButton]
    if {![property get $cashRadioButton checked]} {
        invoke clickButton $cashRadioButton
    }
    test verify [property get $cashRadioButton checked]

    # Business rule #1: only the QStackedWidget's CashWidget must be
    # visible in cash mode
    # (The name "CashWidget" was set with QObject::setObjectName())
    set cashWidget [waitForObject [::Squish::ObjectName name CashWidget type QLabel ]]
    test compare [property get $cashWidget visible] true

    # Object is hidden, so we use waitForObjectExists()
    set checkWidget [waitForObjectExists $names::Make_Payment_CheckWidget_QWidget]
    test compare [property get $checkWidget visible] false

    # Object is hidden, so we use waitForObjectExists()
    set cardWidget [waitForObjectExists $names::Make_Payment_CardWidget_QWidget]
    test compare [property get $cardWidget visible] false

    # Business rule #2: the minimum payment is $1 and the maximum is
    # $2000 or the amount due whichever is smaller
    set amountDueLabel [waitForObject [::Squish::ObjectName name AmountDueLabel type QLabel]]
    set amountText [toString [property get $amountDueLabel text]]
    regsub -all {\D} $amountText "" amountText
    set amount_due [expr $amountText]
    set maximum [expr $amount_due < 2000 ? $amount_due : 2000]

    set paymentSpinBoxName [::Squish::ObjectName type QSpinBox unnamed 1 \
        buddy $names::Make_Payment_This_Payment_QLabel ]
    set paymentSpinBox [waitForObject $paymentSpinBoxName]
    test compare [property get $paymentSpinBox minimum] 1
    test compare [property get $paymentSpinBox maximum] $maximum

    # Business rule #3: the Pay button is enabled (since the above tests
    # ensure that the payment amount is in range)
    set payButtonName [::Squish::ObjectName text Pay type QPushButton visible 1]
    set payButton [waitForObject $payButtonName]
    test verify [property get $payButton enabled]

    sendEvent "QCloseEvent" [waitForObject $names::Make_Payment_MainWindow]
}

    source [findFile "scripts" "names.tcl"]

    proc clickRadioButton {text} {
        set radioButton [waitForObject [::Squish::ObjectName text $text type QRadioButton visible 1 window $names::Make_Payment_MainWindow]]
        if (![property get $radioButton checked]) {
            invoke clickButton $radioButton
        }
        test verify [property get $radioButton checked]
    }

proc getAmountDue {} {
        set amountDueLabel [waitForObject [::Squish::ObjectName name AmountDueLabel type QLabel]]
        set amountText [toString [property get $amountDueLabel text]]
        regsub -all {\D} $amountText "" amountText
        return [expr $amountText]
    }


    proc checkVisibleWidget {visible hidden} {
        set widget [waitForObject [::Squish::ObjectName name $visible type QWidget]]
        test compare [property get $widget visible] true
        foreach name $hidden {
            set widget [findObject [::Squish::ObjectName name $name type QWidget]]
            test compare [property get $widget visible] false
        }
    }


    proc checkPaymentRange {minimum maximum} {
        set paymentSpinBox [waitForObject $names::This_Payment_QSpinBox]
        test compare [property get $paymentSpinBox minimum] $minimum
        test compare [property get $paymentSpinBox maximum] $maximum
    }

proc main {} {
    startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/paymentform/paymentform\""
    # Import functionality needed by more than one test script
    source [findFile "scripts" "common.tcl"]

    # Make sure we start in the mode we want to test: check mode
    clickRadioButton "Check"

    # Business rule #1: only the CheckWidget must be visible in check mode
    checkVisibleWidget "CheckWidget" {"CashWidget" "CardWidget"}

    # Business rule #2: the minimum payment is $10 and the maximum is
    # $250 or the amount due whichever is smaller
    set amount_due [getAmountDue]
    set maximum [expr 250 > $amount_due ? $amount_due : 250]
    checkPaymentRange 10 $maximum

    # Business rule #3: the check date must be no earlier than 30 days
    # ago and no later than tomorrow
    set today [invoke QDate currentDate]
    set thirtyDaysAgo [toString [invoke $today addDays -30]]
    set tomorrow [toString [invoke $today addDays 1]]
    checkDateRange $thirtyDaysAgo $tomorrow

    # Business rule #4: the Pay button is disabled (since the form's data
    # isn't yet valid), so we use waitForObjectExists()
    set payButton [waitForObjectExists $names::Make_Payment_Pay_QPushButton]
    test verify [expr ![property get $payButton enabled]]

    # Business rule #5: the check must be signed (and if it isn't we
    # will check the check box ready to test the next rule)
    ensureSignedCheckBoxIsChecked

    # Business rule #6: the Pay button should be enabled since all the
    # previous tests pass, the check is signed and now we have filled in
    # the account details
    populateCheckFields
    set payButton [waitForObject $names::Make_Payment_Pay_QPushButton]
    test verify [property get $payButton enabled]

    sendEvent "QCloseEvent" [waitForObject $names::Make_Payment_MainWindow]
}

proc checkDateRange {minimum maximum} {
    set checkDateEdit [waitForObject [$names::Check_Date_QDateEdit]]
    set minimumDate [toString [property get $checkDateEdit minimumDate]]
    set maximumDate [toString [property get $checkDateEdit maximumDate]]
    test verify [string equal $minimum $minimumDate]
    test verify [string equal $maximum $maximumDate]
}

proc ensureSignedCheckBoxIsChecked {} {
    set checkSignedCheckBox [waitForObject $names::Make_Payment_Check_Signed_QCheckBox]
    if (![property get $checkSignedCheckBox checked]) {
        invoke clickButton $checkSignedCheckBox
    }
    test verify [property get $checkSignedCheckBox checked]
}

proc populateCheckFields {} {
    set bankNameLineEdit [waitForObject $names::Bank_Name_QLineEdit]
    invoke type $bankNameLineEdit "A Bank"
    set bankNumberLineEdit [waitForObject $names::Bank_Number_QLineEdit]
    invoke type $bankNumberLineEdit "88-91-33X"
    set accountNameLineEdit [waitForObject $names::Account_Name_QLineEdit]
    invoke type $accountNameLineEdit "An Account"
    set accountNumberLineEdit [waitForObject $names::Account_Number_QLineEdit]
    invoke type $accountNumberLineEdit "932745395"
}

proc checkDateRange {minimum maximum} {
    set checkDateEdit [waitForObject [$names::Check_Date_QDateEdit]]
    set minimumDate [toString [property get $checkDateEdit minimumDate]]
    set maximumDate [toString [property get $checkDateEdit maximumDate]]
    test verify [string equal $minimum $minimumDate]
    test verify [string equal $maximum $maximumDate]
}

proc ensureSignedCheckBoxIsChecked {} {
    set checkSignedCheckBox [waitForObject $names::Make_Payment_Check_Signed_QCheckBox]
    if (![property get $checkSignedCheckBox checked]) {
        invoke clickButton $checkSignedCheckBox
    }
    test verify [property get $checkSignedCheckBox checked]
}

proc populateCheckFields {} {
    set bankNameLineEdit [waitForObject $names::Bank_Name_QLineEdit]
    invoke type $bankNameLineEdit "A Bank"
    set bankNumberLineEdit [waitForObject $names::Bank_Number_QLineEdit]
    invoke type $bankNumberLineEdit "88-91-33X"
    set accountNameLineEdit [waitForObject $names::Account_Name_QLineEdit]
    invoke type $accountNameLineEdit "An Account"
    set accountNumberLineEdit [waitForObject $names::Account_Number_QLineEdit]
    invoke type $accountNumberLineEdit "932745395"
}

proc main {} {
    startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/paymentform/paymentform\""
    source [findFile "scripts" "common.tcl"]

    # Make sure we start in the mode we want to test: card mode
    clickRadioButton "Credit Card"

    # Business rule #1: only the CardWidget must be visible in check mode
    checkVisibleWidget "CardWidget" {"CashWidget" "CheckWidget"}

    # Business rule #2: the minimum payment is $10 or 5% of the amount due
    # whichever is larger and the maximum is $5000 or the amount due
    # whichever is smaller
    set amount_due [getAmountDue]
    set five_percent [expr $amount_due / 20.0]
    set minimum [expr 10 < $five_percent ? $five_percent : 10]
    set maximum [expr 5000 > $amount_due ? $amount_due : 5000]
    checkPaymentRange $minimum $maximum

    # Business rule #3: for non-Visa cards the issue date must be no
    # earlier than 3 years ago
    # Business rule #4: the expiry date must be at least a month later
    # than today---we will make sure this is the case for the later tests
    checkCardDateEdits

    # Business rule #5: the Pay button is disabled (since the form's data
    # isn't yet valid), so we use waitForObjectExists()
    set payButton [waitForObjectExists $names::Make_Payment_Pay_QPushButton]
    test compare [property get $payButton enabled] false

    # Business rule #6: the Pay button should be enabled since all the
    # previous tests pass, and now we have filled in the account details
    populateCardFields
    set payButton [waitForObject $names::Make_Payment_Pay_QPushButton]
    test verify [property get $payButton enabled]

    sendEvent "QCloseEvent" [waitForObject $names::Make_Payment_MainWindow]
}

proc checkCardDateEdits {} {
    set cardTypeComboBox [waitForObject $names::Card_Type_QComboBox]
    set count [property get $cardTypeComboBox count]
    for {set index 0} {$index < $count} {incr index} {
        if {[invoke $cardTypeComboBox itemText $index] != "Visa"} {
            invoke $cardTypeComboBox setCurrentIndex $index
            break
        }
    }
    set today [invoke QDate currentDate]
    set issueDateEdit [waitForObject $names::Issue_Date_QDateEdit]
    set maximumIssueDate [toString [property get $issueDateEdit \
        maximumDate]]
    set threeYearsAgo [toString [invoke $today addYears -3]]
    test verify [string equal $maximumIssueDate $threeYearsAgo]

    set expiryDateEdit [waitForObject $names::Expiry_Date_QDateEdit]
    set date [invoke $today addMonths 2]
    invoke type $expiryDateEdit [invoke $date toString "MMM yyyy"]
}

proc populateCardFields {} {
    set cardAccountNameLineEdit [waitForObject $names::Account_Name_QLineEdit]
    invoke type $cardAccountNameLineEdit "An Account"
    set cardAccountNumberLineEdit [waitForObject $names::Account_Number_QLineEdit]
    invoke type $cardAccountNumberLineEdit "1343 876 326 1323 32"
}

proc main {} {
    startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/itemviews/itemviews\""
    set listWidgetName {{type='QListWidget' unnamed='1' visible='1'}}
    set listWidget [waitForObject $listWidgetName]
    for {set row 0} {$row < [property get $listWidget count]} {incr row} {
        set item [invoke $listWidget item $row]
        set checked ""
        set selected ""
        if {[invoke $item checkState] == [enum Qt Checked]} {
            set checked " +checked"
        }
        if [invoke $item isSelected] {
            set selected " +selected"
        }
        set text [toString [invoke $item text]]
        test log "($row) '$text'$checked$selected"
    }
    sendEvent "QCloseEvent" [waitForObject ":Item Views_MainWindow"]
}

proc main {} {
    startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/itemviews/itemviews\""
    set listViewName {{type='QListView' unnamed='1' visible='1'}}
    set listView [waitForObject $listViewName]
    set model [invoke $listView model]
    set selectionModel [invoke $listView selectionModel]
    for {set row 0} {$row < [invoke $model rowCount]} {incr row} {
        set index [invoke $model index $row 0]
        set text [toString [invoke [invoke $model data $index] toString]]
        set checked ""
        set selected ""
        set checkState [invoke [invoke $model data $index \
            [enum Qt CheckStateRole]] toInt]
        if {$checkState == [enum Qt Checked]} {
            set checked " +checked"
        }
        if [invoke $selectionModel isSelected $index] {
            set selected " +selected"
        }
        test log "($row) '$text'$checked$selected"
    }
    sendEvent "QCloseEvent" [waitForObject ":Item Views_MainWindow"]
}

    set tableWidget [waitForObject {{type='QTableWidget' \
        unnamed='1' visible='1'}}]
    invoke $tableWidget setRowCount 4
    invoke $tableWidget setColumnCount 3
    set count 0
    for {set row 0} {$row < [property get $tableWidget rowCount]} \
        {incr row} {
        for {set column 0} {$column < [property get $tableWidget \
            columnCount]} {incr column} {
            set tableItem [construct QTableWidgetItem "Item $count"]
                incr count
                if {$column == 2} {
                    invoke $tableItem setCheckState [enum Qt Unchecked]
                    if {$row == 1 || $row == 3} {
                        invoke $tableItem setCheckState \
                            [enum Qt Checked]
                    }
                }
                invoke $tableWidget setItem $row $column $tableItem
                if {$count == 6 || $count == 10} {
                invoke $tableItem setSelected 1
                }
        }
    }
    invoke $tableWidget setRowHidden 2 true

    set tableWidget [waitForObject {{type='QTableWidget' \
        unnamed='1' visible='1'}}]
    for {set row 0} {$row < [property get $tableWidget rowCount]} \
        {incr row} {
        if {[invoke $tableWidget isRowHidden $row]} {
                test log "Skipping hidden row $row"
            continue
        }
        for {set column 0} {$column < [property get $tableWidget \
            columnCount]} {incr column} {
            set tableItem [invoke $tableWidget item $row $column]
            set text [toString [invoke $tableItem text]]
            set checked ""
            set selected ""
            if {[invoke $tableItem checkState] == [enum Qt Checked]} {
                set checked " +checked"
            }
            if {[invoke $tableItem isSelected]} {
                set selected " +selected"
            }
            test log "($row, $column) '$text'$checked$selected"
        }
    }

proc main {} {
    startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/itemviews/itemviews\""
    set tableViewName {{type='QTableView' unnamed='1' visible='1'}}
    set tableView [waitForObject $tableViewName]
    set model [invoke $tableView model]
    set selectionModel [invoke $tableView selectionModel]
    for {set row 0} {$row < [invoke $model rowCount]} {incr row} {
        for {set column 0} {$column < [invoke $model columnCount]} \
            {incr column} {
            set index [invoke $model index $row $column]
            set text [toString [invoke [invoke $model data $index] \
                toString]]
            set checked ""
            set selected ""
            set checkState [invoke [invoke $model data $index \
                [enum Qt CheckStateRole]] toInt]
            if {$checkState == [enum Qt Checked]} {
                set checked " +checked"
            }
            if [invoke $selectionModel isSelected $index] {
                set selected " +selected"
            }
            test log "($row, $column) '$text'$checked$selected"
        }
    }
    sendEvent "QCloseEvent" [waitForObject ":Item Views_MainWindow"]
}

    proc checkAnItem {indent item root} {
        if {$indent > -1} {
            set checked ""
            set selected ""
            if {[invoke $item checkState 0] == [enum Qt Checked]} {
                set checked " +checked"
            }
            if [invoke $item isSelected] {
                set selected " +selected"
            }
            set text [toString [invoke $item text 0]]
            set pad [string repeat " " $indent]
            test log "|$pad'$text'$checked$selected"
        } else {
            set indent [expr -4]
        }
        # Only show visible child items
        if {$item != $root && [invoke $item isExpanded] || $item == $root} {
            for {set row 0} {$row < [invoke $item childCount]} {incr row} {
                checkAnItem [expr $indent + 4] [invoke $item child $row] \
                    $root
            }
        }
    }

proc main {} {
        startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/itemviews/itemviews\""
        set treeWidgetName {{type='QTreeWidget' unnamed='1' visible='1'}}
        set treeWidget [waitForObject $treeWidgetName]
        set root [invoke $treeWidget invisibleRootItem]
        checkAnItem -1 $root $root
        sendEvent "QCloseEvent" [waitForObject ":Item Views_MainWindow"]
    }

    proc checkAnItem {indent index treeView model selectionModel} {
        if {$indent > -1 && [invoke $index isValid]} {
            set text [toString [invoke [invoke $model data $index] toString]]
            set checked ""
            set selected ""
            set checkState [invoke [invoke $model data $index \
                [enum Qt CheckStateRole]] toInt]
            if {$checkState == [enum Qt Checked]} {
                set checked " +checked"
            }
            if [invoke $selectionModel isSelected $index] {
                set selected " +selected"
            }
            set pad [string repeat " " $indent]
            test log "|$pad'$text'$checked$selected"
        } else {
            set indent [expr -4]
        }
        # Only show visible child items
        if {[invoke $index isValid] && \
            [invoke $treeView isExpanded $index] || \
            ![invoke $index isValid]} {
            for {set row 0} {$row < [invoke $model rowCount $index]} \
                {incr row} {
                checkAnItem [expr $indent + 4] [invoke $model index \
                    $row 0 $index] $treeView $model $selectionModel
            }
        }
    }

proc main {} {
        startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/itemviews/itemviews\""
        set treeViewName {{type='QTreeView' unnamed='1' visible='1'}}
        set treeView [waitForObject $treeViewName]
        set model [invoke $treeView model]
        set selectionModel [invoke $treeView selectionModel]
        checkAnItem -1 [construct QModelIndex] $treeView $model \
            $selectionModel
        sendEvent "QCloseEvent" [waitForObject ":Item Views_MainWindow"]
    }

proc main {} {
    startApplication "\"$::env(SQUISH_PREFIX)/examples/qt/csvtable/csvtable\""
    source [findFile "scripts" "common.tcl"]
    doFileOpen [findFile "testdata" "before.csv"]
    set tableWidget [waitForObject {{type='QTableWidget' \
        unnamed='1' visible='1'}}]
    compareTableWithDataFile $tableWidget "before.csv"
}

proc doFileOpen {path_and_filename} {
    invoke activateItem [waitForObjectItem $names::CSV_Table_QMenuBar "File"]
    invoke activateItem [waitForObjectItem $names::CSV_Table_File_QMenu "Open..."]

    set fn [file join [squishinfo testCase] $path_and_filename]
    invoke type $names::fileNameEdit_QLineEdit $fn
    invoke clickButton $names::CSV_Table_Choose_File_Open_QPushButton

}

proc chooseMenuOptionByKey {menuTitle menuKey optionKey} {
    set windowName "{type='MainWindow' unnamed='1' visible='1' \
        windowTitle?='CSV Table*'}"
    waitForObject $windowName
    invoke type $windowName "<Alt+$menuKey>"
    set menuName "{title='$menuTitle' type='QMenu' unnamed='1' \
        visible='1'}"
    waitForObject $menuName
    invoke type $menuName $optionKey
}

proc compareTableWithDataFile {tableWidget filename} {
    set data [testData dataset $filename]
    for {set row 0} {$row < [llength $data]} {incr row} {
        set columnNames [testData fieldNames [lindex $data $row]]
        for {set column 0} {$column < [llength $columnNames]} {incr column} {
            set tableItem [invoke $tableWidget item $row $column]
            test compare [testData field [lindex $data $row] $column] \
                [invoke $tableItem text]
        }
    }
}

    # Added by hand
    source [findFile "scripts" "common.tcl"]
    set tableWidget [waitForObject {{type='QTableWidget' \
        unnamed='1' visible='1'}}]
    compareTableWithDataFile $tableWidget "after.csv"

    sendEvent QCloseEvent [waitForObject $names::CSV_Table_MainWindow]

    waitForObject "{type='QPushButton' unnamed='1' text='No'}"
    invoke clickButton "{type='QPushButton' unnamed='1' text='No'}"

    set tableWidget [waitForObject {{type='QTableWidget' \
        unnamed='1' visible='1'}}]
    test compare [property get $tableWidget rowCount] 12
    test compare [property get $tableWidget columnCount] 5

set menu [waitForObject ":CSV Table.Edit_QMenu"]
set removeAction [getAction $menu "Disabled"]
test compare [property get $removeAction enabled] 0
test compare [property get $removeAction checked] 0
set insertRowAction [getAction $menu "&Insert Row"]
test compare [property get $insertRowAction enabled] 1
test compare [property get $insertRowAction checked] 0

proc getAction {widget text} {
    set actions [invoke $widget actions]
    for {set index 0} {$index < [invoke $actions count]} \
            {incr index} {
        set action [invoke $actions at $index]
        set action_text [toString [property get $action text]]
        if {[string equal $action_text $text]} {
            return $action
        }
    }
}

    test verify [property get [waitForObject $names::Add_Box_QPushButton] enabled]
    test verify [property get [waitForObject $names::Add_Polygon_QPushButton] enabled]
    test verify [property get [waitForObject $names::Add_Text_QPushButton] enabled]
    test verify [property get [waitForObject $names::Quit_QPushButton] enabled]
    test compare [property get [waitForObjectExists $names::Delete_QPushButton] enabled] 0
    test compare [property get [waitForObjectExists $names::QSpinBox] enabled] 0

    set rectItem1 [waitForObject $names::QGraphicsRectItem]
    set rectItem2 [waitForObject $names::QGraphicsRectItem_2]
    set rectItem1X [property get [property get $rectItem1 rect] x]
    set rectItem1Y [property get [property get $rectItem1 rect] y]
    set rectItem2X [property get [property get $rectItem2 rect] x]
    set rectItem2Y [property get [property get $rectItem2 rect] y]
    test compare $rectItem2X [expr $rectItem1X + 5]
    test compare $rectItem2Y [expr $rectItem1Y + 5]
    test verify [expr [property get $rectItem1 zValue] < [property get $rectItem2 zValue]]
    set polygonItem [waitForObject $names::QGraphicsPolygonItem]
    test compare [invoke [property get $polygonItem polygon] count] 3

    test compare [invoke [property get $polygonItem polygon] count] 4
    set textItem [waitForObject $names::QGraphicsTextItem]
    test compare [invoke $textItem toPlainText] "Some Text"
    set countLCD [waitForObject $names::QLCDNumber]
    test compare [invoke $countLCD intValue] 4
    test verify [property get [waitForObject $names::Delete_QPushButton] enabled]
    test verify [property get [waitForObject $names::QSpinBox] enabled]