Add Timer class

Author: adazem009

CMakeLists.txt

@@ -46,6 +46,7 @@ target_sources(scratchcpp
     include/scratchcpp/target.h
     include/scratchcpp/stage.h
     include/scratchcpp/sprite.h
+    include/scratchcpp/itimer.h
 )
 
 add_library(zip SHARED

include/scratchcpp/itimer.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace libscratchcpp
+{
+
+/*!
+ * \brief The ITimer interface represents a timer of a Scratch project.
+ *
+ * You can get a project timer using Engine#timer().
+ */
+class ITimer
+{
+    public:
+        virtual ~ITimer() { }
+
+        /*! Returns the time since last reset in seconds. */
+        virtual double value() const = 0;
+
+        /*! Resets the timer. */
+        virtual void reset() = 0;
+};
+
+} // namespace libscratchcpp

src/engine/CMakeLists.txt

@@ -14,6 +14,8 @@ target_sources(scratchcpp
     internal/clock.cpp
     internal/clock.h
     internal/iclock.h
+    internal/timer.cpp
+    internal/timer.h
     internal/blocksectioncontainer.cpp
     internal/blocksectioncontainer.h
     internal/global.h

src/engine/internal/timer.cpp

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <cassert>
+
+#include "timer.h"
+#include "clock.h"
+
+using namespace libscratchcpp;
+
+Timer::Timer()
+{
+    m_clock = Clock::instance().get();
+    resetTimer();
+}
+
+Timer::Timer(IClock *clock) :
+    m_clock(clock)
+{
+    assert(clock);
+    resetTimer();
+}
+
+double Timer::value() const
+{
+    return std::chrono::duration_cast<std::chrono::milliseconds>(m_clock->currentTime() - m_startTime).count() / 1000.0;
+}
+
+void Timer::reset()
+{
+    resetTimer();
+}
+
+// Required to avoid calling the virtual method from the constructors
+void Timer::resetTimer()
+{
+    m_startTime = m_clock->currentTime();
+}

src/engine/internal/timer.h

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/itimer.h>
+#include <chrono>
+
+namespace libscratchcpp
+{
+
+class IClock;
+
+class Timer : public ITimer
+{
+    public:
+        Timer();
+        Timer(IClock *clock);
+        Timer(const Timer &) = delete;
+
+        double value() const override;
+        void reset() override;
+
+    private:
+        void resetTimer();
+
+        std::chrono::steady_clock::time_point m_startTime;
+        IClock *m_clock = nullptr;
+};
+
+} // namespace libscratchcpp

test/CMakeLists.txt

@@ -29,3 +29,4 @@ add_subdirectory(script)
 add_subdirectory(extensions)
 add_subdirectory(engine)
 add_subdirectory(clock)
+add_subdirectory(timer)

test/mocks/timermock.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <scratchcpp/itimer.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class TimerMock : public ITimer
+{
+    public:
+        MOCK_METHOD(double, value, (), (const, override));
+
+        MOCK_METHOD(void, reset, (), (override));
+};

test/timer/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_executable(
+  timer_test
+  timer_test.cpp
+)
+
+target_link_libraries(
+  timer_test
+  GTest::gtest_main
+  GTest::gmock_main
+  scratchcpp
+  scratchcpp_mocks
+)
+
+gtest_discover_tests(timer_test)

test/timer/timer_test.cpp

@@ -0,0 +1,33 @@
+#include <engine/internal/timer.h>
+#include <clockmock.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+using ::testing::Return;
+
+TEST(TimerTest, ValueAndReset)
+{
+    ClockMock clock;
+
+    std::chrono::steady_clock::time_point startTime(std::chrono::milliseconds(50));
+    EXPECT_CALL(clock, currentTime()).WillOnce(Return(startTime));
+    Timer timer(&clock);
+
+    std::chrono::steady_clock::time_point time1(std::chrono::milliseconds(73));
+    EXPECT_CALL(clock, currentTime()).WillOnce(Return(time1));
+    ASSERT_EQ(timer.value(), 0.023);
+
+    std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(15432));
+    EXPECT_CALL(clock, currentTime()).WillOnce(Return(time2));
+    ASSERT_EQ(timer.value(), 15.382);
+
+    std::chrono::steady_clock::time_point time3(std::chrono::milliseconds(16025));
+    EXPECT_CALL(clock, currentTime()).WillOnce(Return(time3));
+    timer.reset();
+
+    std::chrono::steady_clock::time_point time4(std::chrono::milliseconds(24632));
+    EXPECT_CALL(clock, currentTime()).WillOnce(Return(time4));
+    ASSERT_EQ(timer.value(), 8.607);
+}