Add "default" empty implementation for Timer and SleepMs()

p12tic · p12tic · commit f70aeb811c5a · 2018-11-16T16:55:11.000+02:00
diff --git a/UnitTest++/Default/TimeHelpers.cpp b/UnitTest++/Default/TimeHelpers.cpp
@@ -0,0 +1,25 @@
+#include "TimeHelpers.h"
+#include <unistd.h>
+
+namespace UnitTest {
+namespace Detail {
+
+   TimerImplDefault::TimerImplDefault()
+   {
+   }
+
+   void TimerImplDefault::Start()
+   {
+   }
+
+   double TimerImplDefault::GetTimeInMs() const
+   {
+      return 0;
+   }
+
+   void SleepMsImplDefault(int ms)
+   {
+   }
+
+}
+}
diff --git a/UnitTest++/Default/TimeHelpers.h b/UnitTest++/Default/TimeHelpers.h
@@ -0,0 +1,25 @@
+#ifndef UNITTEST_DEFAULT_TIMEHELPERS_H
+#define UNITTEST_DEFAULT_TIMEHELPERS_H
+
+#include <sys/time.h>
+
+// An implementation on platforms that are not supported
+
+namespace UnitTest {
+namespace Detail {
+
+   class TimerImplDefault
+   {
+   public:
+      TimerImplDefault();
+      void Start();
+      double GetTimeInMs() const;
+
+   private:
+   };
+
+   void SleepMsImplDefault(int ms);
+}
+}
+
+#endif
diff --git a/UnitTest++/Posix/TimeHelpers.cpp b/UnitTest++/Posix/TimeHelpers.cpp
@@ -2,19 +2,20 @@
 #include <unistd.h>
 
 namespace UnitTest {
+namespace Detail {
 
-   Timer::Timer()
+   TimerImplPosix::TimerImplPosix()
    {
       m_startTime.tv_sec = 0;
       m_startTime.tv_usec = 0;
    }
 
-   void Timer::Start()
+   void TimerImplPosix::Start()
    {
       gettimeofday(&m_startTime, 0);
    }
 
-   double Timer::GetTimeInMs() const
+   double TimerImplPosix::GetTimeInMs() const
    {
       struct timeval currentTime;
       gettimeofday(&currentTime, 0);
@@ -25,9 +26,10 @@ namespace UnitTest {
       return (dsecs * 1000.0) + (dus / 1000.0);
    }
 
-   void TimeHelpers::SleepMs(int ms)
+   void SleepMsImplPosix(int ms)
    {
       usleep(static_cast<useconds_t>(ms * 1000));
    }
 
 }
+}
diff --git a/UnitTest++/Posix/TimeHelpers.h b/UnitTest++/Posix/TimeHelpers.h
@@ -1,28 +1,24 @@
-#ifndef UNITTEST_TIMEHELPERS_H
-#define UNITTEST_TIMEHELPERS_H
+#ifndef UNITTEST_POSIX_TIMEHELPERS_H
+#define UNITTEST_POSIX_TIMEHELPERS_H
 
 #include <sys/time.h>
 
 namespace UnitTest {
+namespace Detail {
 
-   class Timer
+   class TimerImplPosix
    {
    public:
-      Timer();
+      TimerImplPosix();
       void Start();
       double GetTimeInMs() const;
 
    private:
       struct timeval m_startTime;
    };
 
-
-   namespace TimeHelpers
-   {
-      void SleepMs(int ms);
-   }
-
-
+   void SleepMsImplPosix(int ms);
+}
 }
 
 #endif
diff --git a/UnitTest++/TimeHelpers.h b/UnitTest++/TimeHelpers.h
@@ -1,7 +1,49 @@
+#ifndef UNITTEST_TIMEHELPERS_H
+#define UNITTEST_TIMEHELPERS_H
+
 #include "Config.h"
 
 #if defined UNITTEST_POSIX
    #include "Posix/TimeHelpers.h"
-#else
+#elif defined UNITTEST_WIN32
    #include "Win32/TimeHelpers.h"
+#else
+   #include "Default/TimeHelpers.h"
+#endif
+
+namespace UnitTest {
+
+   class Timer
+   {
+#if defined UNITTEST_POSIX
+      typedef UnitTest::Detail::TimerImplPosix TimerImpl;
+#elif defined UNITTEST_WIN32
+      typedef UnitTest::Detail::TimerImplWin32 TimerImpl;
+#else
+      typedef UnitTest::Detail::TimerImplDefault TimerImpl;
+#endif
+
+   public:
+      Timer() {}
+      void Start() { m_timer.Start(); }
+      double GetTimeInMs() const { return m_timer.GetTimeInMs(); }
+
+   private:
+      TimerImpl m_timer;
+   };
+
+   namespace TimeHelpers {
+      static inline void SleepMs(int ms)
+      {
+#if defined UNITTEST_POSIX
+         UnitTest::Detail::SleepMsImplPosix(ms);
+#elif defined UNITTEST_WIN32
+         UnitTest::Detail::SleepMsImplWin32(ms);
+#else
+         UnitTest::Detail::SleepMsImplDefault(ms);
+#endif
+      }
+   }
+}
+
 #endif
diff --git a/UnitTest++/Win32/TimeHelpers.cpp b/UnitTest++/Win32/TimeHelpers.cpp
@@ -4,8 +4,9 @@
 #include <windows.h>
 
 namespace UnitTest {
+namespace Detail {
 
-   Timer::Timer()
+   TimerImplWin32::TimerImplWin32()
       : m_threadHandle(::GetCurrentThread())
       , m_startTime(0)
    {
@@ -20,19 +21,19 @@ namespace UnitTest {
       ::SetThreadAffinityMask(m_threadHandle, m_processAffinityMask);
    }
 
-   void Timer::Start()
+   void TimerImplWin32::Start()
    {
       m_startTime = GetTime();
    }
 
-   double Timer::GetTimeInMs() const
+   double TimerImplWin32::GetTimeInMs() const
    {
       __int64 const elapsedTime = GetTime() - m_startTime;
       double const seconds = double(elapsedTime) / double(m_frequency);
       return seconds * 1000.0;
    }
 
-   __int64 Timer::GetTime() const
+   __int64 TimerImplWin32::GetTime() const
    {
       LARGE_INTEGER curTime;
       ::SetThreadAffinityMask(m_threadHandle, 1);
@@ -41,9 +42,10 @@ namespace UnitTest {
       return curTime.QuadPart;
    }
 
-   void TimeHelpers::SleepMs(int ms)
+   void SleepMsImplWin32(int ms)
    {
       ::Sleep(ms);
    }
 
 }
+}
diff --git a/UnitTest++/Win32/TimeHelpers.h b/UnitTest++/Win32/TimeHelpers.h
@@ -1,5 +1,5 @@
-#ifndef UNITTEST_TIMEHELPERS_H
-#define UNITTEST_TIMEHELPERS_H
+#ifndef UNITTEST_WIN32_TIMEHELPERS_H
+#define UNITTEST_WIN32_TIMEHELPERS_H
 
 #include "../Config.h"
 #include "../HelperMacros.h"
@@ -11,11 +11,12 @@
 #endif
 
 namespace UnitTest {
+namespace Detail {
 
-   class UNITTEST_LINKAGE Timer
+   class UNITTEST_LINKAGE TimerImplWin32
    {
    public:
-      Timer();
+      TimerImplWin32();
       void Start();
       double GetTimeInMs() const;
 
@@ -34,12 +35,8 @@ namespace UnitTest {
       __int64 m_frequency;
    };
 
-
-   namespace TimeHelpers
-   {
-      UNITTEST_LINKAGE void SleepMs(int ms);
-   }
-
+   UNITTEST_LINKAGE void SleepMsImplWin32(int ms);
+}
 }
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -2,19 +2,20 @@`
`2`	`2`	`#include <unistd.h>`
`3`	`3`
`4`	`4`	`namespace UnitTest {`
	`5`	`+namespace Detail {`
`5`	`6`
`6`		`- Timer::Timer()`
	`7`	`+ TimerImplPosix::TimerImplPosix()`
`7`	`8`	`{`
`8`	`9`	`m_startTime.tv_sec = 0;`
`9`	`10`	`m_startTime.tv_usec = 0;`
`10`	`11`	`}`
`11`	`12`
`12`		`- void Timer::Start()`
	`13`	`+ void TimerImplPosix::Start()`
`13`	`14`	`{`
`14`	`15`	`gettimeofday(&m_startTime, 0);`
`15`	`16`	`}`
`16`	`17`
`17`		`- double Timer::GetTimeInMs() const`
	`18`	`+ double TimerImplPosix::GetTimeInMs() const`
`18`	`19`	`{`
`19`	`20`	`struct timeval currentTime;`
`20`	`21`	`gettimeofday(&currentTime, 0);`
`@@ -25,9 +26,10 @@ namespace UnitTest {`
`25`	`26`	`return (dsecs * 1000.0) + (dus / 1000.0);`
`26`	`27`	`}`
`27`	`28`
`28`		`- void TimeHelpers::SleepMs(int ms)`
	`29`	`+ void SleepMsImplPosix(int ms)`
`29`	`30`	`{`
`30`	`31`	`usleep(static_cast<useconds_t>(ms * 1000));`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`}`
	`35`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,9 @@`
`4`	`4`	`#include <windows.h>`
`5`	`5`
`6`	`6`	`namespace UnitTest {`
	`7`	`+namespace Detail {`
`7`	`8`
`8`		`- Timer::Timer()`
	`9`	`+ TimerImplWin32::TimerImplWin32()`
`9`	`10`	`: m_threadHandle(::GetCurrentThread())`
`10`	`11`	`, m_startTime(0)`
`11`	`12`	`{`
`@@ -20,19 +21,19 @@ namespace UnitTest {`
`20`	`21`	`::SetThreadAffinityMask(m_threadHandle, m_processAffinityMask);`
`21`	`22`	`}`
`22`	`23`
`23`		`- void Timer::Start()`
	`24`	`+ void TimerImplWin32::Start()`
`24`	`25`	`{`
`25`	`26`	`m_startTime = GetTime();`
`26`	`27`	`}`
`27`	`28`
`28`		`- double Timer::GetTimeInMs() const`
	`29`	`+ double TimerImplWin32::GetTimeInMs() const`
`29`	`30`	`{`
`30`	`31`	`__int64 const elapsedTime = GetTime() - m_startTime;`
`31`	`32`	`double const seconds = double(elapsedTime) / double(m_frequency);`
`32`	`33`	`return seconds * 1000.0;`
`33`	`34`	`}`
`34`	`35`
`35`		`- __int64 Timer::GetTime() const`
	`36`	`+ __int64 TimerImplWin32::GetTime() const`
`36`	`37`	`{`
`37`	`38`	`LARGE_INTEGER curTime;`
`38`	`39`	`::SetThreadAffinityMask(m_threadHandle, 1);`
`@@ -41,9 +42,10 @@ namespace UnitTest {`
`41`	`42`	`return curTime.QuadPart;`
`42`	`43`	`}`
`43`	`44`
`44`		`- void TimeHelpers::SleepMs(int ms)`
	`45`	`+ void SleepMsImplWin32(int ms)`
`45`	`46`	`{`
`46`	`47`	`::Sleep(ms);`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`}`
	`51`	`+}`