Implement sensing_dayssince2000 block

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -23,6 +23,7 @@
 #include "sensingblocks.h"
 #include "audio/audioinput.h"
 #include "audio/iaudioloudness.h"
+#include "engine/internal/clock.h"
 
 using namespace libscratchcpp;
 
@@ -60,6 +61,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sensing_resettimer", &compileResetTimer);
     engine->addCompileFunction(this, "sensing_of", &compileOf);
     engine->addCompileFunction(this, "sensing_current", &compileCurrent);
+    engine->addCompileFunction(this, "sensing_dayssince2000", &compileDaysSince2000);
 }
 
 void SensingBlocks::onInit(IEngine *engine)
@@ -367,6 +369,11 @@ CompilerValue *SensingBlocks::compileCurrent(Compiler *compiler)
         return compiler->addConstValue(Value());
 }
 
+CompilerValue *SensingBlocks::compileDaysSince2000(Compiler *compiler)
+{
+    return compiler->addFunctionCall("sensing_dayssince2000", Compiler::StaticType::Number);
+}
+
 void SensingBlocks::onAnswer(const std::string &answer)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/6055823f203a696165084b873e661713806583ec/src/blocks/scratch3_sensing.js#L99-L115
@@ -775,3 +782,12 @@ extern "C" double sensing_current_second()
     tm *ltm = localtime(&now);
     return ltm->tm_sec;
 }
+
+extern "C" double sensing_dayssince2000()
+{
+    if (!SensingBlocks::clock)
+        SensingBlocks::clock = Clock::instance().get();
+
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(SensingBlocks::clock->currentSystemTime().time_since_epoch()).count();
+    return ms / 86400000.0 - 10957.0;
+}

src/blocks/sensingblocks.h

@@ -10,6 +10,7 @@ namespace libscratchcpp
 {
 
 class IAudioInput;
+class IClock;
 class ExecutionContext;
 class Thread;
 
@@ -27,6 +28,7 @@ class SensingBlocks : public IExtension
         static void askQuestion(ExecutionContext *ctx, const StringPtr *question);
 
         static inline IAudioInput *audioInput = nullptr;
+        static inline IClock *clock = nullptr;
 
     private:
         struct Question
@@ -62,6 +64,7 @@ class SensingBlocks : public IExtension
         static CompilerValue *compileResetTimer(Compiler *compiler);
         static CompilerValue *compileOf(Compiler *compiler);
         static CompilerValue *compileCurrent(Compiler *compiler);
+        static CompilerValue *compileDaysSince2000(Compiler *compiler);
 
         static void onAnswer(const std::string &answer);
         static void enqueueAsk(const std::string &question, Thread *thread);

test/blocks/sensing_blocks_test.cpp

@@ -13,6 +13,7 @@
 #include <audioinputmock.h>
 #include <audioloudnessmock.h>
 #include <timermock.h>
+#include <clockmock.h>
 
 #include "../common.h"
 #include "blocks/sensingblocks.h"
@@ -44,19 +45,23 @@ class SensingBlocksTest : public testing::Test
             m_audioLoudness = std::make_shared<AudioLoudnessMock>();
             SensingBlocks::audioInput = &m_audioInput;
             EXPECT_CALL(m_audioInput, audioLoudness()).WillRepeatedly(Return(m_audioLoudness));
+
+            SensingBlocks::clock = &m_clock;
         }
 
         void TearDown() override
         {
             SensingBlocks::clearQuestions();
             SensingBlocks::audioInput = nullptr;
+            SensingBlocks::clock = nullptr;
         }
 
         std::unique_ptr<IExtension> m_extension;
         Project m_project;
         IEngine *m_engine = nullptr;
         EngineMock m_engineMock;
         std::shared_ptr<AudioLoudnessMock> m_audioLoudness;
+        ClockMock m_clock;
 
     private:
         AudioInputMock m_audioInput;
@@ -2745,3 +2750,25 @@ TEST_F(SensingBlocksTest, Current_Invalid)
     ASSERT_EQ(value_toDouble(&value), 0.0);
     value_free(&value);
 }
+
+TEST_F(SensingBlocksTest, DaysSince2000)
+{
+    auto targetMock = std::make_shared<TargetMock>();
+
+    ScriptBuilder builder(m_extension.get(), m_engine, targetMock);
+    builder.addBlock("sensing_dayssince2000");
+    Block *block = builder.currentBlock();
+
+    Compiler compiler(&m_engineMock, targetMock.get());
+    auto code = compiler.compile(block, Compiler::CodeType::Reporter);
+    Script script(targetMock.get(), block, &m_engineMock);
+    script.setCode(code);
+    Thread thread(targetMock.get(), &m_engineMock, &script);
+
+    std::chrono::system_clock::time_point time(std::chrono::milliseconds(1011243120562)); // Jan 17 2002 04:52:00
+    EXPECT_CALL(m_clock, currentSystemTime()).WillOnce(Return(time));
+
+    ValueData value = thread.runReporter();
+    ASSERT_EQ(value_toDouble(&value), 747.20278428240817);
+    value_free(&value);
+}