Improve state handling

This is an attempt to clean up and make the state changes more sane,
i.e., by trying do everything once and in the right order. There are
still ugliness in this code, but it should be more easily to follow now,
aided by extra inline commentary. This change should also improve some
of the flickering seen in some examples when changing slides, as we try
avoid re-setting stuff when we don't need to.

Since time updates for the new slide is deferred until the first time
callback, some of the test needed to be changed to their QTRY_* version.

Also, there's now a clear distinction between stopped and paused, where
paused means the slides progress is stopped at time t, as expected and
stopped means the slides values and state is reset to it's initial state.

Task-number: QT3DS-1866
Change-Id: I7a9b61ee3ad4a976e0e8d4de386704dcf0d526bf
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

5 files changed, 380 insertions, 401 deletions

diff --git a/src/runtime/q3dsanimationmanager.cpp b/src/runtime/q3dsanimationmanager.cpp
index 6a33cae..e6bba81 100644
--- a/src/runtime/q3dsanimationmanager.cpp
+++ b/src/runtime/q3dsanimationmanager.cpp
@@ -475,7 +475,7 @@ void Q3DSAnimationManager::clearAnimations(Q3DSSlide *slide)
         // Remove all other animatiors that was associated with this slide
         Q3DSSlideAttached *slideAttached = static_cast<Q3DSSlideAttached *>(slide->attached());
         for (auto animator : slideAttached->animators) {
-            Q_ASSERT(!animator->isRunning());
+            animator->stop();
             slideAttached->entity->removeComponent(animator);
             delete animator;
         }
diff --git a/src/runtime/q3dsslideplayer.cpp b/src/runtime/q3dsslideplayer.cpp
index ddb81f2..81d04b0 100644
--- a/src/runtime/q3dsslideplayer.cpp
+++ b/src/runtime/q3dsslideplayer.cpp
@@ -66,7 +66,11 @@ public:
         if (!slidePlayer)
             return;
 
-        slidePlayer->setSlideTime(m_slide, newValue * 1000.0f);
+        slidePlayer->flushQueuedChanges();
+
+        const float newTime = newValue * 1000.0f;
+        slidePlayer->setSlideTime(static_cast<Q3DSSlide *>(m_slide->parent()), newTime);
+        slidePlayer->setSlideTime(m_slide, newTime);
         m_previousValue = newValue;
     }
 
@@ -128,7 +132,7 @@ static void detatchPositionCallback(Q3DSSlide *slide)
     Q3DSSlideAttached *data = slide->attached<Q3DSSlideAttached>();
     auto animator = data->animator;
     if (animator) {
-        Q_ASSERT(!animator->isRunning());
+        animator->stop();
         slide->attached()->entity->removeComponent(animator);
         // TODO: Figure out why this is needed.
         data->animator = nullptr;
@@ -216,6 +220,20 @@ void Q3DSSlideUtils::getStartAndEndTime(Q3DSSlide *slide, qint32 *startTime, qin
         *endTime = layerEndTime != -1 ? layerEndTime : nodesEndtime;
 }
 
+// NOTE: This will skip components that are marked as disabled!!!
+static void forAllSlideComponents(Q3DSSlide *slide, std::function<void (Q3DSComponentNode *)> fn)
+{
+    if (slide) {
+        const auto &objects = slide->objects();
+        auto it = objects.cbegin();
+        while (it != objects.cend()) {
+            if ((*it)->type() == Q3DSGraphObject::Component && (*it)->state() == Q3DSGraphObject::Enabled)
+                fn(static_cast<Q3DSComponentNode *>(*it));
+            ++it;
+        }
+    }
+}
+
 static QString getSlideName(Q3DSSlide *slide)
 {
     return slide ? slide->name() : QStringLiteral("nullptr");
@@ -352,37 +370,11 @@ void Q3DSSlidePlayer::sceneReady()
     Q_ASSERT(currentSlide);
 
     const bool viewerMode = (m_mode == PlayerMode::Viewer);
-    if (viewerMode && (currentSlide->initialPlayState() == Q3DSSlide::Play))
+
+    if (viewerMode && m_type == PlayerType::Slide && (currentSlide->initialPlayState() == Q3DSSlide::Play))
         play();
     else
         pause();
-
-    // In viewer-mode we need to go through all components players as well
-    if (viewerMode) {
-        static const auto notifyComponentPlayers = [](Q3DSSlide *slide) {
-            if (!slide)
-                return;
-
-            const auto &objects = slide->objects();
-            std::find_if(objects.constBegin(), objects.constEnd(), [](Q3DSGraphObject *obj) {
-                if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
-                    Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
-                    Q3DSSlide *compSlide = comp->masterSlide();
-                    Q3DSSlidePlayer *player = compSlide->attached<Q3DSSlideAttached>()->slidePlayer;
-                    player->sceneReady();
-                }
-                return false;
-            });
-        };
-
-        Q3DSSlide *slide = m_data.slideDeck->masterSlide();
-        notifyComponentPlayers(slide);
-        slide = static_cast<Q3DSSlide *>(slide->firstChild());
-        while (slide) {
-            notifyComponentPlayers(slide);
-            slide = static_cast<Q3DSSlide *>(slide->nextSibling());
-        }
-    }
 }
 
 float Q3DSSlidePlayer::duration() const
