Implement control_forever

Author: adazem009

src/dev/blocks/controlblocks.cpp

@@ -1,5 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/dev/compiler.h>
+#include <scratchcpp/dev/compilerconstant.h>
+#include <scratchcpp/value.h>
+#include <scratchcpp/input.h>
+
 #include "controlblocks.h"
 
 using namespace libscratchcpp;
@@ -16,4 +22,13 @@ std::string ControlBlocks::description() const
 
 void ControlBlocks::registerBlocks(IEngine *engine)
 {
+    engine->addCompileFunction(this, "control_forever", &compileForever);
+}
+
+CompilerValue *ControlBlocks::compileForever(Compiler *compiler)
+{
+    auto substack = compiler->input("SUBSTACK");
+    compiler->beginLoopCondition();
+    compiler->moveToWhileLoop(compiler->addConstValue(true), substack ? substack->valueBlock() : nullptr);
+    return nullptr;
 }

src/dev/blocks/controlblocks.h

@@ -14,6 +14,9 @@ class ControlBlocks : public IExtension
         std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
+
+    private:
+        static CompilerValue *compileForever(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/CMakeLists.txt

@@ -1,3 +1,15 @@
+add_library(
+  block_test_deps SHARED
+  util.cpp
+  util.h
+)
+
+target_link_libraries(
+  block_test_deps
+  GTest::gtest_main
+  scratchcpp
+)
+
 # motion_blocks_test
 if (LIBSCRATCHCPP_ENABLE_MOTION_BLOCKS)
     add_executable(
@@ -83,6 +95,7 @@ if (LIBSCRATCHCPP_ENABLE_CONTROL_BLOCKS)
       GTest::gmock_main
       scratchcpp
       scratchcpp_mocks
+      block_test_deps
     )
 
     gtest_discover_tests(control_blocks_test)

test/dev/blocks/control_blocks_test.cpp

@@ -1,15 +1,70 @@
+#include <scratchcpp/project.h>
+#include <scratchcpp/dev/compiler.h>
+#include <scratchcpp/dev/test/scriptbuilder.h>
+#include <scratchcpp/sprite.h>
+#include <scratchcpp/block.h>
+#include <scratchcpp/input.h>
 #include <enginemock.h>
 
 #include "../common.h"
 #include "dev/blocks/controlblocks.h"
+#include "util.h"
 
 using namespace libscratchcpp;
+using namespace libscratchcpp::test;
 
 class ControlBlocksTest : public testing::Test
 {
     public:
-        void SetUp() override { m_extension = std::make_unique<ControlBlocks>(); }
+        void SetUp() override
+        {
+            m_extension = std::make_unique<ControlBlocks>();
+            m_engine = m_project.engine().get();
+            m_extension->registerBlocks(m_engine);
+            registerBlocks(m_engine, m_extension.get());
+        }
 
         std::unique_ptr<IExtension> m_extension;
+        Project m_project;
+        IEngine *m_engine = nullptr;
         EngineMock m_engineMock;
 };
+
+TEST_F(ControlBlocksTest, Forever)
+{
+    auto target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_forever");
+        auto substack = std::make_shared<Block>("", "test_print_test");
+        builder.addObscuredInput("SUBSTACK", substack);
+
+        builder.build();
+        m_engine->start();
+
+        for (int i = 0; i < 2; i++) {
+            testing::internal::CaptureStdout();
+            m_engine->step();
+            ASSERT_EQ(testing::internal::GetCapturedStdout().substr(0, 10), "test\ntest\n");
+            ASSERT_TRUE(m_engine->isRunning());
+        }
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+        builder.addBlock("control_forever");
+
+        builder.build();
+        m_engine->start();
+
+        for (int i = 0; i < 2; i++) {
+            m_engine->step();
+            ASSERT_TRUE(m_engine->isRunning());
+        }
+    }
+}

test/dev/blocks/util.cpp

@@ -0,0 +1,32 @@
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/dev/compiler.h>
+#include <scratchcpp/dev/compilerconstant.h>
+#include <scratchcpp/value.h>
+#include <iostream>
+
+#include "util.h"
+
+namespace libscratchcpp
+{
+
+void registerBlocks(IEngine *engine, IExtension *extension)
+{
+    engine->addCompileFunction(extension, "test_print", [](Compiler *compiler) -> CompilerValue * {
+        auto input = compiler->addInput("STRING");
+        compiler->addFunctionCall("test_print", Compiler::StaticType::Void, { Compiler::StaticType::String }, { input });
+        return nullptr;
+    });
+
+    engine->addCompileFunction(extension, "test_print_test", [](Compiler *compiler) -> CompilerValue * {
+        auto input = compiler->addConstValue("test");
+        compiler->addFunctionCall("test_print", Compiler::StaticType::Void, { Compiler::StaticType::String }, { input });
+        return nullptr;
+    });
+}
+
+extern "C" void test_print(const char *str)
+{
+    std::cout << str << std::endl;
+}
+
+} // namespace libscratchcpp

test/dev/blocks/util.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace libscratchcpp
+{
+
+class IEngine;
+class IExtension;
+
+void registerBlocks(IEngine *engine, IExtension *extension);
+
+} // namespace libscratchcpp