3 files changed, 262 insertions, 0 deletions
diff --git a/tests/auto/controls/data/tst_combobox.qml b/tests/auto/controls/data/tst_combobox.qml
index 0f1f0bdc..2d5069b3 100644
--- a/tests/auto/controls/data/tst_combobox.qml
+++ b/tests/auto/controls/data/tst_combobox.qml
@@ -1869,4 +1869,56 @@ TestCase {
         mouseRelease(control, control.leftPadding + control.contentItem.width, control.height / 2)
         compare(control.contentItem.selectedText, "Some text")
     }
+
+    // QTBUG-78885: When the edit text is changed on an editable ComboBox,
+    // and then that ComboBox loses focus, its currentIndex should change
+    // to the index of the edit text (assuming a match is found).
+    function test_currentIndexChangeOnLostFocus() {
+        if (Qt.styleHints.tabFocusBehavior !== Qt.TabFocusAllControls)
+            skip("This platform only allows tab focus for text controls")
+
+        let theModel = []
+        for (let i = 0; i < 10; ++i)
+            theModel.push("Item " + (i + 1))
+
+        let comboBox1 = createTemporaryObject(comboBox, testCase,
+            { objectName: "comboBox1", editable: true, model: theModel })
+        verify(comboBox1)
+        compare(comboBox1.currentIndex, 0)
+
+        let comboBox2 = createTemporaryObject(comboBox, testCase, { objectName: "comboBox2" })
+        verify(comboBox2)
+
+        // Give the first ComboBox focus and type in 0 to select "Item 10" (default is "Item 1").
+        waitForRendering(comboBox1)
+        comboBox1.forceActiveFocus()
+        verify(comboBox1.activeFocus)
+        keyClick(Qt.Key_0)
+        compare(comboBox1.editText, "Item 10")
+
+        let currentIndexSpy = signalSpy.createObject(comboBox1,
+            { target: comboBox1, signalName: "currentIndexChanged" })
+        verify(currentIndexSpy.valid)
+
+        // Give focus to the other ComboBox so that the first one loses it.
+        // The first ComboBox's currentIndex should change to that of "Item 10".
+        keyClick(Qt.Key_Tab)
+        verify(comboBox2.activeFocus)
+        compare(comboBox1.currentIndex, 9)
+        compare(currentIndexSpy.count, 1)
+
+        // Give focus back to the first ComboBox, and try the same thing except
+        // with non-existing text; the currentIndex should not change.
+        comboBox1.forceActiveFocus()
+        verify(comboBox1.activeFocus)
+        keySequence(StandardKey.SelectAll)
+        compare(comboBox1.contentItem.selectedText, "Item 10")
+        keyClick(Qt.Key_N)
+        keyClick(Qt.Key_O)
+        keyClick(Qt.Key_P)
+        keyClick(Qt.Key_E)
+        compare(comboBox1.editText, "nope")
+        compare(comboBox1.currentIndex, 9)
+        compare(currentIndexSpy.count, 1)
+    }
 }
diff --git a/tests/auto/controls/data/tst_splitview.qml b/tests/auto/controls/data/tst_splitview.qml
index c125b99e..74e4c68e 100644
--- a/tests/auto/controls/data/tst_splitview.qml
+++ b/tests/auto/controls/data/tst_splitview.qml
@@ -2026,4 +2026,55 @@ TestCase {
         compare(control.repeater.count, 3)
         compare(control.contentChildren.length, 3)
     }