@@ -404,27 +396,18 @@ void Q3DSSlidePlayer::setMode(Q3DSSlidePlayer::PlayerMode mode)
     if (!m_data.slideDeck)
         return;
 
-    const auto notifyComponentPlayers = [mode](Q3DSSlide *slide) {
-        if (!slide)
-            return;
 
-        const auto &objects = slide->objects();
-        std::find_if(objects.constBegin(), objects.constEnd(), [mode](Q3DSGraphObject *obj) {
-            if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
-                Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
-                Q3DSSlide *compSlide = comp->masterSlide();
-                Q3DSSlidePlayer *player = compSlide->attached<Q3DSSlideAttached>()->slidePlayer;
-                player->setMode(mode);
-            }
-            return false;
-        });
+    const auto callSetMode = [mode](Q3DSComponentNode *comp) {
+        Q3DSSlide *compSlide = comp->masterSlide();
+        Q3DSSlidePlayer *player = compSlide->attached<Q3DSSlideAttached>()->slidePlayer;
+        player->setMode(mode);
     };
 
     Q3DSSlide *slide = m_data.slideDeck->masterSlide();
-    notifyComponentPlayers(slide);
+    forAllSlideComponents(slide, callSetMode);
     slide = static_cast<Q3DSSlide *>(slide->firstChild());
     while (slide) {
-        notifyComponentPlayers(slide);
+        forAllSlideComponents(slide, callSetMode);
         slide = static_cast<Q3DSSlide *>(slide->nextSibling());
     }
 
@@ -436,7 +419,7 @@ void Q3DSSlidePlayer::play()
     if (m_data.state == PlayerState::Playing)
         return;
 
