Add thread about to stop signal

Author: adazem009

include/scratchcpp/iengine.h

@@ -113,6 +113,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Emits when rendering should occur. */
         virtual sigslot::signal<> &aboutToRender() = 0;
 
+        /*! Emits when a script is about to stop. */
+        virtual sigslot::signal<VirtualMachine *> &threadAboutToStop() = 0;
+
         /*! Returns true if the project is currently running. */
         virtual bool isRunning() const = 0;
 

src/engine/internal/engine.cpp

@@ -63,6 +63,11 @@ void Engine::clear()
     for (auto monitor : m_monitors)
         m_monitorRemoved(monitor.get(), monitor->impl->iface);
 
+    for (auto thread : m_threads) {
+        if (!thread->atEnd())
+            m_threadAboutToStop(thread.get());
+    }
+
     m_sections.clear();
     m_targets.clear();
     m_broadcasts.clear();
@@ -328,6 +333,11 @@ void Engine::stop()
     } else {
         // If there isn't any active thread, it means the project was stopped from the outside
         // In this case all threads should be removed and the project should be considered stopped
+        for (auto thread : m_threads) {
+            if (!thread->atEnd())
+                m_threadAboutToStop(thread.get());
+        }
+
         m_threads.clear();
         m_running = false;
     }
@@ -511,6 +521,11 @@ sigslot::signal<> &Engine::aboutToRender()
     return m_aboutToRedraw;
 }
 
+sigslot::signal<VirtualMachine *> &Engine::threadAboutToStop()
+{
+    return m_threadAboutToStop;
+}
+
 std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L70-L173
@@ -548,8 +563,14 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
         }
 
         // Remove threads in m_threadsToStop
-        for (auto thread : m_threadsToStop)
+        for (auto thread : m_threadsToStop) {
+            if (!thread->atEnd())
+                m_threadAboutToStop(thread.get());
+
             m_threads.erase(std::remove(m_threads.begin(), m_threads.end(), thread), m_threads.end());
+        }
+
+        m_threadsToStop.clear();
 
         // Remove inactive threads (and add them to doneThreads)
         m_threads.erase(
@@ -1658,6 +1679,10 @@ void Engine::stopThread(VirtualMachine *thread)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1667-L1672
     assert(thread);
+
+    if (!thread->atEnd())
+        m_threadAboutToStop(thread);
+
     thread->kill();
 }
 
@@ -1668,6 +1693,9 @@ std::shared_ptr<VirtualMachine> Engine::restartThread(std::shared_ptr<VirtualMac
     auto it = std::find(m_threads.begin(), m_threads.end(), thread);
 
     if (it != m_threads.end()) {
+        if (!thread->atEnd())
+            m_threadAboutToStop(thread.get());
+
         auto i = it - m_threads.begin();
         m_threads[i] = newThread;
         return newThread;

src/engine/internal/engine.h

@@ -50,6 +50,7 @@ class Engine : public IEngine
         void stopEventLoop() override;
 
         sigslot::signal<> &aboutToRender() override;
+        sigslot::signal<VirtualMachine *> &threadAboutToStop() override;
 
         bool isRunning() const override;
 
@@ -266,6 +267,7 @@ class Engine : public IEngine
         bool m_running = false;
         bool m_redrawRequested = false;
         sigslot::signal<> m_aboutToRedraw;
+        sigslot::signal<VirtualMachine *> m_threadAboutToStop;
         bool m_stopEventLoop = false;
         std::mutex m_stopEventLoopMutex;
 

test/3_threads.sb3

@@ -47,6 +47,12 @@ class RedrawMock
         MOCK_METHOD(void, redraw, ());
 };
 
+class ThreadAboutToStopMock
+{
+    public:
+        MOCK_METHOD(void, threadRemoved, (VirtualMachine *));
+};
+
 class AddRemoveMonitorMock
 {
     public:
@@ -109,6 +115,44 @@ TEST(EngineTest, Clear)
     ASSERT_TRUE(engine.monitors().empty());
 }
 
+TEST(EngineTest, ClearThreadAboutToStopSignal)
+{
+    Project p("3_threads.sb3");
+    ASSERT_TRUE(p.load());
+    auto engine = p.engine();
+
+    engine->start();
+    engine->step();
+
+    ThreadAboutToStopMock threadRemovedMock;
+    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+        ASSERT_TRUE(vm);
+        ASSERT_FALSE(vm->atEnd());
+    })));
+
+    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->clear();
+}
+
+TEST(EngineTest, StopThreadAboutToStopSignal)
+{
+    Project p("3_threads.sb3");
+    ASSERT_TRUE(p.load());
+    auto engine = p.engine();
+
+    engine->start();
+    engine->step();
+
+    ThreadAboutToStopMock threadRemovedMock;
+    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+        ASSERT_TRUE(vm);
+        ASSERT_FALSE(vm->atEnd());
+    })));
+
+    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->stop();
+}
+
 TEST(EngineTest, CompileAndExecuteMonitors)
 {
     Engine engine;
@@ -1840,10 +1884,18 @@ TEST(EngineTest, BroadcastsProject)
 {
     Project p("broadcasts.sb3");
     ASSERT_TRUE(p.load());
-    p.run();
 
     auto engine = p.engine();
+
+    ThreadAboutToStopMock threadRemovedMock;
+    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(21).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+        ASSERT_TRUE(vm);
+        ASSERT_FALSE(vm->atEnd());
+    })));
+
+    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
     engine->setFps(1000);
+    p.run();
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
@@ -1880,10 +1932,18 @@ TEST(EngineTest, StopAllBypass)
 {
     Project p("stop_all_bypass.sb3");
     ASSERT_TRUE(p.load());
-    p.run();
 
     auto engine = p.engine();
 
+    ThreadAboutToStopMock threadRemovedMock;
+    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(2).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+        ASSERT_TRUE(vm);
+        ASSERT_FALSE(vm->atEnd());
+    })));
+
+    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    p.run();
+
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 
@@ -1900,10 +1960,18 @@ TEST(EngineTest, StopOtherScriptsInSprite)
 {
     Project p("stop_other_scripts_in_sprite.sb3");
     ASSERT_TRUE(p.load());
-    p.run();
 
     auto engine = p.engine();
 
+    ThreadAboutToStopMock threadRemovedMock;
+    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(4).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+        ASSERT_TRUE(vm);
+        ASSERT_FALSE(vm->atEnd());
+    })));
+
+    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    p.run();
+
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 

test/engine/engine_test.cpp

@@ -33,6 +33,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, stopEventLoop, (), (override));
 
         MOCK_METHOD(sigslot::signal<> &, aboutToRender, (), (override));
+        MOCK_METHOD(sigslot::signal<VirtualMachine *> &, threadAboutToStop, (), (override));
 
         MOCK_METHOD(bool, isRunning, (), (const, override));