Implement sensing_resettimer block

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -17,15 +17,27 @@ void SensingBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
     engine->addCompileFunction(this, "sensing_timer", &compileTimer);
+    engine->addCompileFunction(this, "sensing_resettimer", &compileResetTimer);
 }
 
 void SensingBlocks::compileTimer(Compiler *compiler)
 {
     compiler->addFunctionCall(&timer);
 }
 
+void SensingBlocks::compileResetTimer(Compiler *compiler)
+{
+    compiler->addFunctionCall(&resetTimer);
+}
+
 unsigned int SensingBlocks::timer(VirtualMachine *vm)
 {
     vm->addReturnValue(vm->engine()->timer()->value());
     return 0;
 }
+
+unsigned int SensingBlocks::resetTimer(VirtualMachine *vm)
+{
+    vm->engine()->timer()->reset();
+    return 0;
+}

src/blocks/sensingblocks.h

@@ -16,8 +16,10 @@ class SensingBlocks : public IBlockSection
         void registerBlocks(IEngine *engine) override;
 
         static void compileTimer(Compiler *compiler);
+        static void compileResetTimer(Compiler *compiler);
 
         static unsigned int timer(VirtualMachine *vm);
+        static unsigned int resetTimer(VirtualMachine *vm);
 };
 
 } // namespace libscratchcpp

test/blocks/sensing_blocks_test.cpp

@@ -40,6 +40,7 @@ TEST_F(SensingBlocksTest, RegisterBlocks)
 {
     // Blocks
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_timer", &SensingBlocks::compileTimer)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_resettimer", &SensingBlocks::compileResetTimer)).Times(1);
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -77,3 +78,36 @@ TEST_F(SensingBlocksTest, TimerImpl)
     ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 2.375);
 }
+
+TEST_F(SensingBlocksTest, ResetTimer)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sensing_resettimer");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::resetTimer)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    SensingBlocks::compileResetTimer(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+}
+
+TEST_F(SensingBlocksTest, ResetTimerImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SensingBlocks::resetTimer };
+
+    VirtualMachine vm(nullptr, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+
+    EXPECT_CALL(m_engineMock, timer()).WillOnce(Return(&m_timerMock));
+    EXPECT_CALL(m_timerMock, reset()).Times(1);
+
+    vm.setBytecode(bytecode);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+}