-    if (m_data.state == PlayerState::Idle) {
+    if (m_data.state == PlayerState::Idle && !m_data.slideDeck) {
         qCWarning(lcSlidePlayer) << "Play called in Idle state (no content)";
         return;
     }
@@ -456,7 +439,7 @@ void Q3DSSlidePlayer::play()
 
 void Q3DSSlidePlayer::stop()
 {
-    if (m_data.state == PlayerState::Idle) {
+    if (m_data.state == PlayerState::Idle && !m_data.slideDeck) {
         qCWarning(lcSlidePlayer) << "Stop called in Idle state (no content)";
         return;
     }
@@ -472,10 +455,6 @@ void Q3DSSlidePlayer::stop()
     }
 
     setInternalState(PlayerState::Stopped);
-    // NOTE: We force an update here to make sure we don't get stale updates from
-    // from Qt3D, this way we can properly rollback the animatables to their initial values.
-    updatePosition(currentSlide, 0.0f, duration());
-    handleCurrentSlideChanged(currentSlide, currentSlide, true);
 }
 
 void Q3DSSlidePlayer::pause()
@@ -483,7 +462,7 @@ void Q3DSSlidePlayer::pause()
     if (m_data.state == PlayerState::Paused)
         return;
 
-    if (m_data.state == PlayerState::Idle) {
+    if (m_data.state == PlayerState::Idle && !m_data.slideDeck) {
         qCWarning(lcSlidePlayer) << "Pause called in Idle state (no content)";
         return;
     }
@@ -590,7 +569,6 @@ void Q3DSSlidePlayer::setSlideDeck(Q3DSSlideDeck *slideDeck)
 
     forAllSlides(slideDeck);
 
-    setInternalState(PlayerState::Ready);
     Q_EMIT slideDeckChanged(m_data.slideDeck);
 }
 
@@ -637,9 +615,7 @@ void Q3DSSlidePlayer::precedingSlide()
 
 void Q3DSSlidePlayer::reload()
 {
-    setInternalState(PlayerState::Stopped);
-    if (m_mode == PlayerMode::Viewer)
-        setInternalState(getInitialSlideState(m_data.slideDeck->currentSlide()));
+    setInternalState((m_mode == PlayerMode::Viewer) ? getInitialSlideState(m_data.slideDeck->currentSlide()) : PlayerState::Paused);
 }
 
 Q3DSSlidePlayer::Q3DSSlidePlayer(QSharedPointer<Q3DSAnimationManager> animationManager,
@@ -677,18 +653,23 @@ void Q3DSSlidePlayer::setInternalState(Q3DSSlidePlayer::PlayerState state)
     Q3DSSlide *previousSlide = (m_type == PlayerType::Slide) ? m_sceneManager->currentSlide()
                                                              : m_component->currentSlide();
 
-    if (state == PlayerState::Idle) {
+    // When going from Idle to X there's no previous slide, so correct the
+    // findings above to reflect that...
+    if ((m_data.state == PlayerState::Idle) && (m_data.pendingState != PlayerState::Idle))
+        previousSlide = nullptr;
+
+    if (state == PlayerState::Idle) { // If the state is set to idle, we want to clean-up and leave
         handleCurrentSlideChanged(nullptr, previousSlide);
         if (m_data.slideDeck)
             delete m_data.slideDeck;
         m_data = Data();
+        Q_EMIT stateChanged(m_data.state);
         return;
     }
 
     const bool slideChanged = (previousSlide != currentSlide);
-    const bool forceUpdate = (!slideChanged && (state == PlayerState::Ready));
-    if (slideChanged || forceUpdate)
-        handleCurrentSlideChanged(currentSlide, previousSlide, forceUpdate);
+    if (slideChanged || (m_data.state == PlayerState::Stopped && state != PlayerState::Stopped))
+        handleCurrentSlideChanged(currentSlide, previousSlide);
 
     if (state == PlayerState::Playing) {
         const bool restart = (m_mode == PlayerMode::Viewer)
@@ -696,7 +677,8 @@ void Q3DSSlidePlayer::setInternalState(Q3DSSlidePlayer::PlayerState state)
                              && (m_data.state != PlayerState::Paused);
         updateAnimators(currentSlide, true, restart, m_data.playbackRate);
     } else if (state == PlayerState::Stopped) {
-        updateAnimators(currentSlide, false, false, m_data.playbackRate);
+        // Reset the slide, but avoid emitting slideChanged signal.
+        handleCurrentSlideChanged(currentSlide, currentSlide);
     } else if (state == PlayerState::Paused) {
         updateAnimators(currentSlide, false, false, m_data.playbackRate);
     }
@@ -707,119 +689,116 @@ void Q3DSSlidePlayer::setInternalState(Q3DSSlidePlayer::PlayerState state)
     }
 }
 
-void Q3DSSlidePlayer::handleCurrentSlideChanged(Q3DSSlide *slide,
-                                                Q3DSSlide *previousSlide,
-                                                bool forceUpdate)
+void Q3DSSlidePlayer::handleCurrentSlideChanged(Q3DSSlide *slide, Q3DSSlide *previousSlide)
 {
-    const bool slideDidChange = (previousSlide != slide) || forceUpdate;
-    const bool parentChanged = [previousSlide, slide, forceUpdate]() -> bool {
-        if (forceUpdate)
-            return true;
+    const bool parentChanged = (previousSlide && slide && previousSlide->parent() != slide->parent())
+                               || (!previousSlide && slide) || (previousSlide && !slide);
+
+    // Helper function to update all components on a slide
+    static const auto stopComponent = [](Q3DSComponentNode *comp) {
+        Q3DSSlide *compSlide = comp->currentSlide();
+        Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
+        data->slidePlayer->setInternalState(PlayerState::Stopped);
+    };
 
-        auto parent = slide ? slide->parent() : nullptr;
-        auto pparent = previousSlide ? previousSlide->parent() : nullptr;
-        return (parent != pparent);
-    }();
+    static const auto startComponent = [](Q3DSComponentNode *comp) {
+        Q3DSSlide *compSlide = comp->currentSlide();
+        Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
+        Q3DSSlidePlayer *player = data->slidePlayer;
+        const PlayerState state = (player->mode() == PlayerMode::Viewer) ? getInitialSlideState(compSlide) : PlayerState::Paused;
+        player->setInternalState(state);
+    };
+
+    const auto queueSlideEvent = [this](Q3DSSlide *slide, const QString &evName) {
+        Q3DSGraphObject *eventTarget = m_sceneManager->m_scene;
+        if (m_type != PlayerType::Slide)
+            eventTarget = m_component;
+
+        const QVariantList args {
+            QVariant::fromValue(slide),
+            m_data.slideDeck->indexOfSlide(slide->id())
+        };
+
+        const Q3DSGraphObject::Event ev(eventTarget, evName, { QVariant::fromValue(slide), m_data.slideDeck->indexOfSlide(slide->id())});
+        m_sceneManager->queueEvent(ev);
+    };
 
     qCDebug(lcSlidePlayer, "Handling current slide change: from slide \"%s\", to slide \"%s\"",
             qPrintable(getSlideName(previousSlide)), qPrintable(getSlideName(slide)));
 
-    static const auto cleanUpComponentPlayers = [](Q3DSSlide *slide) {
-        if (!slide)
-            return;
+    // --------------------------------------------------------------------------------------------
+
+    m_queuedChanges.clear();
+
+    // 1. Stop the previous slide, notify all its components to stop and hide associated objects.
+    if (previousSlide) {
+        forAllSlideComponents(previousSlide, stopComponent);
 
-        const auto &objects = slide->objects();
-        std::find_if(objects.constBegin(), objects.constEnd(), [](Q3DSGraphObject *obj) {
-            if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
-                Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
-                Q3DSSlide *compSlide = comp->currentSlide();
-                Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
-                data->slidePlayer->handleCurrentSlideChanged(nullptr, compSlide);
-            }
-            return false;
-        });
-    };
-    if (previousSlide && slideDidChange) {
-        cleanUpComponentPlayers(previousSlide);
         Q3DSSlideAttached *data = previousSlide->attached<Q3DSSlideAttached>();
         if (data && data->animator) {
-            // TODO: We probably want to be a bit less brute.
-            if (slide) Q_ASSERT(previousSlide->parent() == slide->parent());
-            updateAnimators(previousSlide, false, false, 1.0f);
             detatchPositionCallback(previousSlide);
             m_animationManager->clearAnimations(previousSlide);
         }
-        if (parentChanged)
-            cleanUpComponentPlayers(static_cast<Q3DSSlide *>(previousSlide->parent()));
 
-        setSlideTime(previousSlide, -1.0f, true);
+        m_queuedChanges.push_back([this, previousSlide]() { setSlideTime(previousSlide, -1.0f, true); });
+
+        queueSlideEvent(previousSlide, Q3DSGraphObjectEvents::slideExitEvent());
     }
 
-    if (slide && slideDidChange && isSlideVisible(slide)) {
-        setSlideTime(slide, 0.0f, true);
-        processPropertyChanges(slide, previousSlide);
-        attatchPositionCallback(slide);
-        m_animationManager->updateAnimations(slide, (m_mode == PlayerMode::Editor));
+    // 2. Apply properties for this slide (update eyeball values and keep values for dynamic kf. etc.).
+    if (slide) {
+        // A bit crude, but whatever
+        if (m_type == PlayerType::Slide)
+            m_sceneManager->m_currentSlide = slide;
+        else
+            m_component->setCurrentSlide(slide);
 
-        Q3DSGraphObject *eventTarget = m_sceneManager->m_scene;
-        if (m_type != PlayerType::Slide)
-            eventTarget = m_component;
+        processPropertyChanges(slide, previousSlide);
+    }
 
+    // 3. If the parent Changed stop/start, and update components and objects ad needed
+    if (parentChanged) {
         if (previousSlide) {
-            const QVariantList args {
-                QVariant::fromValue(previousSlide),
-                m_data.slideDeck->indexOfSlide(previousSlide->id())
-            };
-            m_sceneManager->queueEvent(Q3DSGraphObject::Event(eventTarget,
-                                                              Q3DSGraphObjectEvents::slideExitEvent(),
-                                                              args));
+            Q3DSSlide *parent = static_cast<Q3DSSlide *>(previousSlide->parent());
+            forAllSlideComponents(parent, stopComponent);
+            m_queuedChanges.push_back([this, parent]() { setSlideTime(parent, -1.0f, true); });
         }
 
-        if (slide) {
-            const QVariantList args {
-                QVariant::fromValue(slide),
-                m_data.slideDeck->indexOfSlide(slide->id())
-            };
-            m_sceneManager->queueEvent(Q3DSGraphObject::Event(eventTarget,
-                                                              Q3DSGraphObjectEvents::slideEnterEvent(),
-                                                              args));
+        if (slide && (m_data.pendingState != PlayerState::Stopped)) {
+            Q3DSSlide *parent = static_cast<Q3DSSlide *>(slide->parent());
+            forAllSlideComponents(parent, startComponent);
+            if (m_data.pendingState != PlayerState::Playing)
+                m_queuedChanges.push_back([this, parent]() { setSlideTime(parent, 0.0f, true); });
         }
+    }
 
-        // A bit crude, but whatever
-        if (m_type == PlayerType::Slide)
-            m_sceneManager->m_currentSlide = slide;
-        else
-            m_component->setCurrentSlide(slide);
-
-        m_sceneManager->syncScene();
+    // 4. Now set-up the animations and notify
+    //    any components on this slide to do the same.
+    if (slide && (m_data.pendingState != PlayerState::Stopped)) {
+        attatchPositionCallback(slide);
+        m_animationManager->updateAnimations(slide, (m_mode == PlayerMode::Editor));
 
         qint32 startTime = 0;
         qint32 endTime = 0;
         Q3DSSlideUtils::getStartAndEndTime(slide, &startTime, &endTime);
         onDurationChanged(endTime - startTime);
 
-        static const auto updateComponentSlides = [](Q3DSSlide *slide) {
-            if (!slide)
-                return;
-            const auto &objects = slide->objects();
-            std::find_if(objects.constBegin(), objects.constEnd(), [](Q3DSGraphObject *obj) {
-                if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
-                    Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
-                    Q3DSSlide *compSlide = comp->currentSlide();
-                    Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
-                    data->slidePlayer->handleCurrentSlideChanged(compSlide, nullptr);
-                    if (data->slidePlayer->m_mode == PlayerMode::Viewer)
-                        data->slidePlayer->setInternalState(getInitialSlideState(compSlide));
-                }
-                return false;
-            });
-        };
-        if (parentChanged)
-            updateComponentSlides(static_cast<Q3DSSlide *>(slide->parent()));
-        updateComponentSlides(slide);
+        queueSlideEvent(slide, Q3DSGraphObjectEvents::slideEnterEvent());
+
+        forAllSlideComponents(slide, startComponent);
+        if (m_data.pendingState != PlayerState::Playing)
+            m_queuedChanges.push_back([this, slide]() { setSlideTime(slide, 0.0f, true); });
+    }
+
+    // If the player isn't playing then make the time updates valid now.
+    // If this is the top scene player also sync the scene.
+    if (m_data.pendingState != PlayerState::Playing) {
+        flushQueuedChanges();
+        if (m_type == PlayerType::Slide)
+            m_sceneManager->syncScene();
     }
 
-    if (previousSlide != slide)
+    if ((m_data.pendingState != PlayerState::Stopped) && (previousSlide != slide))
         Q_EMIT slideChanged(slide);
 }
 
@@ -849,16 +828,20 @@ void Q3DSSlidePlayer::setSlideTime(Q3DSSlide *slide, float time, bool forceUpdat
             parentVisible = (m_component->attached()->visibilityTag == Q3DSGraphObjectAttached::Visible);
     }
 
-    const auto updateObjects = [=](Q3DSSlide *s) {
-        if (!s)
-            return;
+    for (Q3DSGraphObject *obj : slide->objects())
+        setObjectVisibility(obj, parentVisible, forceUpdate, time);
 
-        for (Q3DSGraphObject *obj : s->objects())
-            setObjectVisibility(obj, parentVisible, forceUpdate, time);
-    };
-
-    updateObjects(static_cast<Q3DSSlide *>(slide->parent()));
-    updateObjects(slide);
+    forAllSlideComponents(slide, [forceUpdate](Q3DSComponentNode *component) {
+        Q3DSSlide *componentCurrentSlide = component->currentSlide();
+        Q3DSSlidePlayer *player = componentCurrentSlide->attached<Q3DSSlideAttached>()->slidePlayer;
+        // If the component is not playing it won't get time updates, so to ensure it correctly
+        // updates its visibility we tell it to update with time from its last time update.
+        if (player->state() != PlayerState::Idle && player->state() != PlayerState::Playing) {
+            const float lastTime = player->position();
+            player->setSlideTime(component->masterSlide(), lastTime, forceUpdate);
+            player->setSlideTime(component->currentSlide(), lastTime, forceUpdate);
+        }
+    });
 
     // This method is called for all slides, but we only want to update the
     // position for the associated slide player once
@@ -868,6 +851,15 @@ void Q3DSSlidePlayer::setSlideTime(Q3DSSlide *slide, float time, bool forceUpdat
     sendPositionChanged(slide, time);
 }
 
+void Q3DSSlidePlayer::flushQueuedChanges()
+{
+    if (!m_queuedChanges.isEmpty()) {
+        for (const auto &fn : qAsConst(m_queuedChanges))
+            fn();
+        m_queuedChanges.clear();
+    }
+}
+
 void Q3DSSlidePlayer::setObjectVisibility(Q3DSGraphObject *obj, bool parentVisible, bool forceUpdate, float time)
 {
     if (obj->state() != Q3DSGraphObject::Enabled)
@@ -897,18 +889,6 @@ void Q3DSSlidePlayer::setObjectVisibility(Q3DSGraphObject *obj, bool parentVisib
 
     if (forceUpdate || shouldBeVisible != objectHasVisibilityTag(obj))
         updateObjectVisibility(obj, shouldBeVisible, time);
-
-    if (obj->type() == Q3DSGraphObject::Component) {
-        Q3DSComponentNode *component = static_cast<Q3DSComponentNode *>(obj);
-        Q3DSSlide *componentCurrentSlide = component->currentSlide();
-        Q3DSSlidePlayer *player = componentCurrentSlide->attached<Q3DSSlideAttached>()->slidePlayer;
-        // If the component is not playing it won't get time updates, so to ensure it correctly
-        // updates its visibility we tell it to update with time from its last time update.
-        if (player->state() != PlayerState::Idle && player->state() != PlayerState::Playing) {
-            const float lastTime = player->position();
-            player->setSlideTime(componentCurrentSlide, lastTime, forceUpdate);
-        }
-    }
 }
 
 void Q3DSSlidePlayer::sendPositionChanged(Q3DSSlide *slide, float pos)
@@ -1054,14 +1034,14 @@ void Q3DSSlidePlayer::onSlideFinished(Q3DSSlide *slide)
 
     // We don't change slides automatically in Editor mode
     if (m_mode == PlayerMode::Editor) {
-        setInternalState(PlayerState::Stopped);
+        setInternalState(PlayerState::Paused);
         return;
     }
 
     // Get the slide's play mode
     const auto playMode = slide->playMode();
 
-    PlayerState state = PlayerState::Stopped;
+    PlayerState state = PlayerState::Paused;
 
     switch (playMode) {
     case Q3DSSlide::Looping:
@@ -1097,7 +1077,7 @@ void Q3DSSlidePlayer::onSlideFinished(Q3DSSlide *slide)
         } else {
             m_data.loopCount = 0;
             m_data.playbackRate = rate;
-            state = PlayerState::Stopped;
+            state = PlayerState::Paused;
         }
     }
         break;
@@ -1109,7 +1089,7 @@ void Q3DSSlidePlayer::onSlideFinished(Q3DSSlide *slide)
     }
         break;
     case Q3DSSlide::StopAtEnd:
-        state = PlayerState::Stopped;
+        state = PlayerState::Paused;
         break;
     }
 
