Say hello to StackLayout

Task-number: QTBUG-44077
Change-Id: I85dadc0950617728bca83d5c72ed5a086352b57d
Reviewed-by: J-P Nurmi <jpnurmi@theqtcompany.com>

1 files changed, 448 insertions, 0 deletions

diff --git a/tests/auto/controls/data/tst_stacklayout.qml b/tests/auto/controls/data/tst_stacklayout.qml
new file mode 100644
index 00000000..ba468a24
--- /dev/null
+++ b/tests/auto/controls/data/tst_stacklayout.qml
@@ -0,0 +1,448 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** 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 http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.2
+import QtTest 1.0
+import QtQuick.Layouts 1.3
+
+Item {
+    id: container
+    width: 200
+    height: 200
+    TestCase {
+        id: testCase
+        name: "Tests_StackLayout"
+        when: windowShown
+        width: 200
+        height: 200
+
+        function geometry(item) {
+            return [item.x, item.y, item.width, item.height]
+        }
+
+        Component {
+            id: countGeometryChanges_Component
+            StackLayout {
+                id: stack
+                property alias col: _col
+                property alias row: _row
+                width: 100
+                ColumnLayout {
+                    id: _col
+                    property alias r1: _r1
+                    property alias r2: _r2
+                    property alias r3: _r3
+                    spacing: 0
+                    property int counter : 0
+                    onWidthChanged: { ++counter; }
+                    Rectangle {
+                        id: _r1
+                        implicitWidth: 20
+                        implicitHeight: 20
+                        Layout.fillWidth: true
+                        property int counter : 0
+                        onWidthChanged: { ++counter; }
+                    }
+                    Rectangle {
+                        id: _r2
+                        implicitWidth: 50
+                        implicitHeight: 50
+                        Layout.fillWidth: true
+                        property int counter : 0
+                        onWidthChanged: { ++counter; }
+                    }
+                    Rectangle {
+                        id: _r3
+                        implicitWidth: 40
+                        implicitHeight: 40
+                        Layout.fillWidth: true
+                        property int counter : 0
+                        onWidthChanged: { ++counter; }
+                    }
+                }
+                RowLayout {
+                    id: _row
+                    property alias r5: _r5
+                    spacing: 0
+                    property int counter : 0
+                    onWidthChanged: { ++counter; }
+                    Rectangle {
+                        id: _r5
+                        implicitWidth: 100
+                        implicitHeight: 100
+                        Layout.fillWidth: true
+                        property int counter : 0
+                        onWidthChanged: { ++counter; }
+                    }
+                }
+            }
+        }
+
+        function test_countGeometryChanges() {
+
+            var stack = countGeometryChanges_Component.createObject(container)
+            compare(stack.currentIndex, 0)
+            compare(stack.col.width, 100)
+            compare(stack.col.height, 110)
+            compare(stack.row.width, 100)
+            compare(stack.row.height, 100)
+            verify(stack.col.r1.counter <= 2)
+            compare(stack.col.r2.counter, 1)
+            verify(stack.col.r3.counter <= 2)
+            verify(stack.col.counter <= 2)
+            compare(stack.row.counter, 1)    // not visible, will only receive the initial geometry change
+            compare(stack.row.r5.counter, 0)
+            stack.destroy()
+        }
+
+        Component {
+            id: layoutItem_Component
+            Rectangle {
+                implicitWidth: 20
+                implicitHeight: 20
+            }
+        }
+
+        Component {
+            id: emtpy_StackLayout_Component
+            StackLayout {
+                property int num_onCountChanged: 0
+                property int num_onCurrentIndexChanged: 0
+                onCountChanged: { ++num_onCountChanged; }
+                onCurrentIndexChanged: { ++num_onCurrentIndexChanged; }
+            }
+        }
+
+        function test_addAndRemoveItems()
+        {
+            var stack = emtpy_StackLayout_Component.createObject(container)
+            stack.currentIndex = 2
+            compare(stack.implicitWidth, 0)
+            compare(stack.implicitHeight, 0)
+
+            var rect0 = layoutItem_Component.createObject(stack)
+            compare(stack.implicitWidth, 20)
+            compare(stack.implicitHeight, 20)
+            compare(rect0.visible, false)
+
+            var rect1 = layoutItem_Component.createObject(stack)
+            rect1.Layout.preferredWidth = 30
+            rect1.Layout.preferredHeight = 10
+            compare(stack.implicitWidth, 30)
+            compare(stack.implicitHeight, 20)
+            compare(rect0.visible, false)
+            compare(rect1.visible, false)
+
+            var rect2 = layoutItem_Component.createObject(stack)
+            rect2.x = 42    // ### items in a stacklayout will have their x and y positions discarded.
+            rect2.y = 42
+            rect2.Layout.preferredWidth = 80
+            rect2.Layout.preferredHeight = 30
+            rect2.Layout.fillWidth = true
+            compare(stack.implicitWidth, 80)
+            compare(stack.implicitHeight, 30)
+            compare(rect0.visible, false)
+            compare(rect1.visible, false)
+            compare(rect2.visible, true)
+            compare(geometry(rect2), geometry(stack))
+
+            rect2.destroy()
+            wait(0)     // this will hopefully effectuate the destruction of the object
+            compare(stack.implicitWidth, 30)
+            compare(stack.implicitHeight, 20)
+
+            rect0.destroy()
+            wait(0)
+            compare(stack.implicitWidth, 30)
+            compare(stack.implicitHeight, 10)
+
+            rect1.destroy()
+            wait(0)
+            compare(stack.implicitWidth, 0)
+            compare(stack.implicitHeight, 0)
+
+            stack.destroy()
+        }
+
+        function test_sizeHint_data() {
+            return [
+                    { tag: "propagateNone",            layoutHints: [10, 20, 30], childHints: [11, 21, 31], expected:[10, 20, Number.POSITIVE_INFINITY]},
+                    { tag: "propagateMinimumWidth",    layoutHints: [-1, 20, 30], childHints: [10, 21, 31], expected:[10, 20, Number.POSITIVE_INFINITY]},
+                    { tag: "propagatePreferredWidth",  layoutHints: [10, -1, 30], childHints: [11, 20, 31], expected:[10, 20, Number.POSITIVE_INFINITY]},
+                    { tag: "propagateMaximumWidth",    layoutHints: [10, 20, -1], childHints: [11, 21, 30], expected:[10, 20, Number.POSITIVE_INFINITY]},
+                    { tag: "propagateAll",             layoutHints: [-1, -1, -1], childHints: [10, 20, 30], expected:[10, 20, Number.POSITIVE_INFINITY]},
+                    { tag: "propagateCrazy",           layoutHints: [-1, -1, -1], childHints: [40, 21, 30], expected:[30, 30, Number.POSITIVE_INFINITY]},
+                    { tag: "expandMinToExplicitPref",  layoutHints: [-1,  1, -1], childHints: [11, 21, 31], expected:[ 1,  1, Number.POSITIVE_INFINITY]},
+                    { tag: "expandMaxToExplicitPref",  layoutHints: [-1, 99, -1], childHints: [11, 21, 31], expected:[11, 99, Number.POSITIVE_INFINITY]},
+                    { tag: "expandAllToExplicitMin",   layoutHints: [99, -1, -1], childHints: [11, 21, 31], expected:[99, 99, Number.POSITIVE_INFINITY]},
+                    { tag: "expandPrefToExplicitMin",  layoutHints: [24, -1, -1], childHints: [11, 21, 31], expected:[24, 24, Number.POSITIVE_INFINITY]},
+                    { tag: "boundPrefToExplicitMax",   layoutHints: [-1, -1, 19], childHints: [11, 21, 31], expected:[11, 19, Number.POSITIVE_INFINITY]},
+                    { tag: "boundAllToExplicitMax",    layoutHints: [-1, -1,  9], childHints: [11, 21, 31], expected:[ 9,  9, Number.POSITIVE_INFINITY]},
+                    ];
+        }
+
+        function itemSizeHints(item) {
+            return [item.Layout.minimumWidth, item.implicitWidth, item.Layout.maximumWidth]
+        }
+        Component {
+            id: stacklayout_sizeHint_Component
+            StackLayout {
+                property int implicitWidthChangedCount : 0
+                onImplicitWidthChanged: { ++implicitWidthChangedCount }
+                ColumnLayout {
+                    Rectangle {
+                        id: r1
+                        color: "red"
+                        Layout.minimumWidth: 1
+                        Layout.preferredWidth: 2
+                        Layout.maximumWidth: 3
+
+                        Layout.minimumHeight: 20
+                        Layout.preferredHeight: 20
+                        Layout.maximumHeight: 20
+                        Layout.fillWidth: true
+                    }
+                }
+            }
+        }
+
+        function test_sizeHint(data) {
+            var layout = stacklayout_sizeHint_Component.createObject(container)
+
+            var col = layout.children[0]
+            col.Layout.minimumWidth = data.layoutHints[0]
+            col.Layout.preferredWidth = data.layoutHints[1]
+            col.Layout.maximumWidth = data.layoutHints[2]
+
+            var child = col.children[0]
+            if (data.implicitWidth !== undefined) {
+                child.implicitWidth = data.implicitWidth
+            }
+            child.Layout.minimumWidth = data.childHints[0]
+            child.Layout.preferredWidth = data.childHints[1]
+            child.Layout.maximumWidth = data.childHints[2]
+
+            var effectiveSizeHintResult = [layout.Layout.minimumWidth, layout.implicitWidth, layout.Layout.maximumWidth]
+            compare(effectiveSizeHintResult, data.expected)
+            layout.destroy()
+        }
+
+        Component {
+            id: stacklayout_addIgnoredItem_Component
+            StackLayout {
+                Repeater {
+                    id: rep
+                    model: 1
+                    Rectangle {
+                        id: r
+                    }
+                }
+            }
+        }
+
+        // Items with no size information is ignored.
+        function test_addIgnoredItem()
+        {
+            var stack = stacklayout_addIgnoredItem_Component.createObject(container)
+            compare(stack.count, 1)
+            compare(stack.implicitWidth, 0)
+            compare(stack.implicitHeight, 0)
+            var r = stack.children[0]
+            r.Layout.preferredWidth = 20
+            r.Layout.preferredHeight = 30
+            compare(stack.count, 1)
+            compare(stack.implicitWidth, 20)
+            compare(stack.implicitHeight, 30)
+            stack.destroy();
+        }
+
+        function test_dontCrashWhenAnchoredToAWindow() {
+            var test_layoutStr =
+           'import QtQuick 2.2;                         \
+            import QtQuick.Window 2.1;                  \
+            import QtQuick.Layouts 1.3;                 \
+            Window {                                    \
+                visible: true;                          \
+                width: stack.implicitWidth;             \
+                height: stack.implicitHeight;           \
+                StackLayout {                           \
+                    id: stack;                          \
+                    currentIndex: 0;                    \
+                    anchors.fill: parent;               \
+                    Rectangle {                         \
+                        color: "red";                   \
+                        implicitWidth: 300;             \
+                        implicitHeight: 200;            \
+                    }                                   \
+                }                                       \
+            }                                           '
+
+            var lay = Qt.createQmlObject(test_layoutStr, container, '');
+            tryCompare(lay, 'width', 300);
+            lay.destroy()
+        }
+
+        Component {
+            id: test_dontCrashWhenChildIsResizedToNull_Component
+            StackLayout {
+                property alias rect : _rect
+                Rectangle {
+                    id: _rect;
+                    color: "red"
+                    implicitWidth: 200
+                    implicitHeight: 200
+                }
+            }
+        }
+
+        function test_dontCrashWhenChildIsResizedToNull() {
+            var layout = test_dontCrashWhenChildIsResizedToNull_Component.createObject(container)
+            layout.rect.width = 0
+            layout.width = 222      // trigger a rearrange with a valid size
+            layout.height = 222
+        }
+
+        Component {
+            id: test_currentIndex_Component
+            StackLayout {
+                currentIndex: 1
+                Text {
+                    text: "0"
+                }
+                Text {
+                    text: "1"
+                }
+            }
+        }
+
+        function test_currentIndex() {
+            var layout = test_currentIndex_Component.createObject(container)
+            var c0 = layout.children[0]
+            var c1 = layout.children[1]
+            compare(layout.currentIndex, 1)
+            tryCompare(layout, 'visible', true)
+            compare(c0.visible, false)
+            compare(c1.visible, true)
+            layout.currentIndex = 0
+            compare(c0.visible, true)
+            compare(c1.visible, false)
+            var c2 = layoutItem_Component.createObject(layout)
+            compare(c2.visible, false)
+
+            /*
+             * destroy the current item and check if visibility advances to next
+             */
+            c0.destroy()
+            tryCompare(c1, 'visible', true)
+            compare(c2.visible, false)
+            c1.destroy()
+            tryCompare(c2, 'visible', true)
+            c2.destroy()
+            tryCompare(layout, 'currentIndex', 0)
+
+            layout.destroy()
+
+            /*
+             * Test the default/implicit value of currentIndex, either -1 (if empty) or 0:
+             */
+            layout = emtpy_StackLayout_Component.createObject(container)
+            tryCompare(layout, 'visible', true)
+            compare(layout.currentIndex, -1)
+            compare(layout.num_onCurrentIndexChanged, 0)
+            // make it non-empty
+            c0 = layoutItem_Component.createObject(layout)
+            compare(layout.currentIndex, 0)
+            compare(layout.num_onCurrentIndexChanged, 1)
+            compare(c0.visible, true)
+            // make it empty again
+            c0.destroy()
+            wait(0)
+            compare(layout.currentIndex, -1)
+            //tryCompare(layout, 'currentIndex', -1)
+            compare(layout.num_onCurrentIndexChanged, 2)
+
+            /*
+             * Check that explicit value doesn't change,
+             * and that no items are visible if the index is invalid/out of range
+             */
+            layout.currentIndex = 2
+            compare(layout.currentIndex, 2)
+            compare(layout.num_onCurrentIndexChanged, 3)
+            c0 = layoutItem_Component.createObject(layout)
+            compare(layout.currentIndex, 2)
+            compare(c0.visible, false)
+
+            c1 = layoutItem_Component.createObject(layout)
+            compare(layout.currentIndex, 2)
+            compare(c0.visible, false)
+            compare(c1.visible, false)
+
+            c2 = layoutItem_Component.createObject(layout)
+            compare(layout.currentIndex, 2)
+            compare(c0.visible, false)
+            compare(c1.visible, false)
+            compare(c2.visible, true)
+
+            c2.destroy()
+            wait(0)
+            compare(layout.currentIndex, 2)
+            compare(c0.visible, false)
+            compare(c1.visible, false)
+            c1.destroy()
+            wait(0)
+            compare(layout.currentIndex, 2)
+            compare(c0.visible, false)
+            c0.destroy()
+            wait(0)
+            compare(layout.currentIndex, 2)
+            compare(layout.num_onCurrentIndexChanged, 3)
+        }
+
+        function test_count() {
+            var layout = emtpy_StackLayout_Component.createObject(container)
+            tryCompare(layout, 'visible', true)
+            compare(layout.count, 0)
+            compare(layout.currentIndex, -1)
+            compare(layout.num_onCountChanged, 0)
+            compare(layout.num_onCurrentIndexChanged, 0)
+            var c0 = layoutItem_Component.createObject(layout)
+            compare(layout.count, 1)
+            compare(layout.currentIndex, 0)
+            compare(layout.num_onCurrentIndexChanged, 1)
+            compare(layout.num_onCountChanged, 1)
+        }
+    }
+}