Implement operator_random

Author: adazem009

src/dev/blocks/operatorblocks.cpp

@@ -2,6 +2,7 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/dev/compiler.h>
+#include <scratchcpp/dev/compilervalue.h>
 
 #include "operatorblocks.h"
 
@@ -23,6 +24,7 @@ void OperatorBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "operator_subtract", &compileSubtract);
     engine->addCompileFunction(this, "operator_multiply", &compileMultiply);
     engine->addCompileFunction(this, "operator_divide", &compileDivide);
+    engine->addCompileFunction(this, "operator_random", &compileRandom);
 }
 
 CompilerValue *OperatorBlocks::compileAdd(Compiler *compiler)
@@ -44,3 +46,10 @@ CompilerValue *OperatorBlocks::compileDivide(Compiler *compiler)
 {
     return compiler->createDiv(compiler->addInput("NUM1"), compiler->addInput("NUM2"));
 }
+
+CompilerValue *OperatorBlocks::compileRandom(Compiler *compiler)
+{
+    auto from = compiler->addInput("FROM");
+    auto to = compiler->addInput("TO");
+    return compiler->createRandom(from, to);
+}

src/dev/blocks/operatorblocks.h

@@ -7,6 +7,8 @@
 namespace libscratchcpp
 {
 
+class IRandomGenerator;
+
 class OperatorBlocks : public IExtension
 {
     public:
@@ -20,6 +22,7 @@ class OperatorBlocks : public IExtension
         static CompilerValue *compileSubtract(Compiler *compiler);
         static CompilerValue *compileMultiply(Compiler *compiler);
         static CompilerValue *compileDivide(Compiler *compiler);
+        static CompilerValue *compileRandom(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/CMakeLists.txt

@@ -132,6 +132,7 @@ if (LIBSCRATCHCPP_ENABLE_OPERATOR_BLOCKS)
       GTest::gmock_main
       scratchcpp
       scratchcpp_mocks
+      block_test_deps
     )
 
     gtest_discover_tests(operator_blocks_test)

test/dev/blocks/operator_blocks_test.cpp

@@ -2,15 +2,25 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/dev/compiler.h>
+#include <scratchcpp/block.h>
+#include <scratchcpp/input.h>
+#include <scratchcpp/script.h>
+#include <scratchcpp/thread.h>
+#include <scratchcpp/dev/executablecode.h>
+#include <scratchcpp/dev/executioncontext.h>
 #include <scratchcpp/dev/test/scriptbuilder.h>
 #include <enginemock.h>
+#include <randomgeneratormock.h>
 
 #include "../common.h"
 #include "dev/blocks/operatorblocks.h"
+#include "util.h"
 
 using namespace libscratchcpp;
 using namespace libscratchcpp::test;
 
+using ::testing::Return;
+
 class OperatorBlocksTest : public testing::Test
 {
     public:
@@ -19,12 +29,14 @@ class OperatorBlocksTest : public testing::Test
             m_extension = std::make_unique<OperatorBlocks>();
             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;
+        RandomGeneratorMock m_rng;
 };
 
 TEST_F(OperatorBlocksTest, Add)
@@ -102,3 +114,52 @@ TEST_F(OperatorBlocksTest, Divide)
     ASSERT_EQ(valueList->size(), 1);
     ASSERT_EQ(std::round(value_toDouble(&values[0]) * 100) / 100, 2.28);
 }
+
+TEST_F(OperatorBlocksTest, Random)
+{
+    auto target = std::make_shared<Sprite>();
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    auto addRandomTest = [&builder](const Value &from, const Value &to) {
+        auto block = std::make_shared<Block>("", "operator_random");
+        auto input = std::make_shared<Input>("FROM", Input::Type::Shadow);
+        input->setPrimaryValue(from);
+        block->addInput(input);
+        input = std::make_shared<Input>("TO", Input::Type::Shadow);
+        input->setPrimaryValue(to);
+        block->addInput(input);
+
+        builder.addBlock("test_print");
+        builder.addObscuredInput("STRING", block);
+        return builder.currentBlock();
+    };
+
+    auto block = addRandomTest(-45, 12);
+    addRandomTest(12, 6.05);
+    addRandomTest(-78.686, -45);
+    addRandomTest(6.05, -78.686);
+
+    builder.build();
+
+    Compiler compiler(&m_engineMock, target.get());
+    auto code = compiler.compile(block);
+    Script script(target.get(), block, &m_engineMock);
+    script.setCode(code);
+    Thread thread(target.get(), &m_engineMock, &script);
+    auto ctx = code->createExecutionContext(&thread);
+    ctx->setRng(&m_rng);
+
+    static const std::string expected =
+        "-18\n"
+        "3.486789\n"
+        "-59.468873\n"
+        "-28.648764\n";
+
+    EXPECT_CALL(m_rng, randint(-45, 12)).WillOnce(Return(-18));
+    EXPECT_CALL(m_rng, randintDouble(12, 6.05)).WillOnce(Return(3.486789));
+    EXPECT_CALL(m_rng, randintDouble(-78.686, -45)).WillOnce(Return(-59.468873));
+    EXPECT_CALL(m_rng, randintDouble(6.05, -78.686)).WillOnce(Return(-28.648764));
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+}