diff --git a/src/runtime/q3dsslideplayer_p.h b/src/runtime/q3dsslideplayer_p.h
index baddb25..2e8b637 100644
--- a/src/runtime/q3dsslideplayer_p.h
+++ b/src/runtime/q3dsslideplayer_p.h
@@ -69,9 +69,9 @@ public:
     {
         Idle,
         Ready,
-        Stopped,
+        Stopped, // Stopped means the player and it's slides are reset to the starting point.
         Playing,
-        Paused
+        Paused // Paused means the state it paused at time t, this is also true for "stopAtEnd" with t = duration
     };
     Q_ENUM(PlayerState)
 
@@ -141,10 +141,10 @@ private:
     void onDurationChanged(float duration);
     void onSlideFinished(Q3DSSlide *slide);
     void setSlideTime(Q3DSSlide *slide, float time, bool forceUpdate = false);
+    void flushQueuedChanges();
 
     void handleCurrentSlideChanged(Q3DSSlide *slide,
-                                   Q3DSSlide *previousSlide,
-                                   bool forceUpdate = false);
+                                   Q3DSSlide *previousSlide);
 
     // TODO: Move out to a "slide manager"?
     void sendPositionChanged(Q3DSSlide *slide, float pos);
@@ -170,6 +170,8 @@ private:
     PlayerMode m_mode = PlayerMode::Viewer;
     PlayerType m_type = PlayerType::Slide;
 