+
+    Component {
+        id: hoverableChildrenSplitViewComponent
+
+        SplitView {
+            handle: handleComponent
+            anchors.fill: parent
+
+            MouseArea {
+                objectName: "mouseArea1"
+                hoverEnabled: true
+
+                SplitView.preferredWidth: 200
+            }
+            MouseArea {
+                objectName: "mouseArea2"
+                hoverEnabled: true
+            }
+        }
+    }
+
+    function test_hoverableChilden() {
+        if (Qt.platform.pluginName === "offscreen" || Qt.platform.pluginName === "minimal")
+            skip("Mouse hovering not functional on offscreen/minimal platforms")
+
+        var control = createTemporaryObject(hoverableChildrenSplitViewComponent, testCase)
+        verify(control)
+
+        verify(isPolishScheduled(control))
+        verify(waitForItemPolished(control))
+
+        // Move the mouse over the handle.
+        var handles = findHandles(control)
+        var targetHandle = handles[0]
+        // Test fails if we don't do two moves for some reason...
+        mouseMove(targetHandle, targetHandle.width / 2, targetHandle.height / 2)
+        mouseMove(targetHandle, targetHandle.width / 2, targetHandle.height / 2)
+        verify(targetHandle.SplitHandle.hovered)
+
+        // Move the mouse to the MouseArea on the left. The handle should no longer be hovered.
+        mouseMove(control, 100, control.height / 2)
+        verify(!targetHandle.SplitHandle.hovered)
+
+        // Move the mouse back over the handle.
+        mouseMove(targetHandle, targetHandle.width / 2, targetHandle.height / 2)
+        verify(targetHandle.SplitHandle.hovered)
+
+        // Move the mouse to the MouseArea on the right. The handle should no longer be hovered.
+        mouseMove(control, control.width - 100, control.height / 2)
+        verify(!targetHandle.SplitHandle.hovered)
+    }
 }
diff --git a/tests/auto/controls/data/tst_stackview.qml b/tests/auto/controls/data/tst_stackview.qml
index a9fbf874..c15ce8ea 100644
--- a/tests/auto/controls/data/tst_stackview.qml
+++ b/tests/auto/controls/data/tst_stackview.qml
@@ -1245,4 +1245,163 @@ TestCase {
         gc()
         verify(control.initialItem)
     }
