Thread: Use ExecutableCode when using LLVM

Author: adazem009

src/engine/thread.cpp

@@ -2,6 +2,10 @@
 
 #include <scratchcpp/thread.h>
 #include <scratchcpp/virtualmachine.h>
+#ifdef USE_LLVM
+#include <scratchcpp/script.h>
+#include <scratchcpp/dev/executablecode.h>
+#endif
 
 #include "thread_p.h"
 
@@ -12,11 +16,16 @@ Thread::Thread(Target *target, IEngine *engine, Script *script) :
     impl(spimpl::make_unique_impl<ThreadPrivate>(target, engine, script))
 {
     impl->vm = std::make_unique<VirtualMachine>(target, engine, script, this);
+#ifdef USE_LLVM
+    impl->code = impl->script->code();
+    impl->executionContext = impl->code->createExecutionContext(target);
+#endif
 }
 
 /*! Returns the virtual machine of this thread. */
 VirtualMachine *Thread::vm() const
 {
+    // TODO: Remove this method
     return impl->vm.get();
 }
 
@@ -41,35 +50,59 @@ Script *Thread::script() const
 /*! Runs the script until it finishes or yields. */
 void Thread::run()
 {
+#ifdef USE_LLVM
+    impl->code->run(impl->executionContext.get());
+#else
     impl->vm->run();
+#endif
 }
 
 /*! Stops the script. */
 void Thread::kill()
 {
+#ifdef USE_LLVM
+    impl->code->kill(impl->executionContext.get());
+#else
     impl->vm->kill();
+#endif
 }
 
 /*! Resets the script to run from the start. */
 void Thread::reset()
 {
+#ifdef USE_LLVM
+    impl->code->reset(impl->executionContext.get());
+#else
     impl->vm->reset();
+#endif
 }
 
 /*! Returns true if the script is stopped or finished. */
 bool Thread::isFinished() const
 {
+#ifdef USE_LLVM
+    return impl->code->isFinished(impl->executionContext.get());
+#else
     return impl->vm->atEnd();
+#endif
 }
 
 /*! Pauses the script (when it's executed using run() again) until resolvePromise() is called. */
 void Thread::promise()
 {
+#ifdef USE_LLVM
+    impl->code->promise();
+#else
     impl->vm->promise();
+#endif
 }
 
 /*! Resolves the promise and resumes the script. */
 void Thread::resolvePromise()
 {
+#ifdef USE_LLVM
+    impl->code->resolvePromise();
+#else
     impl->vm->resolvePromise();
+#endif
 }

src/engine/thread_p.h

@@ -7,6 +7,11 @@
 namespace libscratchcpp
 {
 
+#ifdef USE_LLVM
+class ExecutableCode;
+class ExecutionContext;
+#endif
+
 struct ThreadPrivate
 {
         ThreadPrivate(Target *target, IEngine *engine, Script *script);
@@ -15,6 +20,10 @@ struct ThreadPrivate
         Target *target = nullptr;
         IEngine *engine = nullptr;
         Script *script = nullptr;
+#ifdef USE_LLVM
+        ExecutableCode *code = nullptr;
+        std::shared_ptr<ExecutionContext> executionContext;
+#endif
 };
 
 } // namespace libscratchcpp

test/thread/thread_test.cpp

@@ -1,26 +1,80 @@
 #include <scratchcpp/thread.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/virtualmachine.h>
+#include <scratchcpp/dev/executioncontext.h>
 #include <targetmock.h>
 #include <enginemock.h>
+#include <executablecodemock.h>
 
 #include "../common.h"
 
 using namespace libscratchcpp;
 
-TEST(ThreadTest, Constructor)
+using ::testing::Return;
+
+class ThreadTest : public testing::Test
 {
-    TargetMock target;
-    EngineMock engine;
-    Script script(nullptr, nullptr, nullptr);
-    Thread thread(&target, &engine, &script);
-    ASSERT_EQ(thread.target(), &target);
-    ASSERT_EQ(thread.engine(), &engine);
-    ASSERT_EQ(thread.script(), &script);
-    ASSERT_TRUE(thread.vm());
-    ASSERT_EQ(thread.vm()->target(), &target);
-    ASSERT_EQ(thread.vm()->engine(), &engine);
-    ASSERT_EQ(thread.vm()->script(), &script);
+    public:
+        void SetUp() override
+        {
+            m_script = std::make_unique<Script>(nullptr, nullptr, nullptr);
+#ifdef USE_LLVM
+            m_code = std::make_shared<ExecutableCodeMock>();
+            m_script->setCode(m_code);
+            m_ctx = std::make_shared<ExecutionContext>(&m_target);
+            EXPECT_CALL(*m_code, createExecutionContext(&m_target)).WillOnce(Return(m_ctx));
+#endif
+            m_thread = std::make_unique<Thread>(&m_target, &m_engine, m_script.get());
+        }
+
+        std::unique_ptr<Thread> m_thread;
+        TargetMock m_target;
+        EngineMock m_engine;
+        std::unique_ptr<Script> m_script;
+#ifdef USE_LLVM
+        std::shared_ptr<ExecutableCodeMock> m_code;
+        std::shared_ptr<ExecutionContext> m_ctx;
+#endif
+};
+
+TEST_F(ThreadTest, Constructor)
+{
+    ASSERT_EQ(m_thread->target(), &m_target);
+    ASSERT_EQ(m_thread->engine(), &m_engine);
+    ASSERT_EQ(m_thread->script(), m_script.get());
+    ASSERT_TRUE(m_thread->vm());
+    ASSERT_EQ(m_thread->vm()->target(), &m_target);
+    ASSERT_EQ(m_thread->vm()->engine(), &m_engine);
+    ASSERT_EQ(m_thread->vm()->script(), m_script.get());
+}
+
+#ifdef USE_LLVM
+TEST_F(ThreadTest, Run)
+{
+    EXPECT_CALL(*m_code, run(m_ctx.get()));
+    m_thread->run();
+}
+
+TEST_F(ThreadTest, Kill)
+{
+    EXPECT_CALL(*m_code, kill(m_ctx.get()));
+    m_thread->kill();
+}
+
+TEST_F(ThreadTest, Reset)
+{
+    EXPECT_CALL(*m_code, reset(m_ctx.get()));
+    m_thread->reset();
+}
+
+TEST_F(ThreadTest, IsFinished)
+{
+    EXPECT_CALL(*m_code, isFinished(m_ctx.get())).WillOnce(Return(false));
+    ASSERT_FALSE(m_thread->isFinished());
+
+    EXPECT_CALL(*m_code, isFinished(m_ctx.get())).WillOnce(Return(true));
+    ASSERT_TRUE(m_thread->isFinished());
 }
 
-// NOTE: Since VirtualMachine is going to be removed, tests for the other methods will be added later
+// TODO: Test promise() and resolvePromise()
+#endif // USE_LLVM