+    QVector<std::function<void()>> m_queuedChanges;
+
     // This class handles animation callback from animationmanager and calls setSlideTime
     friend class Q3DSSlidePositionCallback;
     friend class Q3DSSceneManager;
diff --git a/tests/auto/slideplayer/tst_q3dsslideplayer.cpp b/tests/auto/slideplayer/tst_q3dsslideplayer.cpp
index 96fa78b..4b494bb 100644
--- a/tests/auto/slideplayer/tst_q3dsslideplayer.cpp
+++ b/tests/auto/slideplayer/tst_q3dsslideplayer.cpp
@@ -188,9 +188,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
     QCOMPARE(player->duration(), 1000);
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
 
-    // Stopped -> playing -> stopped
+    // Stopped -> playing -> paused
     QCOMPARE(stateChangeSpy.count(), 2);
     // PlayToNext -> StopAtEnd
     QCOMPARE(slideChangedSpy.count(), 1);
@@ -207,10 +207,11 @@ void tst_Q3DSSlidePlayer::tst_playModes()
     QCOMPARE(player->duration(), 1000);
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
 
-    // Stopped -> playing -> stopped
+    // Stopped -> playing -> paused
     QCOMPARE(stateChangeSpy.count(), 2);
+    // StopAtEnd (which was the previous slide, so no changes expected)
     QCOMPARE(slideChangedSpy.count(), 0);
     QCOMPARE(player->slideDeck()->currentSlide(), m_stopAtEnd);
 