+
+    // Need to use this specific structure in order to reproduce the crash.
+    Component {
+        id: clearUponDestructionContainerComponent
+
+        Item {
+            id: container
+            objectName: "container"
+
+            property alias control: stackView
+            property var onDestructionCallback
+
+            property Component clearUponDestructionComponent: Component {
+                id: clearUponDestructionComponent
+
+                Item {
+                    objectName: "clearUponDestructionItem"
+                    Component.onDestruction: container.onDestructionCallback(stackView)
+                }
+            }
+
+            StackView {
+                id: stackView
+                initialItem: Item {
+                    objectName: "initialItem"
+                }
+            }
+        }
+    }
+
+    // QTBUG-80353
+    // Tests that calling clear() in Component.onDestruction in response to that
+    // item being removed (e.g. via an earlier call to clear()) results in a warning and not a crash.
+    function test_recursiveClearClear() {
+        let container = createTemporaryObject(clearUponDestructionContainerComponent, testCase,
+            { onDestructionCallback: function(stackView) { stackView.clear(StackView.Immediate) }})
+        verify(container)
+
+        let control = container.control
+        control.push(container.clearUponDestructionComponent, StackView.Immediate)
+
+        // Shouldn't crash.
+        ignoreWarning(new RegExp(".*cannot clear while already in the process of removing elements"))
+        control.clear(StackView.Immediate)
+    }
+
+    function test_recursivePopClear() {
+        let container = createTemporaryObject(clearUponDestructionContainerComponent, testCase,
+            { onDestructionCallback: function(stackView) { stackView.clear(StackView.Immediate) }})
+        verify(container)
+
+        let control = container.control
+        control.push(container.clearUponDestructionComponent, StackView.Immediate)
+
+        // Pop all items except the first, removing the second item we pushed in the process.
+        // Shouldn't crash.
+        ignoreWarning(new RegExp(".*cannot clear while already in the process of removing elements"))
+        control.pop(null, StackView.Immediate)
+    }
+
+    function test_recursivePopPop() {
+        let container = createTemporaryObject(clearUponDestructionContainerComponent, testCase,
+            { onDestructionCallback: function(stackView) { stackView.pop(null, StackView.Immediate) }})
+        verify(container)
+
+        let control = container.control
+        // Push an extra item so that we can call pop(null) and reproduce the conditions for the crash.
+        control.push(component, StackView.Immediate)
+        control.push(container.clearUponDestructionComponent, StackView.Immediate)
+
+        // Pop the top item, then pop down to the first item in response.
+        ignoreWarning(new RegExp(".*cannot pop while already in the process of removing elements"))
+        control.pop(StackView.Immediate)
+    }
+
+    function test_recursiveReplaceClear() {
+        let container = createTemporaryObject(clearUponDestructionContainerComponent, testCase,
+            { onDestructionCallback: function(stackView) { stackView.clear(StackView.Immediate) }})
+        verify(container)
+
+        let control = container.control
+        control.push(container.clearUponDestructionComponent, StackView.Immediate)
+
+        // Replace the top item, then clear in response.
+        ignoreWarning(new RegExp(".*cannot clear while already in the process of removing elements"))
+        control.replace(component, StackView.Immediate)
+    }
+
+    function test_recursiveClearReplace() {
+        let container = createTemporaryObject(clearUponDestructionContainerComponent, testCase,
+            { onDestructionCallback: function(stackView) { stackView.replace(component, StackView.Immediate) }})
+        verify(container)
+
+        let control = container.control
+        control.push(container.clearUponDestructionComponent, StackView.Immediate)
+
+        // Replace the top item, then clear in response.
+        ignoreWarning(new RegExp(".*cannot replace while already in the process of removing elements"))
+        control.clear(StackView.Immediate)
+    }
+
+    Component {
+        id: rectangleComponent
+        Rectangle {}
+    }
+
+    Component {
+        id: qtbug57267_StackViewComponent
+
+        StackView {
+            id: stackView
+
+            popEnter: Transition {
+                XAnimator { from: (stackView.mirrored ? -1 : 1) * -stackView.width; to: 0; duration: 400; easing.type: Easing.Linear }
+            }
+            popExit: Transition {
+                XAnimator { from: 0; to: (stackView.mirrored ? -1 : 1) * stackView.width; duration: 400; easing.type: Easing.Linear }
+            }
+            pushEnter: Transition {
+                XAnimator { from: (stackView.mirrored ? -1 : 1) * stackView.width; to: 0; duration: 400; easing.type: Easing.Linear }
+            }
+            pushExit: Transition {
+                XAnimator { from: 0; to: (stackView.mirrored ? -1 : 1) * -stackView.width; duration: 400; easing.type: Easing.Linear }
+            }
+            replaceEnter: Transition {
+                XAnimator { from: (stackView.mirrored ? -1 : 1) * stackView.width; to: 0; duration: 400; easing.type: Easing.Linear }
+            }
+            replaceExit: Transition {
+                XAnimator { from: 0; to: (stackView.mirrored ? -1 : 1) * -stackView.width; duration: 400; easing.type: Easing.Linear }
+            }
+        }
+    }
+
+    function test_qtbug57267() {
+        let redRect = createTemporaryObject(rectangleComponent, testCase, { color: "red" })
+        verify(redRect)
+        let blueRect = createTemporaryObject(rectangleComponent, testCase, { color: "blue" })
+        verify(blueRect)
+        let control = createTemporaryObject(qtbug57267_StackViewComponent, testCase,
+            { "anchors.fill": testCase, initialItem: redRect })
+        verify(control)
+
+        control.replace(blueRect)
+        compare(control.currentItem, blueRect)
+        compare(control.depth, 1)
+
+        // Wait until the animation has started and then interrupt it by pushing the redRect.
+        tryCompare(control, "busy", true)
+        control.replace(redRect)
+        // The blue rect shouldn't be visible since we replaced it and therefore interrupted its animation.
+        tryCompare(blueRect, "visible", false)
+        // We did the replace very early on, so the transition for the redRect should still be happening.
+        compare(control.busy, true)
+        compare(redRect.visible, true)
+
+        // After finishing the transition, the red rect should still be visible.
+        tryCompare(control, "busy", false)
+        compare(redRect.visible, true)
+    }
 }