Added 5 tests and fixed a bug in the process!

.gitignore

@@ -14,6 +14,7 @@ x64/
 build/
 [Bb]in/
 [Oo]bj/
+Intermediate/
 
 # Enable "build/" folder in the NuGet Packages folder since NuGet packages use it for MSBuild targets
 !packages/*/build/

RemoteFileBrowser/RemoteFileBrowser/LoggingTests.cpp

@@ -1,18 +1,175 @@
 #include "PrecompiledHeader.h"
+
+#if _TESTBUILD
+
 #include "CppUnitTest.h"
+#include "Utilities\Utilities.h"
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace std;
+using namespace Utilities;
 
-namespace RemoteFileBrowser
+TEST_CLASS(LoggingTests)
 {
-	TEST_CLASS(LoggingTests)
+private:
+	wstring m_LogFileName;
+
+public:
+	LoggingTests() :
+		m_LogFileName(Logging::GetLogFileName())
 	{
-	public:
-
-		TEST_METHOD(TestMethod1)
+	}
+
+	template <typename LogAction, typename AssertAction>
+	void DoTest(LogAction logAction, AssertAction assertAction)
+	{
+		Logging::Initialize(true);
+		logAction();
+		Logging::Shutdown();
+
+		assertAction();
+	}
+
+	vector<wstring> GetLogFileContents()
+	{
+		wifstream in(m_LogFileName);
+		vector<wstring> input;
+		wstring line;
+
+		while (!in.eof())
 		{
-			// TODO: Your test code here
+			getline(in, line);
+
+			if (!in.fail())
+			{
+				input.push_back(move(line));
+			}
 		}
 
-	};
-}
+		return input;
+	}
+
+	void AssertEndsWith(const wstring& expected, const wstring& actual)
+	{
+		Assert::AreEqual(expected.c_str(), actual.c_str() + actual.length() - expected.length());
+	}
+
+	void AssertEndsWith(const vector<wstring>& expectedLines, const vector<wstring>& actualLines)
+	{
+		Assert::AreEqual(expectedLines.size(), actualLines.size());
+
+		for (auto i = 0u; i < actualLines.size(); i++)
+		{
+			AssertEndsWith(expectedLines[i], actualLines[i]);
+		}
+	}
+
+	TEST_METHOD(CanOutputMessage)
+	{
+		DoTest(
+			[]()
+			{
+				Logging::OutputMessage("Hello, world!");
+			},
+
+			[this]()
+			{
+				Assert::AreEqual(L"Hello, world!", GetLogFileContents()[0].c_str());
+			}
+		);
+	}
+
+	TEST_METHOD(CanLogOnce)
+	{
+		DoTest(
+			[]()
+			{
+				Logging::Log("Hello, world!");
+			},
+
+			[this]()
+			{
+				AssertEndsWith(L"Hello, world!", GetLogFileContents()[0]);
+			}
+		);
+	}
+
+	TEST_METHOD(CanLogMultipleMessages)
+	{
+		DoTest(
+			[]()
+			{
+				Logging::Log("Hell", "o, w", "orld!");
+			},
+
+			[this]()
+			{
+				AssertEndsWith(L"Hello, world!", GetLogFileContents()[0].c_str());
+			}
+		);
+	}
+
+	TEST_METHOD(CanLogMultipleTimes)
+	{
+		DoTest(
+			[]()
+			{
+				Logging::Log("Hello, world!");
+				Logging::Log("Hello, world!");
+				Logging::Log("Hello, world!");
+			},
+
+			[this]()
+			{
+				vector<wstring> expected;
+				expected.push_back(L"Hello, world!");
+				expected.push_back(L"Hello, world!");
+				expected.push_back(L"Hello, world!");
+				AssertEndsWith(expected, GetLogFileContents());
+			}
+		);
+	}
+
+	static const int kThreadCountForThreadSafeTest = 10;
+	static const int kMessagesPerThreadForThreadSafeTest = 20;
+
+	TEST_METHOD(LogIsThreadSafe)
+	{
+		DoTest(
+			[]()
+			{
+				thread threads[kThreadCountForThreadSafeTest];
+
+				for (int i = 0; i < kThreadCountForThreadSafeTest; i++)
+				{
+					threads[i] = thread([]()
+					{
+						for (int j = 0; j < kMessagesPerThreadForThreadSafeTest; j++)
+						{
+							Logging::Log("Hello, world!");							
+						}
+					});
+				}
+
+				for (int i = 0; i < kThreadCountForThreadSafeTest; i++)
+				{
+					threads[i].join();
+				}
+			},
+
+			[this]()
+			{
+				vector<wstring> expected;
+
+				for (int i = 0; i < kThreadCountForThreadSafeTest * kMessagesPerThreadForThreadSafeTest; i++)
+				{
+					expected.push_back(L"Hello, world!");
+				}
+
+				AssertEndsWith(expected, GetLogFileContents());
+			}
+		);
+	}
+};
+
+#endif // _TESTBUILD

RemoteFileBrowser/RemoteFileBrowser/RemoteFileBrowser.vcxproj

@@ -90,7 +90,7 @@
       <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_TESTBUILD;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
       <PrecompiledHeaderFile>PrecompiledHeader.h</PrecompiledHeaderFile>
       <AdditionalIncludeDirectories>$(ProjectDir)</AdditionalIncludeDirectories>

RemoteFileBrowser/RemoteFileBrowser/Utilities/CriticalSection.h

@@ -32,7 +32,7 @@ class CriticalSection
 		CriticalSection& m_Section;
 
 	public:
-		inline Lock(CriticalSection criticalSection) :
+		inline Lock(CriticalSection& criticalSection) :
 			m_Section(criticalSection)
 		{
 			m_Section.Enter();

RemoteFileBrowser/RemoteFileBrowser/Utilities/Utilities.cpp

@@ -10,9 +10,11 @@ CriticalSection Logging::s_LogCriticalSection;
 static HANDLE s_OutputFile;
 static const wchar_t kLogFileName[] = L"LogFile.log";
 
-void Logging::Initialize()
+void Logging::Initialize(bool forceOverwrite)
 {
-	s_OutputFile = CreateFile(kLogFileName, FILE_GENERIC_WRITE, FILE_SHARE_READ, nullptr, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, nullptr);
+	auto openMode = forceOverwrite ? CREATE_ALWAYS : CREATE_NEW;
+	s_OutputFile = CreateFile(kLogFileName, FILE_GENERIC_WRITE, FILE_SHARE_READ, nullptr, openMode, FILE_ATTRIBUTE_NORMAL, nullptr);
+	Assert(s_OutputFile != INVALID_HANDLE_VALUE || !forceOverwrite);
 
 	if (s_OutputFile == INVALID_HANDLE_VALUE)
 	{
@@ -28,13 +30,20 @@ void Logging::Initialize()
 		Assert(result != FALSE);
 		Assert(bytesWritten = sizeof(threeNewLines));
 	}
+
+	SetLastError(ERROR_SUCCESS);
 }
 
 void Logging::Shutdown()
 {
 	CloseHandle(s_OutputFile);
 }
 
+std::wstring Logging::GetLogFileName()
+{
+	return kLogFileName;
+}
+
 void Logging::OutputMessage(const char* message, size_t length)
 {
 	if (IsDebuggerPresent())
@@ -71,8 +80,8 @@ void Logging::OutputCurrentTimestamp()
 
 	char buffer[kBufferSize];
 	wchar_t wbuffer[kBufferSize];
-	SystemTimeToStringInline(wbuffer);
-	Encoding::Utf16ToUtf8Inline(wbuffer, buffer);
+	auto dateTimeLength = SystemTimeToStringInline(wbuffer);
+	Encoding::Utf16ToUtf8Inline(wbuffer, dateTimeLength, buffer, kBufferSize);
 
 	OutputMessage(buffer);
 	OutputMessage("] ");

RemoteFileBrowser/RemoteFileBrowser/Utilities/Utilities.h

@@ -32,8 +32,9 @@ namespace Utilities
 		template <typename ...Message>
 		static inline void LogFatalErrorIfFailed(bool failed, Message&& ...message);
 
-		static void Initialize();
+		static void Initialize(bool forceOverwrite = false);
 		static void Shutdown();
+		static std::wstring GetLogFileName();
 
 		Logging() = delete;
 		Logging(const Logging&) = delete;
@@ -58,18 +59,10 @@ namespace Utilities
 	namespace Encoding
 	{
 		size_t Utf8ToUtf16Inline(const char* str, size_t strLength, wchar_t* destination, size_t destinationLength);
-
-		template <size_t SourceLength, size_t DestinationLength>
-		inline size_t Utf8ToUtf16Inline(const char (&str)[SourceLength], wchar_t (&destination)[DestinationLength]);
-
 		std::wstring Utf8ToUtf16(const char* str, size_t strLength);
 		inline std::wstring Utf8ToUtf16(const std::string& str);
 
 		size_t Utf16ToUtf8Inline(const wchar_t* wstr, size_t wstrLength, char* destination, size_t destinationLength);
-
-		template <size_t SourceLength, size_t DestinationLength>
-		inline size_t Utf16ToUtf8Inline(const wchar_t (&wstr)[SourceLength], char (&destination)[DestinationLength]);
-
 		std::string Utf16ToUtf8(const wchar_t* wstr, size_t wstrLength);
 		inline std::string Utf16ToUtf8(const std::wstring& wstr);
 

RemoteFileBrowser/RemoteFileBrowser/Utilities/Utilities.inl

@@ -22,8 +22,8 @@ inline void Utilities::Logging::Win32ErrorToMessageInline(int win32ErrorCode, ch
 {
 	wchar_t wBuffer[kBufferSize];
 
-	FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, win32ErrorCode, 0, wBuffer, kBufferSize, nullptr);
-	Utilities::Encoding::Utf16ToUtf8Inline(wBuffer, buffer);
+	auto messageLength = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, win32ErrorCode, 0, wBuffer, kBufferSize, nullptr);
+	Utilities::Encoding::Utf16ToUtf8Inline(wBuffer, messageLength, buffer, kBufferSize);
 }
 
 template <typename Message>
@@ -118,23 +118,11 @@ inline void Utilities::Logging::LogFatalErrorIfFailed(bool failed, Message&& ...
 
 // Encoding
 
-template <size_t SourceLength, size_t DestinationLength>
-inline size_t Utilities::Encoding::Utf8ToUtf16Inline(const char (&str)[SourceLength], wchar_t (&destination)[DestinationLength])
-{
-	return Utf8ToUtf16Inline(str, SourceLength, destination, DestinationLength);
-}
-
 inline std::wstring Utilities::Encoding::Utf8ToUtf16(const std::string& str)
 {
 	return Utf8ToUtf16(str.c_str(), str.length());
 }
 
-template <size_t SourceLength, size_t DestinationLength>
-inline size_t Utilities::Encoding::Utf16ToUtf8Inline(const wchar_t(&wstr)[SourceLength], char(&destination)[DestinationLength])
-{
-	return Utf16ToUtf8Inline(wstr, SourceLength, destination, DestinationLength);
-}
-
 inline std::string Utilities::Encoding::Utf16ToUtf8(const std::wstring& wstr)
 {
 	return Utf16ToUtf8(wstr.c_str(), wstr.length());