@@ -219,19 +220,15 @@ void tst_Q3DSSlidePlayer::tst_playModes()
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
     slideChangedSpy.clear();
+    stateChangeSpy.clear();
 
     player->slideDeck()->setCurrentSlide(int(Slide::PlayToPrevious));
     QCOMPARE(player->duration(), 1000);
-    player->stop();
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
-
-    stateChangeSpy.clear();
-
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
 
-    // Stopped -> playing -> stopped
+    // Stopped -> playing -> paused
     QCOMPARE(stateChangeSpy.count(), 2);
     // StopAtEnd -> PlayToPrevious -> StopAtEnd
     QCOMPARE(slideChangedSpy.count(), 2);
@@ -250,9 +247,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
 
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
 
-    // Stopped -> playing -> stopped
+    // Stopped -> playing -> paused
     QCOMPARE(stateChangeSpy.count(), 2);
     // StopAtEnd -> Ping
     QCOMPARE(slideChangedSpy.count(), 1);
@@ -320,9 +317,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
 
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
 
-    // Stopped -> playing -> stopped
+    // Stopped -> playing -> paused
     QCOMPARE(stateChangeSpy.count(), 2);
     // Looping -> PlayToSlide -> FinalSlide
     QCOMPARE(slideChangedSpy.count(), 2);
@@ -343,9 +340,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
 
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
 
-    // Stopped -> playing -> stopped
+    // Stopped -> playing -> paused
     QCOMPARE(stateChangeSpy.count(), 2);
     // FinalSlide -> Dummy
     QCOMPARE(slideChangedSpy.count(), 1);
diff --git a/tests/auto/slides/tst_q3dsslides.cpp b/tests/auto/slides/tst_q3dsslides.cpp
index 59d8809..f48311f 100644
--- a/tests/auto/slides/tst_q3dsslides.cpp
+++ b/tests/auto/slides/tst_q3dsslides.cpp
@@ -261,79 +261,79 @@ void tst_Q3DSSlides::setPresentationSlides()
     m_updateSpy.wait(30);
 
     Q3DSSlidePlayer *player = m_sceneManager->slidePlayer();
-    player->stop();
+    player->pause();
     QVERIFY(player);
 
     // Check starting state
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
     // "Slide 1 Rect" should be visible
-    QVERIFY(isNodeVisible(m_slide1Rect));
-    QVERIFY(!isNodeVisible(m_slide4Cone));
+    QTRY_VERIFY(isNodeVisible(m_slide1Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide4Cone));
 
     // Set second slide
     m_sceneManager->setCurrentSlide(m_presentationSlide2, true);
     // Verify second slide state
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
     // "Slide 2 Sphere" should be visible
