Update readme. Code cleanup.

Author: endurodave

IntegrationTest/IT_Util.h

@@ -15,15 +15,15 @@
 
 // Helper function to simplify asynchronous function invoke within a test
 template <typename C, typename F, typename T, typename M = std::chrono::milliseconds, typename... Args>
-auto AsyncInvoke(C obj, F func, T& thread, M timeout, Args&&... args) 
+auto AsyncInvoke(C obj, F func, T& thread, M timeout, Args&&... args)
 {
-	// Asynchronously call target function and wait up to timeout milliseconds to complete
-	auto retVal = MakeDelegate(obj, func, thread, timeout).AsyncInvoke(std::forward<Args>(args)...);
+    // Asynchronously call target function and wait up to timeout milliseconds to complete
+    auto retVal = MakeDelegate(obj, func, thread, timeout).AsyncInvoke(std::forward<Args>(args)...);
 
-	// Check that the target function call succeeded within the timeout specified
-	EXPECT_TRUE(retVal.has_value());
+    // Check that the target function call succeeded within the timeout specified
+    EXPECT_TRUE(retVal.has_value());
 
-	return retVal;
+    return retVal;
 }
 
 #endif

IntegrationTest/IntegrationTest.cpp

@@ -12,46 +12,46 @@
 //----------------------------------------------------------------------------
 IntegrationTest& IntegrationTest::GetInstance()
 {
-	static IntegrationTest instance;
-	return instance;
+    static IntegrationTest instance;
+    return instance;
 }
 
 //----------------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------------
 IntegrationTest::IntegrationTest() :
-	m_thread("IntegrationTestThread")
+    m_thread("IntegrationTestThread")
 {
-	m_thread.CreateThread();
+    m_thread.CreateThread();
 
-	// Start integration tests 500mS after system startup
-	m_timer.Expired = MakeDelegate(this, &IntegrationTest::Run, m_thread);
-	m_timer.Start(std::chrono::milliseconds(500));
+    // Start integration tests 500mS after system startup
+    m_timer.Expired = MakeDelegate(this, &IntegrationTest::Run, m_thread);
+    m_timer.Start(std::chrono::milliseconds(500));
 }
 
 //----------------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------------
 IntegrationTest::~IntegrationTest()
 {
-	m_timer.Expired = 0;
+    m_timer.Expired = 0;
 }
 
 //----------------------------------------------------------------------------
 // Run
 //----------------------------------------------------------------------------
 void IntegrationTest::Run()
 {
-	m_timer.Stop();
+    m_timer.Stop();
 
-	// Initialize Google Test
-	::testing::InitGoogleTest();
+    // Initialize Google Test
+    ::testing::InitGoogleTest();
 
-	// Run all tests and return the result
-	int retVal = RUN_ALL_TESTS();
+    // Run all tests and return the result
+    int retVal = RUN_ALL_TESTS();
 
-	std::cout << "RUN_ALL_TESTS() return value: " << retVal << std::endl;
+    std::cout << "RUN_ALL_TESTS() return value: " << retVal << std::endl;
 
-	m_complete = true;
+    m_complete = true;
 }
 

IntegrationTest/IntegrationTest.h

@@ -12,26 +12,26 @@
 class IntegrationTest
 {
 public:
-	/// Get singleton instance of this class
-	static IntegrationTest& GetInstance();
+    /// Get singleton instance of this class
+    static IntegrationTest& GetInstance();
 
-	// Return true if integration test is complete
-	std::atomic<bool>& IsComplete() { return m_complete; }
+    // Return true if integration test is complete
+    std::atomic<bool>& IsComplete() { return m_complete; }
 
 private:
-	IntegrationTest();
-	~IntegrationTest();
+    IntegrationTest();
+    ~IntegrationTest();
 
-	// Called to run all integration tests
-	void Run();
+    // Called to run all integration tests
+    void Run();
 
-	// The integration test worker thread that executes Google Test
-	Thread m_thread;
+    // The integration test worker thread that executes Google Test
+    Thread m_thread;
 
-	// Timer to start integration tests
-	Timer m_timer;
+    // Timer to start integration tests
+    Timer m_timer;
 
-	std::atomic<bool> m_complete = false;
+    std::atomic<bool> m_complete = false;
 };
 
 #endif

IntegrationTest/SignalThread.h

@@ -14,34 +14,34 @@ class SignalThread
 {
 public:
     // Constructor initializes the signal to false
-    SignalThread() : m_signalSet(false) { }
+    SignalThread() : m_signalSet(false) {}
 
     // This function waits for the signal for a maximum of milliseconds. It
     // returns true if the signal was set within the timeout, false otherwise.
     // @param[in] ms - milliseconds to wait for signal
     // @return Returns true if signalled, false otherwise.
-    bool WaitForSignal(int ms) 
+    bool WaitForSignal(int ms)
     {
         std::unique_lock<std::mutex> lock(m_mutex);
 
         // Wait until the signal is set or the timeout expires
-        if (m_cv.wait_for(lock, std::chrono::milliseconds(ms), [this] { return m_signalSet; })) 
+        if (m_cv.wait_for(lock, std::chrono::milliseconds(ms), [this] { return m_signalSet; }))
         {
             // Reset the signal
-            m_signalSet = false; 
+            m_signalSet = false;
 
             // Signal was set within the timeout
             return true;
         }
-        else 
+        else
         {
             // Timeout expired
             return false;
         }
     }
 
     // This function sets the signal and notifies the waiting thread.
-    void SetSignal() 
+    void SetSignal()
     {
         std::lock_guard<std::mutex> lock(m_mutex);
         m_signalSet = true;

Logger/src/LogData.cpp

@@ -11,7 +11,7 @@ using namespace std;
 //----------------------------------------------------------------------------
 void LogData::Write(const std::string& msg)
 {
-	m_msgData.push_back(msg);
+    m_msgData.push_back(msg);
 }
 
 //----------------------------------------------------------------------------
@@ -25,9 +25,9 @@ bool LogData::Flush()
 
     // Write log data to disk
     std::ofstream logFile("LogData.txt", std::ios::app);
-    if (logFile.is_open()) 
+    if (logFile.is_open())
     {
-        for (const std::string& str : m_msgData) 
+        for (const std::string& str : m_msgData)
         {
             logFile << str << std::endl;
         }

Logger/src/LogData.h

@@ -12,25 +12,25 @@ class LogData
 {
 public:
 #ifdef IT_ENABLE
-	dmq::MulticastDelegateSafe<void(std::chrono::milliseconds)> FlushTimeDelegate;
+    dmq::MulticastDelegateSafe<void(std::chrono::milliseconds)> FlushTimeDelegate;
 #endif
 
-	LogData() { }
-	~LogData() { m_msgData.clear(); }
+    LogData() {}
+    ~LogData() { m_msgData.clear(); }
 
-	/// Write log data
-	/// @param[in] msg - data to log
-	void Write(const std::string& msg);	
+    /// Write log data
+    /// @param[in] msg - data to log
+    void Write(const std::string& msg);
 
-	/// Flush log data to disk
-	/// @return True if success. 
-	bool Flush();
+    /// Flush log data to disk
+    /// @return True if success. 
+    bool Flush();
 
 private:
-IT_PRIVATE_ACCESS:
+    IT_PRIVATE_ACCESS :
 
-	/// List to hold log data messages
-	std::list<std::string> m_msgData;
+    /// List to hold log data messages
+    std::list<std::string> m_msgData;
 };
 
 #endif