/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of The Qt Company Ltd nor the names of its
**     contributors may be used to endorse or promote products derived
**     from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/

import QtQuick 2.2
import QtQuick.Controls 1.2
import QtQuick.Controls.Private 1.0
import QtTest 1.0

Item {
    id: container
    width: 300; height: 300

    TestCase {
        id: testcase
        name: "Tests_SpinBox"
        when: windowShown

        property int arrowMargin: 4 // the mouse areas for the up/down arrows have margins
        property point mainCoord: "0,0"
        property point upCoord: "0,0"
        property point downCoord: "0,0"

        function test_increment_key() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {maximumValue: 50}', container, '')
            spinbox.forceActiveFocus()

            compare(spinbox.maximumValue, 50)
            spinbox.value = spinbox.maximumValue - 3
            keyPress(Qt.Key_Up)
            compare(spinbox.value, spinbox.maximumValue - 2)
            keyPress(Qt.Key_Up)
            keyPress(Qt.Key_Up)
            compare(spinbox.value, spinbox.maximumValue)
            keyPress(Qt.Key_Up)
            compare(spinbox.value, spinbox.maximumValue)
            spinbox.destroy()
        }

        function test_decrement_key() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {minimumValue: 10}', container, '')
            spinbox.forceActiveFocus()

            compare(spinbox.minimumValue, 10)
            spinbox.value = spinbox.minimumValue + 3
            keyPress(Qt.Key_Down)
            compare(spinbox.value, spinbox.minimumValue + 2)
            keyPress(Qt.Key_Down)
            keyPress(Qt.Key_Down)
            compare(spinbox.value, spinbox.minimumValue)
            keyPress(Qt.Key_Down)
            compare(spinbox.value, spinbox.minimumValue)
            spinbox.destroy()
        }

        function test_initial_value() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {decimals: 3 ; value: 0.25}', container, '')
            compare(spinbox.value, 0.25)
            spinbox.destroy()

            spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {value: 0.25 ; decimals: 3}', container, '')
            compare(spinbox.value, 0.25)
            spinbox.destroy()
        }

        function test_keyboard_input_data() {
            return [
                {tag: "1", input: [Qt.Key_1], value: 1},
                {tag: "10", input: [Qt.Key_1, Qt.Key_0], value: 10},
                // max 99 -> last '0' ignored
                {tag: "100", input: [Qt.Key_1, Qt.Key_0, Qt.Key_0], value: 10},

                {tag: "1.1", input: [Qt.Key_1, Qt.locale().decimalPoint, Qt.Key_1], value: 1.1, decimals: 1},
                {tag: "10.10", input: [Qt.Key_1, Qt.Key_0, Qt.locale().decimalPoint, Qt.Key_1, Qt.Key_0], value: 10.10, decimals: 2},
                // max 99 -> '3' ignored, decimals 2 -> '6' ignored
                {tag: "123.456", input: [Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.locale().decimalPoint, Qt.Key_4, Qt.Key_5, Qt.Key_6], value: 12.45, decimals: 2},

                {tag: "-1", input: [Qt.Key_Minus, Qt.Key_1], value: -1, minimumValue: -99},
                {tag: "-10", input: [Qt.Key_Minus, Qt.Key_1, Qt.Key_0], value: -10, minimumValue: -99},
                // min -99 -> last 0 ignored
                {tag: "-100", input: [Qt.Key_Minus, Qt.Key_1, Qt.Key_0, Qt.Key_0], value: -10, minimumValue: -99},

                {tag: "-1.1", input: [Qt.Key_Minus, Qt.Key_1, Qt.locale().decimalPoint, Qt.Key_1], value: -1.1, decimals: 1, minimumValue: -99},
                {tag: "-10.10", input: [Qt.Key_Minus, Qt.Key_1, Qt.Key_0, Qt.locale().decimalPoint, Qt.Key_1, Qt.Key_0], value: -10.10, decimals: 2, minimumValue: -99},
                // min -99 -> '3' ignored, decimals 2 -> '6' ignored
                {tag: "-123.456", input: [Qt.Key_Minus, Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.locale().decimalPoint, Qt.Key_4, Qt.Key_5, Qt.Key_6], value: -12.45, decimals: 2, minimumValue: -99},

                {tag: "2.54cm", input: [Qt.Key_2, Qt.locale().decimalPoint, Qt.Key_5, Qt.Key_4, Qt.Key_C, Qt.Key_M], value: 2.54, suffix: "cm", decimals: 2},
                {tag: "$100", input: [Qt.Key_Dollar, Qt.Key_1, Qt.Key_0, Qt.Key_0], value: 100, maximumValue: 100},

                {tag: "asdf foo", input: [Qt.Key_A, Qt.Key_S, Qt.Key_D, Qt.Key_F, Qt.Key_Space, Qt.Key_F, Qt.Key_O, Qt.Key_O], value: 0},
                {tag: "a1b2c3d4e5", input: [Qt.Key_A, Qt.Key_1, Qt.Key_B, Qt.Key_2, Qt.Key_C, Qt.Key_3, Qt.Key_D, Qt.Key_4, Qt.Key_E, Qt.Key_5], value: 1234, maximumValue: 2000},

                {tag: "20", input: [Qt.Key_2, Qt.Key_0, Qt.Key_Return], value: 2, maximumValue: 10},
                {tag: "200", input: [Qt.Key_2, Qt.Key_0, Qt.Key_0, Qt.Key_Return], value: 20, maximumValue: 100},
                {tag: "2000", input: [Qt.Key_2, Qt.Key_0, Qt.Key_0, Qt.Key_0, Qt.Key_Return], value: 200, maximumValue: 1000},
                {tag: "0123", input: [Qt.Key_0, Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_Return], value: 123, maximumValue: 150},
                {tag: "-20", input: [Qt.Key_Minus, Qt.Key_2, Qt.Key_0, Qt.Key_Return], value: -2, minimumValue: -10},
                {tag: "-200", input: [Qt.Key_Minus, Qt.Key_2, Qt.Key_0, Qt.Key_0, Qt.Key_Return], value: -20, minimumValue: -100},
                {tag: "-2000", input: [Qt.Key_Minus, Qt.Key_2, Qt.Key_0, Qt.Key_0, Qt.Key_0, Qt.Key_Return], value: -200, minimumValue: -1000},
                {tag: "-0123", input: [Qt.Key_Minus, Qt.Key_0, Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_Return], value: -123, minimumValue: -150},

                {tag: "5", input: [Qt.Key_2, Qt.Key_0, Qt.Key_Return], value: 20, minimumValue: 10, maximumValue: 99},
                {tag: "-5", input: [Qt.Key_Minus, Qt.Key_2, Qt.Key_0, Qt.Key_Return], value: -20, minimumValue: -99, maximumValue: -10},
            ]
        }

        function test_keyboard_input(data) {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.forceActiveFocus()

            if (data.decimals !== undefined)
                spinbox.decimals = data.decimals
            if (data.minimumValue !== undefined)
                spinbox.minimumValue = data.minimumValue
            if (data.maximumValue !== undefined)
                spinbox.maximumValue = data.maximumValue
            if (data.prefix !== undefined)
                spinbox.prefix = data.prefix
            if (data.suffix !== undefined)
                spinbox.suffix = data.suffix

            // select all & input
            keyClick(Qt.Key_A, Qt.ControlModifier)
            for (var i = 0; i < data.input.length; ++i)
                keyClick(data.input[i])

            compare(spinbox.value, data.value)
            spinbox.destroy()
        }

        function test_increment_mouse() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {maximumValue: 50}', container, '')
            spinbox.forceActiveFocus()
            setCoordinates(spinbox)

            spinbox.value = spinbox.maximumValue - 3
            mouseClick(spinbox, upCoord.x, upCoord.y, Qt.LeftButton)
            compare(spinbox.value, spinbox.maximumValue - 2)
            mouseClick(spinbox, upCoord.x, upCoord.y, Qt.LeftButton)
            mouseClick(spinbox, upCoord.x, upCoord.y, Qt.LeftButton)
            compare(spinbox.value, spinbox.maximumValue)
            mouseClick(spinbox, upCoord.x, upCoord.y, Qt.LeftButton)
            compare(spinbox.value, spinbox.maximumValue)
            spinbox.destroy()
        }

        function test_decrement_mouse() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {minimumValue: 10}', container, '')
            spinbox.forceActiveFocus()
            setCoordinates(spinbox)

            spinbox.value = spinbox.minimumValue + 3
            mouseClick(spinbox, downCoord.x, downCoord.y, Qt.LeftButton)
            compare(spinbox.value, spinbox.minimumValue + 2)
            mouseClick(spinbox, downCoord.x, downCoord.y, Qt.LeftButton)
            mouseClick(spinbox, downCoord.x, downCoord.y, Qt.LeftButton)
            compare(spinbox.value, spinbox.minimumValue)
            mouseClick(spinbox, downCoord.x, downCoord.y, Qt.LeftButton)
            compare(spinbox.value, spinbox.minimumValue)
            spinbox.destroy()
        }

        function test_move_mouse() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.forceActiveFocus()
            setCoordinates(spinbox)

            mouseMove(spinbox, mainCoord.x, mainCoord.y)
            compare(spinbox.hovered, true)
            compare(spinbox.__styleData.upHovered, false)
            compare(spinbox.__styleData.downHovered, false)

            mouseMove(spinbox.parent, upCoord.x, upCoord.y)
            compare(spinbox.__styleData.upHovered, true)
            compare(spinbox.__styleData.downHovered, false)

            mouseMove(spinbox, downCoord.x, downCoord.y)
            compare(spinbox.__styleData.upHovered, false)
            compare(spinbox.__styleData.downHovered, true)

            mouseMove(spinbox, mainCoord.x - 2, mainCoord.y - 2)
            compare(spinbox.hovered, false)
            compare(spinbox.__styleData.upHovered, false)
            compare(spinbox.__styleData.downHovered, false)
            spinbox.destroy()
        }

        function test_maxvalue() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.value = spinbox.maximumValue + 1
            compare(spinbox.value, spinbox.maximumValue)

            spinbox.maximumValue = 0;
            spinbox.minimumValue = 0;
            spinbox.value = 10;
            compare(spinbox.value, 0)

            spinbox.maximumValue = 5;
            spinbox.minimumValue = 0;
            spinbox.value = 10;
            compare(spinbox.value, 5)
            spinbox.destroy()
        }

        function test_minvalue() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.value = spinbox.minimumValue - 1
            compare(spinbox.value, spinbox.minimumValue)

            spinbox.maximumValue = 0;
            spinbox.minimumValue = 6;
            spinbox.value = 3;
            compare(spinbox.value, 6)

            spinbox.maximumValue = 10;
            spinbox.minimumValue = 6;
            spinbox.value = 0;
            compare(spinbox.value, 6)
            spinbox.destroy()
        }

        function test_decimals() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')

            spinbox.decimals = 0
            spinbox.value = 1.00001
            compare(spinbox.value, 1)
            compare(spinbox.__text, "1")

            spinbox.decimals = 1
            spinbox.value = 1.00001
            compare(spinbox.value, 1)
            compare(spinbox.__text, "1" + Qt.locale().decimalPoint + "0")
            spinbox.value = 1.1
            compare(spinbox.value, 1.1)
            compare(spinbox.__text, "1" + Qt.locale().decimalPoint + "1")

            spinbox.decimals = 5
            spinbox.value = 1.00001
            compare(spinbox.value, 1.00001)
            compare(spinbox.__text, "1" + Qt.locale().decimalPoint + "00001")

            spinbox.decimals = 6
            compare(spinbox.value, 1.00001)
            compare(spinbox.__text, "1" + Qt.locale().decimalPoint + "000010")
            spinbox.destroy()
        }

        function test_groupSeparators() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox { maximumValue: 1000 }', container, '')

            spinbox.value = 1000
            // QTBUG-31839: SpinBox displays group separators
            compare(spinbox.__text.indexOf(Qt.locale().groupSeparator), -1)

            spinbox.destroy()
        }

        function test_stepsize()
        {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.forceActiveFocus()

            spinbox.stepSize = 2
            spinbox.value = 10

            compare(spinbox.value, 10)

            keyPress(Qt.Key_Up)
            compare(spinbox.value, 10 + spinbox.stepSize)

            var previousValue = spinbox.value
            keyPress(Qt.Key_Down)
            compare(spinbox.value, previousValue - spinbox.stepSize)
            spinbox.destroy()
        }

        function test_negativeStepSize()
        {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.forceActiveFocus()

            spinbox.minimumValue = -50
            spinbox.maximumValue = 50

            spinbox.stepSize = -2
            spinbox.value = 5

            compare(spinbox.value, 5)

            keyPress(Qt.Key_Up)
            compare(spinbox.value, 5 + spinbox.stepSize)

            var previousValue = spinbox.value
            keyPress(Qt.Key_Down)
            compare(spinbox.value, previousValue - spinbox.stepSize)

            // test on the edges

            spinbox.value = -49
            keyPress(Qt.Key_Up)
            compare(spinbox.value, spinbox.minimumValue)

            spinbox.value = 49
            keyPress(Qt.Key_Down)
            compare(spinbox.value, spinbox.maximumValue)
            spinbox.destroy()
        }

        function test_initialization_order()
        {
            var spinbox = Qt.createQmlObject("import QtQuick.Controls 1.2; SpinBox { id: spinbox;"  +
                                             "maximumValue: 2000; value: 1000; implicitWidth:80}",
                                             container, '')
            compare(spinbox.value, 1000);

            var spinbox2 = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox { minimumValue: -1000 ; value:-1000}',
                                             container, '')
            compare(spinbox2.value, -1000);
            spinbox.destroy()
            spinbox2.destroy()
        }

        function test_setFontsize(){
            var control = Qt.createQmlObject('import QtQuick.Controls 1.2; import QtQuick.Controls.Styles 1.1; SpinBox {style: SpinBoxStyle{}}', container, '')
            var width = control.width;
            var height = control.height;
            control.font.pixelSize = 40
            verify(control.width > width) // ensure that the text field resizes
            verify(control.height > height)
            control.destroy()
        }

        function test_get_active_focus_when_up_or_down_was_pressed(){
            if (Settings.hasTouchScreen)
                skip("Fails with touch screens");
            var test_control = 'import QtQuick 2.2;             \
            import QtQuick.Controls 1.2;                        \
            Column {                                            \
                property alias spinbox: _spinbox;               \
                property alias textfield: _textfield;           \
                SpinBox  {                                      \
                    id: _spinbox;                               \
                }                                               \
                TextField {                                     \
                    id: _textfield;                             \
                    text: "textfile";                           \
                }                                               \
            }                                                   '

            var control = Qt.createQmlObject(test_control, container, '')
            verify(control !== null)

            var spinbox = control.spinbox
            var textfield = control.textfield
            verify(spinbox !== null)
            verify(textfield !== null)

            waitForRendering(control)

            var up = getMouseArea(spinbox, "mouseUp")
            verify(up !== null)
            var down = getMouseArea(spinbox, "mouseDown")
            verify(down !== null)

            textfield.forceActiveFocus()
            verify(!spinbox.activeFocus)
            verify(textfield.activeFocus)

            mouseClick(up, up.width/2, up.height/2)
            verify(spinbox.activeFocus)
            verify(!textfield.activeFocus)

            textfield.forceActiveFocus()
            verify(!spinbox.activeFocus)
            verify(textfield.activeFocus)

            mouseClick(down, down.width/2, down.height/2)
            verify(spinbox.activeFocus)
            verify(!textfield.activeFocus)

            textfield.forceActiveFocus()
            verify(!spinbox.activeFocus)
            verify(textfield.activeFocus)
            spinbox.activeFocusOnPress = false

            mouseClick(up, up.width/2, up.height/2)
            verify(!spinbox.activeFocus)
            verify(textfield.activeFocus)

            mouseClick(down, down.width/2, down.height/2)
            verify(!spinbox.activeFocus)
            verify(textfield.activeFocus)

            control.destroy()
        }

        function getMouseArea(control, name) {
            for (var i = 0; i < control.children.length; i++) {
                if (control.children[i].objectName === name)
                    return control.children[i]
            }
            return null
        }

        function test_activeFocusOnPress(){
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {x: 20; y: 20; width: 100; height: 50}', container, '')
            spinbox.activeFocusOnPress = false
            verify(!spinbox.activeFocus)
            mouseClick(spinbox, 30, 30)
            verify(!spinbox.activeFocus)
            spinbox.activeFocusOnPress = true
            verify(!spinbox.activeFocus)
            mouseClick(spinbox, 30, 30)
            verify(spinbox.activeFocus)
            spinbox.destroy()
        }

        function test_activeFocusOnTab() {
            var test_control = 'import QtQuick 2.2; \
            import QtQuick.Controls 1.2;            \
            Item {                                  \
                width: 200;                         \
                height: 200;                        \
                property alias control1: _control1; \
                property alias control2: _control2; \
                property alias control3: _control3; \
                SpinBox  {                          \
                    y: 20;                          \
                    id: _control1;                  \
                    activeFocusOnTab: true;         \
                }                                   \
                SpinBox  {                          \
                    y: 70;                          \
                    id: _control2;                  \
                    activeFocusOnTab: false;        \
                }                                   \
                SpinBox  {                          \
                    y: 120;                         \
                    id: _control3;                  \
                    activeFocusOnTab: true;         \
                }                                   \
            }                                       '

            var control = Qt.createQmlObject(test_control, container, '')
            control.control1.forceActiveFocus()
            verify(control.control1.activeFocus)
            verify(!control.control2.activeFocus)
            verify(!control.control3.activeFocus)
            keyPress(Qt.Key_Tab)
            verify(!control.control1.activeFocus)
            verify(!control.control2.activeFocus)
            verify(control.control3.activeFocus)
            keyPress(Qt.Key_Tab)
            verify(control.control1.activeFocus)
            verify(!control.control2.activeFocus)
            verify(!control.control3.activeFocus)
            keyPress(Qt.Key_Tab, Qt.ShiftModifier)
            verify(!control.control1.activeFocus)
            verify(!control.control2.activeFocus)
            verify(control.control3.activeFocus)
            keyPress(Qt.Key_Tab, Qt.ShiftModifier)
            verify(control.control1.activeFocus)
            verify(!control.control2.activeFocus)
            verify(!control.control3.activeFocus)

            control.control2.activeFocusOnTab = true
            control.control3.activeFocusOnTab = false
            keyPress(Qt.Key_Tab)
            verify(!control.control1.activeFocus)
            verify(control.control2.activeFocus)
            verify(!control.control3.activeFocus)
            keyPress(Qt.Key_Tab)
            verify(control.control1.activeFocus)
            verify(!control.control2.activeFocus)
            verify(!control.control3.activeFocus)
            keyPress(Qt.Key_Tab, Qt.ShiftModifier)
            verify(!control.control1.activeFocus)
            verify(control.control2.activeFocus)
            verify(!control.control3.activeFocus)
            keyPress(Qt.Key_Tab, Qt.ShiftModifier)
            verify(control.control1.activeFocus)
            verify(!control.control2.activeFocus)
            verify(!control.control3.activeFocus)
            control.destroy()
        }

        function test_ImplicitSize() // Verify if we correctly grow and shrink depending on contents
        {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.forceActiveFocus()
            spinbox.minimumValue = -50
            spinbox.maximumValue = 50

            var oldSize = spinbox.implicitWidth
            spinbox.maximumValue = 5000
            verify(oldSize < spinbox.implicitWidth)
            oldSize = spinbox.implicitWidth
            spinbox.maximumValue = 50
            verify(oldSize > spinbox.implicitWidth)

            oldSize = spinbox.implicitWidth
            spinbox.minimumValue = -5000
            verify(oldSize < spinbox.implicitWidth)

            spinbox.minimumValue = -50
            oldSize = spinbox.implicitWidth
            spinbox.minimumValue = -5000
            verify(oldSize < spinbox.implicitWidth)

            spinbox.minimumValue = -50
            oldSize = spinbox.implicitWidth
            spinbox.minimumValue = -5000
            verify(oldSize < spinbox.implicitWidth)

            spinbox.minimumValue = -50
            spinbox.decimals = 0
            oldSize = spinbox.implicitWidth
            spinbox.decimals = 4
            verify(oldSize < spinbox.implicitWidth)
            spinbox.destroy()
        }

        function test_wheel() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox {}', container, '')
            spinbox.forceActiveFocus()
            spinbox.minimumValue = 0
            spinbox.maximumValue = 99
            spinbox.value = 10
            mouseWheel(spinbox, 5, 5, 0, 120)
            compare(spinbox.value, 11)
            mouseWheel(spinbox, 5, 5, 0, -120)
            mouseWheel(spinbox, 5, 5, 0, -120)
            compare(spinbox.value, 9)
            spinbox.destroy()
        }

        function test_editingFinished() {
            var component = Qt.createComponent("spinbox/sp_editingfinished.qml")
            compare(component.status, Component.Ready)
            var test =  component.createObject(container);
            verify(test !== null, "test control created is null")
            var control1 = test.control1
            verify(control1 !== null)
            var control2 = test.control2
            verify(control2 !== null)

            control1.forceActiveFocus()
            verify(control1.activeFocus)
            verify(!control2.activeFocus)

            verify(control1.myeditingfinished === false)
            verify(control2.myeditingfinished === false)

            keyPress(Qt.Key_Tab)
            verify(!control1.activeFocus)
            verify(control2.activeFocus)
            verify(control1.myeditingfinished === true)

            keyPress(Qt.Key_Enter)
            verify(!control1.activeFocus)
            verify(control2.activeFocus)
            verify(control2.myeditingfinished === true)

            test.destroy()
        }

        function test_construction() {
            // onValueChanged should not be emitted during construction.
            var root = Qt.createQmlObject("
                import QtQuick 2.2
                import QtQuick.Controls 1.2
                Item {
                    id: root
                    property bool ok: true
                    Item {
                        SpinBox {
                            value: 42
                            onValueChanged: { if (check === null) root.ok = false; }
                        }
                    }
                    Rectangle {
                        id: check
                    }
                }",
            container, "");
            verify(root.ok);
        }

        function setCoordinates(item)
        {
            mainCoord.x = item.x + 1
            mainCoord.y = item.y + 1
            upCoord.x = item.x + item.width - arrowMargin
            upCoord.y = item.y + arrowMargin
            downCoord.x = upCoord.x
            downCoord.y = item.y + item.height - arrowMargin
        }

        function test_fixup() {
            var spinbox = Qt.createQmlObject('import QtQuick.Controls 1.2; SpinBox { minimumValue: -1 }', container, '')
            verify(spinbox)
            spinbox.forceActiveFocus()
            verify(spinbox.activeFocus)

            keyClick(Qt.Key_Minus)
            keyClick(Qt.Key_0)
            compare(spinbox.__text, "-0")

            // fixup "-0" to "0" on accept
            keyClick(Qt.Key_Enter)
            compare(spinbox.__text, "0")

            spinbox.prefix = "pfx"
            spinbox.suffix = "sfx"
            keyClick(Qt.Key_A, Qt.ControlModifier)
            keyClick(Qt.Key_Minus)
            keyClick(Qt.Key_0)
            compare(spinbox.__text, "pfx-0sfx")

            // fixup "-0" to "0" on defocus
            spinbox.focus = false
            compare(spinbox.__text, "pfx0sfx")

            spinbox.destroy()
        }

        function test_keys() {
            var component = Qt.createComponent("spinbox/sb_keys.qml")
            compare(component.status, Component.Ready)
            var test =  component.createObject(container);
            verify(test !== null, "test control created is null")
            var control1 = test.control1
            verify(control1 !== null)

            control1.forceActiveFocus()
            verify(control1.activeFocus)

            verify(control1.gotit === false)
            verify(control1.value === 9)

            keyPress(Qt.Key_A)
            verify(control1.activeFocus)
            verify(control1.gotit === false)
            verify(control1.value === 9)

            keyPress(Qt.Key_B)
            verify(control1.activeFocus)
            verify(control1.gotit === true)
            verify(control1.value === 7)

            keyPress(Qt.Key_B)
            verify(control1.activeFocus)
            verify(control1.gotit === true)
            verify(control1.value === 7)

            test.destroy()
        }

        Component {
            id: moveMouseFlickable
            Flickable {
                property alias spinbox: _spinbox
                width: 100
                height: 200
                contentHeight: 500
                contentWidth: 200
                SpinBox {
                    id: _spinbox
                    x: 20
                    y: 100
                    minimumValue: 0
                    maximumValue: 12500
                }
            }
        }

        function test_moveMouseInFlickable() {
            var control = createTemporaryObject(moveMouseFlickable, container)
            var spinbox = control.spinbox
            spinbox.forceActiveFocus()
            setCoordinates(spinbox)
            mousePress(spinbox, upCoord.x, upCoord.y, Qt.LeftButton)
            mouseMove(spinbox.parent, mainCoord.x, mainCoord.y - 50, 500)
            compare(spinbox.hovered, false)
            compare(spinbox.__styleData.upHovered, false)
            compare(spinbox.__styleData.downHovered, false)
            mouseRelease(spinbox.parent, mainCoord.x, mainCoord.y - 50, Qt.LeftButton)
            var currentVal = spinbox.value
            mouseMove(spinbox.parent, upCoord.x, upCoord.y)
            compare(spinbox.hovered, true)
            compare(spinbox.__styleData.upHovered, true)
            compare(spinbox.__styleData.downHovered, false)
            compare(spinbox.value, currentVal)
        }
    }
}