-    QVERIFY(isNodeVisible(m_slide2Sphere));
+    QTRY_VERIFY(isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QVERIFY(!isNodeVisible(m_slide1Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
 
     // Go back to first slide
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
     // Check first slide state
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
     // "Slide 1 Rect" should be visible
-    QVERIFY(isNodeVisible(m_slide1Rect));
-    QVERIFY(!isNodeVisible(m_slide4Cone));
+    QTRY_VERIFY(isNodeVisible(m_slide1Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide4Cone));
     // "Slide 2 Sphere" should not be visible
-    QVERIFY(!isNodeVisible(m_slide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
 
     // Set 3rd Slide (with Component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
     // Component Should be visible
-    QVERIFY(isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(isNodeVisible(m_slide3Component));
     // "Slide 2 Sphere" should not be visible
-    QVERIFY(!isNodeVisible(m_slide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QVERIFY(!isNodeVisible(m_slide1Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
 
     // Set 4th Slide (from Component)
     m_sceneManager->setCurrentSlide(m_presentationSlide4, true);
     QCOMPARE(player->duration(), 12028);
     // MasterCylinder should be visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
     // Component Should not be visible
-    QVERIFY(!isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
     // "Slide 2 Sphere" should not be visible
-    QVERIFY(!isNodeVisible(m_slide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QVERIFY(!isNodeVisible(m_slide1Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
     // Slide 4 Cone should be visible
-    QVERIFY(isNodeVisible(m_slide4Cone));
+    QTRY_VERIFY(isNodeVisible(m_slide4Cone));
 
     // Set the same slide again
     m_sceneManager->setCurrentSlide(m_presentationSlide4, true);
     QCOMPARE(player->duration(), 12028);
     // MasterCylinder should be visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
     // Component Should not be visible
-    QVERIFY(!isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
     // "Slide 2 Sphere" should not be visible
-    QVERIFY(!isNodeVisible(m_slide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QVERIFY(!isNodeVisible(m_slide1Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
     // Slide 4 Cone should be visible
-    QVERIFY(isNodeVisible(m_slide4Cone));
+    QTRY_VERIFY(isNodeVisible(m_slide4Cone));
 }
 
 void tst_Q3DSSlides::presentationRollback()
@@ -343,27 +343,27 @@ void tst_Q3DSSlides::presentationRollback()
 
     // DynamicSphere exists on the master slide (visible by default)
     // DynamicSphere has eyeball set to false on Slides 2 and 4
-    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
 
     // Go to Second Slide
     m_sceneManager->setCurrentSlide(m_presentationSlide2, true);
-    QVERIFY(!isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_dynamicSphere));
 
     // Go to Third Slide (requires rollback)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
 
     // Go to Forth Slide
     m_sceneManager->setCurrentSlide(m_presentationSlide4, true);
-    QVERIFY(!isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_dynamicSphere));
 
     // Go to another slide with eyeball false (no rollback)
     m_sceneManager->setCurrentSlide(m_presentationSlide2, true);
-    QVERIFY(!isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_dynamicSphere));
 
     // Make sure rollback still works
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
-    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
 
 }
 
@@ -371,64 +371,64 @@ void tst_Q3DSSlides::setComponentSlides()
 {
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QVERIFY(isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(isNodeVisible(m_slide3Component));
 
     // Initial slide should be m_componentSlide1
-    QVERIFY(isNodeVisible(m_componentMasterCube));
-    QVERIFY(isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
 
     // Switch to Component Slide 2 (text)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide2, true);
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
 
     // Switch back to Component Slide 1
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QVERIFY(isNodeVisible(m_componentMasterCube));
-    QVERIFY(isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
 
     // Switch to Component Slide 3 (deep component)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QVERIFY(isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
 
     // Switch to same slide
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QVERIFY(isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
 }
 
 void tst_Q3DSSlides::componentRollback()
 {
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QVERIFY(isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(isNodeVisible(m_slide3Component));
 
     // Set first slide which contains "Master Cube"
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
 
     // Second slide sets Master Cube eyeball to false
     m_sceneManager->setComponentCurrentSlide(m_componentSlide2, true);
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
 
     // Switch back to first slide (requires rollback)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
 
     // Move to slide 3 (no change)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
 }
 
 void tst_Q3DSSlides::setDeepComponentSlides()
@@ -437,33 +437,33 @@ void tst_Q3DSSlides::setDeepComponentSlides()
     // PresentationSlide3 -> ComponentSlide3 -> DeepComponentSlide[n]
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QVERIFY(isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(isNodeVisible(m_slide3Component));
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QVERIFY(isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
 
     // At this point the first slide of deep component should be active
     QVERIFY(m_componentSlide3Component->currentSlide() == m_deepComponentSlide1);
-    QVERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
 
     // Switch to second deep component slide
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide2, true);
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Moon));
 
     // Switch back to deep component first slide
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QVERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
 
     // Set same slide again
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QVERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
 }
 
 void tst_Q3DSSlides::deepComponentRollback()
@@ -472,21 +472,21 @@ void tst_Q3DSSlides::deepComponentRollback()
     // PresentationSlide3 -> ComponentSlide3 -> DeepComponentSlide[n]
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QVERIFY(isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(isNodeVisible(m_slide3Component));
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QVERIFY(isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
 
     // First slide has "master text" active
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QVERIFY(isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentMasterText));
 
     // Second slide has eyeball set to false for master text
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide2, true);
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // Switch back to first slide to perform rollback
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QVERIFY(isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentMasterText));
 }
 
 void tst_Q3DSSlides::setNonVisibleComponentSlides()
@@ -499,85 +499,85 @@ void tst_Q3DSSlides::setNonVisibleComponentSlides()
 
     // Select a presentation slide that does not have a component
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
-    QVERIFY(!isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
 
     // m_slide3Component is only visible on m_presentationSlide3
     // change m_slide3Component's slides and make sure the contents
     // do not become visible.
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     m_sceneManager->setComponentCurrentSlide(m_componentSlide2, true);
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // also change deep compoents slides (now active in component slide3)
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide2, true);
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // Now make component visible by switching to slide 3
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QVERIFY(isNodeVisible(m_slide3Component));
-    QVERIFY(isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(isNodeVisible(m_componentSlide3Component));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(isNodeVisible(m_deepComponentSlide2Moon));
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // make sure that they go away again
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
-    QVERIFY(!isNodeVisible(m_slide3Component));
-    QVERIFY(!isNodeVisible(m_componentMasterCube));
-    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QVERIFY(!isNodeVisible(m_componentSlide2Text));
-    QVERIFY(!isNodeVisible(m_componentSlide3Component));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
 }
 
 void tst_Q3DSSlides::testTimeLineVisibility()
@@ -586,13 +586,13 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     // and endtimes than the slide they are on
     m_sceneManager->setCurrentSlide(m_presentationSlide5, true);
 
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(!isNodeVisible(m_slide5Rect));
-    QVERIFY(isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
 
     Q3DSSlidePlayer *player = m_sceneManager->slidePlayer();
-    player->stop();
+    player->pause();
     QVERIFY(player);
 
     QSignalSpy updateSpy(m_engine, SIGNAL(nextFrameStarting()));
@@ -608,7 +608,7 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     m_sceneManager->setComponentCurrentSlide(m_componentSlide51);
     Q_ASSERT(m_componentSlide5MasterSlide == m_slide5Component->masterSlide());
     Q3DSSlidePlayer *compPlayer = m_componentSlide5MasterSlide->attached<Q3DSSlideAttached>()->slidePlayer;
-    compPlayer->stop();
+    compPlayer->pause();
     QVERIFY(compPlayer);
 
     QSignalSpy compPositionChangedSpy(compPlayer, &Q3DSSlidePlayer::positionChanged);
@@ -623,34 +623,34 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     seekAndWait(999);
 
     // Still invisible
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(!isNodeVisible(m_slide5Rect));
-    QVERIFY(isNodeVisible(m_slide5Sphere));
-    QVERIFY(!isNodeVisible(m_slide5Component));
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(1000);
 
     // Slide 5 component becomes visible, but not components objects
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(isNodeVisible(m_slide5Rect));
-    QVERIFY(isNodeVisible(m_slide5Sphere));
-    QVERIFY(isNodeVisible(m_slide5Component));
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(1500);
     // Sync up the comp player
     seekAndWaitForComp(1500);
 
     // Everything now visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(isNodeVisible(m_slide5Rect));
-    QVERIFY(isNodeVisible(m_slide5Sphere));
-    QVERIFY(isNodeVisible(m_slide5Component));
-    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     // Verify a positionChanged signal coming from component slide player
     seekAndWaitForComp(1501);
@@ -660,36 +660,36 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     seekAndWaitForComp(2000);
 
     // Everything still visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(isNodeVisible(m_slide5Rect));
-    QVERIFY(isNodeVisible(m_slide5Sphere));
-    QVERIFY(isNodeVisible(m_slide5Component));
-    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(2001);
     // Sync up the comp player
     seekAndWaitForComp(2001);
 
     // Neither rect nor sphere are visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(!isNodeVisible(m_slide5Rect));
-    QVERIFY(!isNodeVisible(m_slide5Sphere));
-    QVERIFY(isNodeVisible(m_slide5Component));
-    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(2885);
     // Sync up the comp player
     seekAndWaitForComp(2885);
 
     // Neither rect nor sphere are visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(!isNodeVisible(m_slide5Rect));
-    QVERIFY(!isNodeVisible(m_slide5Sphere));
-    QVERIFY(!isNodeVisible(m_slide5Component));
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 
     // Now test time lines that are out of sync
     // Start by a know state with all visible
@@ -698,67 +698,67 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     seekAndWaitForComp(1500);
 
     // Everything now visible
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(isNodeVisible(m_slide5Rect));
-    QVERIFY(isNodeVisible(m_slide5Sphere));
-    QVERIFY(isNodeVisible(m_slide5Component));
-    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWaitForComp(0);
-    QVERIFY(isNodeVisible(m_slide5Component));
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWaitForComp(1300);
-    QVERIFY(isNodeVisible(m_slide5Component));
-    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(3000);
-    QVERIFY(!isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
     // Component nodes should be hidden by parent.
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(1500);
-    QVERIFY(isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(isNodeVisible(m_slide5Component));
     // Component nodes should be made visible by parent.
-    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(3000);
-    QVERIFY(!isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
     // Make the parent make the component nodes hidden again
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWaitForComp(1000);
     // Component should not make its nodes visible.
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWaitForComp(100);
     // Hidden by component
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(1500);
     // ... Now make sure the parent doesn't make the component nodes visible!
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(0);
     // Sync up the comp player
     seekAndWaitForComp(0);
 
     // Back to the beginning
-    QVERIFY(isNodeVisible(m_masterCylinder));
-    QVERIFY(isNodeVisible(m_dynamicSphere));
-    QVERIFY(!isNodeVisible(m_slide5Rect));
-    QVERIFY(isNodeVisible(m_slide5Sphere));
-    QVERIFY(!isNodeVisible(m_slide5Component));
-    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
+    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
+    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
+    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 }
 
 Q3DSModelNode *tst_Q3DSSlides::getModelWithName(const QString &name, Q3DSGraphObject *parent)