Thread: Add hat predicate support

Author: adazem009

include/scratchcpp/thread.h

@@ -27,6 +27,7 @@ class LIBSCRATCHCPP_EXPORT Thread
         Script *script() const;
 
         void run();
+        bool runPredicate();
         void kill();
         void reset();
 

src/engine/thread.cpp

@@ -18,9 +18,13 @@ Thread::Thread(Target *target, IEngine *engine, Script *script) :
 
     if (impl->script) {
         impl->code = impl->script->code();
+        impl->hatPredicateCode = impl->script->hatPredicateCode();
 
         if (impl->code)
             impl->executionContext = impl->code->createExecutionContext(this);
+
+        if (impl->hatPredicateCode)
+            impl->hatPredicateExecutionContext = impl->hatPredicateCode->createExecutionContext(this);
     }
 }
 
@@ -56,6 +60,18 @@ void Thread::run()
     string_pool_set_thread(nullptr);
 }
 
+/*! Runs the hat predicate and returns its return value. */
+bool Thread::runPredicate()
+{
+    if (!impl->hatPredicateCode)
+        return false;
+
+    string_pool_set_thread(this);
+    const bool ret = impl->hatPredicateCode->runPredicate(impl->hatPredicateExecutionContext.get());
+    string_pool_set_thread(nullptr);
+    return ret;
+}
+
 /*! Stops the script. */
 void Thread::kill()
 {

src/engine/thread_p.h

@@ -21,7 +21,9 @@ struct ThreadPrivate
         IEngine *engine = nullptr;
         Script *script = nullptr;
         ExecutableCode *code = nullptr;
+        ExecutableCode *hatPredicateCode = nullptr;
         std::shared_ptr<ExecutionContext> executionContext;
+        std::shared_ptr<ExecutionContext> hatPredicateExecutionContext;
 };
 
 } // namespace libscratchcpp

test/thread/thread_test.cpp

@@ -50,6 +50,31 @@ TEST_F(ThreadTest, Run)
     m_thread->run();
 }
 
+TEST_F(ThreadTest, RunPredicate)
+{
+    ASSERT_FALSE(m_thread->runPredicate());
+
+    auto predicateCode = std::make_shared<ExecutableCodeMock>();
+    std::shared_ptr<ExecutionContext> predicateCtx;
+    m_script->setHatPredicateCode(predicateCode);
+    EXPECT_CALL(*m_code, createExecutionContext(_)).WillOnce(Invoke([this](Thread *thread) {
+        m_ctx = std::make_shared<ExecutionContext>(thread);
+        return m_ctx;
+    }));
+    EXPECT_CALL(*predicateCode, createExecutionContext(_)).WillOnce(Invoke([&predicateCtx](Thread *thread) {
+        predicateCtx = std::make_shared<ExecutionContext>(thread);
+        return predicateCtx;
+    }));
+
+    Thread thread(&m_target, &m_engine, m_script.get());
+
+    EXPECT_CALL(*predicateCode, runPredicate(predicateCtx.get())).WillOnce(Return(false));
+    ASSERT_FALSE(thread.runPredicate());
+
+    EXPECT_CALL(*predicateCode, runPredicate(predicateCtx.get())).WillOnce(Return(true));
+    ASSERT_TRUE(thread.runPredicate());
+}
+
 TEST_F(ThreadTest, Kill)
 {
     EXPECT_CALL(*m_code, kill(m_ctx.get()));