Implement sensing_dayssince2000 block

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -6,8 +6,12 @@
 #include <scratchcpp/itimer.h>
 #include "sensingblocks.h"
 
+#include "../engine/internal/clock.h"
+
 using namespace libscratchcpp;
 
+IClock *SensingBlocks::clock = Clock::instance().get();
+
 std::string SensingBlocks::name() const
 {
     return "Sensing";
@@ -18,6 +22,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     // Blocks
     engine->addCompileFunction(this, "sensing_timer", &compileTimer);
     engine->addCompileFunction(this, "sensing_resettimer", &compileResetTimer);
+    engine->addCompileFunction(this, "sensing_dayssince2000", &compileDaysSince2000);
 }
 
 void SensingBlocks::compileTimer(Compiler *compiler)
@@ -30,6 +35,11 @@ void SensingBlocks::compileResetTimer(Compiler *compiler)
     compiler->addFunctionCall(&resetTimer);
 }
 
+void SensingBlocks::compileDaysSince2000(Compiler *compiler)
+{
+    compiler->addFunctionCall(&daysSince2000);
+}
+
 unsigned int SensingBlocks::timer(VirtualMachine *vm)
 {
     vm->addReturnValue(vm->engine()->timer()->value());
@@ -41,3 +51,11 @@ unsigned int SensingBlocks::resetTimer(VirtualMachine *vm)
     vm->engine()->timer()->reset();
     return 0;
 }
+
+unsigned int SensingBlocks::daysSince2000(VirtualMachine *vm)
+{
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(clock->currentSystemTime().time_since_epoch()).count();
+    vm->addReturnValue(ms / 86400000.0 - 10957);
+
+    return 0;
+}

src/blocks/sensingblocks.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <scratchcpp/iblocksection.h>
+#include "../engine/internal/clock.h"
 
 namespace libscratchcpp
 {
@@ -17,9 +18,13 @@ class SensingBlocks : public IBlockSection
 
         static void compileTimer(Compiler *compiler);
         static void compileResetTimer(Compiler *compiler);
+        static void compileDaysSince2000(Compiler *compiler);
 
         static unsigned int timer(VirtualMachine *vm);
         static unsigned int resetTimer(VirtualMachine *vm);
+        static unsigned int daysSince2000(VirtualMachine *vm);
+
+        static IClock *clock;
 };
 
 } // namespace libscratchcpp

test/blocks/sensing_blocks_test.cpp

@@ -2,6 +2,7 @@
 #include <scratchcpp/block.h>
 #include <enginemock.h>
 #include <timermock.h>
+#include <clockmock.h>
 
 #include "../common.h"
 #include "blocks/sensingblocks.h"
@@ -24,6 +25,7 @@ class SensingBlocksTest : public testing::Test
         EngineMock m_engineMock;
         Engine m_engine;
         TimerMock m_timerMock;
+        ClockMock m_clockMock;
 };
 
 TEST_F(SensingBlocksTest, Name)
@@ -41,6 +43,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);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_dayssince2000", &SensingBlocks::compileDaysSince2000)).Times(1);
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -111,3 +114,39 @@ TEST_F(SensingBlocksTest, ResetTimerImpl)
 
     ASSERT_EQ(vm.registerCount(), 0);
 }
+
+TEST_F(SensingBlocksTest, DaysSince2000)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sensing_dayssince2000");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::daysSince2000)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    SensingBlocks::compileDaysSince2000(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+}
+
+TEST_F(SensingBlocksTest, DaysSince2000Impl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SensingBlocks::daysSince2000 };
+
+    VirtualMachine vm(nullptr, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+
+    std::chrono::system_clock::time_point time(std::chrono::milliseconds(1011243120562)); // Jan 17 2002 04:52:00
+    EXPECT_CALL(m_clockMock, currentSystemTime()).WillOnce(Return(time));
+
+    SensingBlocks::clock = &m_clockMock;
+    vm.setBytecode(bytecode);
+    vm.run();
+    SensingBlocks::clock = Clock::instance().get();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 747.20278428240817);
+}