Add StackTimer

Author: adazem009

CMakeLists.txt

@@ -59,6 +59,7 @@ target_sources(scratchcpp
     include/scratchcpp/sprite.h
     include/scratchcpp/textbubble.h
     include/scratchcpp/itimer.h
+    include/scratchcpp/istacktimer.h
     include/scratchcpp/keyevent.h
     include/scratchcpp/rect.h
     include/scratchcpp/igraphicseffect.h

include/scratchcpp/istacktimer.h

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "global.h"
+
+namespace libscratchcpp
+{
+
+/*!
+ * \brief The IStackTimer interface represents a timer that can be used by blocks.
+ *
+ * You can get a stack timer using ExecutionContext#stackTimer().
+ */
+class LIBSCRATCHCPP_EXPORT IStackTimer
+{
+    public:
+        virtual ~IStackTimer() { }
+
+        /*! Starts the timer. */
+        virtual void start(double seconds) = 0;
+
+        /*! Stops the timer. */
+        virtual void stop() = 0;
+
+        /*! Returns true if the timer has been stopped using stop() or wasn't used at all. */
+        virtual bool stopped() const = 0;
+
+        /*! Returns true if the timer has elapsed. */
+        virtual bool elapsed() const = 0;
+};
+
+} // namespace libscratchcpp

src/engine/CMakeLists.txt

@@ -16,6 +16,8 @@ target_sources(scratchcpp
     internal/iclock.h
     internal/timer.cpp
     internal/timer.h
+    internal/stacktimer.cpp
+    internal/stacktimer.h
     internal/randomgenerator.h
     internal/randomgenerator.cpp
     internal/irandomgenerator.h

src/engine/internal/stacktimer.cpp

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <cassert>
+#include <iostream>
+
+#include "stacktimer.h"
+#include "clock.h"
+
+using namespace libscratchcpp;
+
+StackTimer::StackTimer()
+{
+    m_clock = Clock::instance().get();
+}
+
+StackTimer::StackTimer(IClock *clock) :
+    m_clock(clock)
+{
+    assert(clock);
+}
+
+void StackTimer::start(double seconds)
+{
+    m_startTime = m_clock->currentSteadyTime();
+    m_timeLimit = seconds * 1000;
+    m_stopped = false;
+}
+
+void StackTimer::stop()
+{
+    m_stopped = true;
+}
+
+bool StackTimer::stopped() const
+{
+    return m_stopped;
+}
+
+bool StackTimer::elapsed() const
+{
+    if (m_stopped)
+        return false;
+
+    return std::chrono::duration_cast<std::chrono::milliseconds>(m_clock->currentSteadyTime() - m_startTime).count() >= m_timeLimit;
+}

src/engine/internal/stacktimer.h

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/istacktimer.h>
+#include <chrono>
+
+namespace libscratchcpp
+{
+
+class IClock;
+
+class StackTimer : public IStackTimer
+{
+    public:
+        StackTimer();
+        StackTimer(IClock *clock);
+        StackTimer(const StackTimer &) = delete;
+
+        void start(double seconds) override;
+        void stop() override;
+
+        bool stopped() const override;
+        bool elapsed() const override;
+
+    private:
+        std::chrono::steady_clock::time_point m_startTime;
+        bool m_stopped = true;
+        long m_timeLimit = 0;
+        IClock *m_clock = nullptr;
+};
+
+} // namespace libscratchcpp

test/mocks/stacktimermock.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <scratchcpp/istacktimer.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class StackTimerMock : public IStackTimer
+{
+    public:
+        MOCK_METHOD(void, start, (double), (override));
+        MOCK_METHOD(void, stop, (), (override));
+
+        MOCK_METHOD(bool, stopped, (), (const, override));
+        MOCK_METHOD(bool, elapsed, (), (const, override));
+};

test/timer/CMakeLists.txt

@@ -1,6 +1,7 @@
 add_executable(
   timer_test
   timer_test.cpp
+  stacktimer_test.cpp
 )
 
 target_link_libraries(

test/timer/stacktimer_test.cpp

@@ -0,0 +1,46 @@
+#include <engine/internal/stacktimer.h>
+
+#include <clockmock.h>
+
+using namespace libscratchcpp;
+
+using ::testing::Return;
+
+TEST(StackTimerTest, StartStopElapsed)
+{
+    ClockMock clock;
+    StackTimer timer(&clock);
+
+    ASSERT_TRUE(timer.stopped());
+
+    EXPECT_CALL(clock, currentSteadyTime).Times(0);
+    ASSERT_FALSE(timer.elapsed());
+
+    std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(73));
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
+    timer.start(0.5);
+
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
+    ASSERT_FALSE(timer.elapsed());
+    ASSERT_FALSE(timer.stopped());
+
+    std::chrono::steady_clock::time_point time3(std::chrono::milliseconds(520));
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time3));
+    ASSERT_FALSE(timer.elapsed());
+    ASSERT_FALSE(timer.stopped());
+
+    std::chrono::steady_clock::time_point time4(std::chrono::milliseconds(573));
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time4));
+    ASSERT_TRUE(timer.elapsed());
+    ASSERT_FALSE(timer.stopped());
+
+    std::chrono::steady_clock::time_point time5(std::chrono::milliseconds(580));
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time5));
+    ASSERT_TRUE(timer.elapsed());
+    ASSERT_FALSE(timer.stopped());
+
+    timer.stop();
+    EXPECT_CALL(clock, currentSteadyTime).Times(0);
+    ASSERT_FALSE(timer.elapsed());
+    ASSERT_TRUE(timer.stopped());
+}