Add system time to Clock

Author: adazem009

src/engine/internal/clock.cpp

@@ -15,7 +15,12 @@ std::shared_ptr<Clock> Clock::instance()
     return m_instance;
 }
 
-std::chrono::steady_clock::time_point Clock::currentTime() const
+std::chrono::steady_clock::time_point Clock::currentSteadyTime() const
 {
     return std::chrono::steady_clock::now();
 }
+
+std::chrono::system_clock::time_point Clock::currentSystemTime() const
+{
+    return std::chrono::system_clock::now();
+}

src/engine/internal/clock.h

@@ -16,7 +16,8 @@ class Clock : public IClock
 
         static std::shared_ptr<Clock> instance();
 
-        std::chrono::steady_clock::time_point currentTime() const override;
+        std::chrono::steady_clock::time_point currentSteadyTime() const override;
+        std::chrono::system_clock::time_point currentSystemTime() const override;
 
     private:
         static std::shared_ptr<Clock> m_instance;

src/engine/internal/iclock.h

@@ -12,7 +12,8 @@ class IClock
     public:
         virtual ~IClock() { }
 
-        virtual std::chrono::steady_clock::time_point currentTime() const = 0;
+        virtual std::chrono::steady_clock::time_point currentSteadyTime() const = 0;
+        virtual std::chrono::system_clock::time_point currentSystemTime() const = 0;
 };
 
 } // namespace libscratchcpp

src/engine/internal/timer.cpp

@@ -22,7 +22,7 @@ Timer::Timer(IClock *clock) :
 
 double Timer::value() const
 {
-    return std::chrono::duration_cast<std::chrono::milliseconds>(m_clock->currentTime() - m_startTime).count() / 1000.0;
+    return std::chrono::duration_cast<std::chrono::milliseconds>(m_clock->currentSteadyTime() - m_startTime).count() / 1000.0;
 }
 
 void Timer::reset()
@@ -33,5 +33,5 @@ void Timer::reset()
 // Required to avoid calling the virtual method from the constructors
 void Timer::resetTimer()
 {
-    m_startTime = m_clock->currentTime();
+    m_startTime = m_clock->currentSteadyTime();
 }

test/clock/clock_test.cpp

@@ -5,15 +5,29 @@
 
 using namespace libscratchcpp;
 
-TEST(ClockTest, CurrentTime)
+TEST(ClockTest, CurrentSteadyTime)
 {
     auto clock = Clock::instance();
     ASSERT_TRUE(clock);
 
     auto currentTime = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now());
     double currentTimeMs = std::round(currentTime.time_since_epoch().count() / 10) * 10;
 
-    auto reportedTime = std::chrono::time_point_cast<std::chrono::milliseconds>(clock->currentTime());
+    auto reportedTime = std::chrono::time_point_cast<std::chrono::milliseconds>(clock->currentSteadyTime());
+    double reportedTimeMs = std::round(reportedTime.time_since_epoch().count() / 10) * 10;
+
+    ASSERT_EQ(reportedTimeMs, currentTimeMs);
+}
+
+TEST(ClockTest, CurrentSystemTime)
+{
+    auto clock = Clock::instance();
+    ASSERT_TRUE(clock);
+
+    auto currentTime = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
+    double currentTimeMs = std::round(currentTime.time_since_epoch().count() / 10) * 10;
+
+    auto reportedTime = std::chrono::time_point_cast<std::chrono::milliseconds>(clock->currentSystemTime());
     double reportedTimeMs = std::round(reportedTime.time_since_epoch().count() / 10) * 10;
 
     ASSERT_EQ(reportedTimeMs, currentTimeMs);

test/mocks/clockmock.h

@@ -8,5 +8,6 @@ using namespace libscratchcpp;
 class ClockMock : public IClock
 {
     public:
-        MOCK_METHOD(std::chrono::steady_clock::time_point, currentTime, (), (const override));
+        MOCK_METHOD(std::chrono::steady_clock::time_point, currentSteadyTime, (), (const, override));
+        MOCK_METHOD(std::chrono::system_clock::time_point, currentSystemTime, (), (const, override));
 };

test/timer/timer_test.cpp

@@ -12,22 +12,22 @@ TEST(TimerTest, ValueAndReset)
     ClockMock clock;
 
     std::chrono::steady_clock::time_point startTime(std::chrono::milliseconds(50));
-    EXPECT_CALL(clock, currentTime()).WillOnce(Return(startTime));
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(startTime));
     Timer timer(&clock);
 
     std::chrono::steady_clock::time_point time1(std::chrono::milliseconds(73));
-    EXPECT_CALL(clock, currentTime()).WillOnce(Return(time1));
+    EXPECT_CALL(clock, currentSteadyTime()).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));
+    EXPECT_CALL(clock, currentSteadyTime()).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));
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time3));
     timer.reset();
 
     std::chrono::steady_clock::time_point time4(std::chrono::milliseconds(24632));
-    EXPECT_CALL(clock, currentTime()).WillOnce(Return(time4));
+    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time4));
     ASSERT_EQ(timer.value(), 8.607);
 }