Implement sensing_timer block

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -1,5 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
+#include <scratchcpp/virtualmachine.h>
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/itimer.h>
 #include "sensingblocks.h"
 
 using namespace libscratchcpp;
@@ -11,4 +15,17 @@ std::string SensingBlocks::name() const
 
 void SensingBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
+    engine->addCompileFunction(this, "sensing_timer", &compileTimer);
+}
+
+void SensingBlocks::compileTimer(Compiler *compiler)
+{
+    compiler->addFunctionCall(&timer);
+}
+
+unsigned int SensingBlocks::timer(VirtualMachine *vm)
+{
+    vm->addReturnValue(vm->engine()->timer()->value());
+    return 0;
 }

src/blocks/sensingblocks.h

@@ -14,6 +14,10 @@ class SensingBlocks : public IBlockSection
         std::string name() const override;
 
         void registerBlocks(IEngine *engine) override;
+
+        static void compileTimer(Compiler *compiler);
+
+        static unsigned int timer(VirtualMachine *vm);
 };
 
 } // namespace libscratchcpp

test/blocks/sensing_blocks_test.cpp

@@ -1,13 +1,16 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/block.h>
 #include <enginemock.h>
+#include <timermock.h>
 
 #include "../common.h"
 #include "blocks/sensingblocks.h"
 #include "engine/internal/engine.h"
 
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
 class SensingBlocksTest : public testing::Test
 {
     public:
@@ -20,6 +23,7 @@ class SensingBlocksTest : public testing::Test
         std::unique_ptr<IBlockSection> m_section;
         EngineMock m_engineMock;
         Engine m_engine;
+        TimerMock m_timerMock;
 };
 
 TEST_F(SensingBlocksTest, Name)
@@ -34,5 +38,42 @@ TEST_F(SensingBlocksTest, CategoryVisible)
 
 TEST_F(SensingBlocksTest, RegisterBlocks)
 {
+    // Blocks
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_timer", &SensingBlocks::compileTimer)).Times(1);
+
     m_section->registerBlocks(&m_engineMock);
 }
+
+TEST_F(SensingBlocksTest, Timer)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sensing_timer");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::timer)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    SensingBlocks::compileTimer(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+}
+
+TEST_F(SensingBlocksTest, TimerImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SensingBlocks::timer };
+
+    VirtualMachine vm(nullptr, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+
+    EXPECT_CALL(m_engineMock, timer()).WillOnce(Return(&m_timerMock));
+    EXPECT_CALL(m_timerMock, value()).WillOnce(Return(2.375));
+
+    vm.setBytecode(bytecode);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 2.375);
+}