Index: src/common/GTestMacros.h
===================================================================
diff -u -r301444777085263aae7aff911dd56722f302597e -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/common/GTestMacros.h	(.../GTestMacros.h)	(revision 301444777085263aae7aff911dd56722f302597e)
+++ src/common/GTestMacros.h	(.../GTestMacros.h)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -4,7 +4,7 @@
 #define EXPECT_TIMEOUT(handle)\
 	{\
 		DWORD dwResult = WaitForSingleObject(handle, 0); \
-		EXPECT_EQ(WAIT_TIMEOUT, dwResult); \
+		EXPECT_EQ((DWORD)WAIT_TIMEOUT, dwResult); \
 	}
 
 #define EXPECT_SIGNALED(handle)\
Index: src/libchcore/Tests/TestsTFileTime.cpp
===================================================================
diff -u -r776c47d61a5a67d5e2541d58013e221c685460ec -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchcore/Tests/TestsTFileTime.cpp	(.../TestsTFileTime.cpp)	(revision 776c47d61a5a67d5e2541d58013e221c685460ec)
+++ src/libchcore/Tests/TestsTFileTime.cpp	(.../TestsTFileTime.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -9,18 +9,18 @@
 {
 	TFileTime fTime;
 	EXPECT_EQ(0, fTime.ToUInt64());
-	EXPECT_EQ(0, fTime.GetAsFiletime().dwLowDateTime);
-	EXPECT_EQ(0, fTime.GetAsFiletime().dwHighDateTime);
+	EXPECT_EQ(0UL, fTime.GetAsFiletime().dwLowDateTime);
+	EXPECT_EQ(0UL, fTime.GetAsFiletime().dwHighDateTime);
 }
 
 TEST(TestsTFileTime, ConstructionFromFILETIME)
 {
 	FILETIME filetime = { 0x00000034, 0x00000045 };
 
 	TFileTime fTime(filetime);
-	EXPECT_EQ(0x0000004500000034, fTime.ToUInt64());
-	EXPECT_EQ(0x00000034, fTime.GetAsFiletime().dwLowDateTime);
-	EXPECT_EQ(0x00000045, fTime.GetAsFiletime().dwHighDateTime);
+	EXPECT_EQ(0x0000004500000034ULL, fTime.ToUInt64());
+	EXPECT_EQ(0x00000034UL, fTime.GetAsFiletime().dwLowDateTime);
+	EXPECT_EQ(0x00000045UL, fTime.GetAsFiletime().dwHighDateTime);
 }
 
 TEST(TestsTFileTime, AssignmentOperator)
@@ -30,9 +30,9 @@
 
 	TFileTime fTime(filetime1);
 	fTime = filetime2;
-	EXPECT_EQ(0x0000008500000074, fTime.ToUInt64());
-	EXPECT_EQ(0x00000074, fTime.GetAsFiletime().dwLowDateTime);
-	EXPECT_EQ(0x00000085, fTime.GetAsFiletime().dwHighDateTime);
+	EXPECT_EQ(0x0000008500000074ULL, fTime.ToUInt64());
+	EXPECT_EQ(0x00000074UL, fTime.GetAsFiletime().dwLowDateTime);
+	EXPECT_EQ(0x00000085UL, fTime.GetAsFiletime().dwHighDateTime);
 }
 
 TEST(TestsTFileTime, CompareOperator_Default)
Index: src/libchcore/Tests/TestsTPathContainer.cpp
===================================================================
diff -u -rbc3ebabeccf483d086fd58d06ddbc4d8a55c1dfc -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchcore/Tests/TestsTPathContainer.cpp	(.../TestsTPathContainer.cpp)	(revision bc3ebabeccf483d086fd58d06ddbc4d8a55c1dfc)
+++ src/libchcore/Tests/TestsTPathContainer.cpp	(.../TestsTPathContainer.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -10,7 +10,7 @@
 {
 	TPathContainer arrStrings;
 
-	EXPECT_EQ(0, arrStrings.GetCount());
+	EXPECT_EQ(0UL, arrStrings.GetCount());
 }
 
 TEST(TestsTPathContainer, AddElements)
@@ -20,7 +20,7 @@
 	arrStrings.Add(PathFromString(L"SomeString1"));
 	arrStrings.Add(PathFromString(L"SomeString2"));
 
-	EXPECT_EQ(2, arrStrings.GetCount());
+	EXPECT_EQ(2UL, arrStrings.GetCount());
 	EXPECT_STREQ(L"SomeString1", arrStrings.GetAt(0).ToWString().c_str());
 	EXPECT_STREQ(L"SomeString2", arrStrings.GetAt(1).ToWString().c_str());
 }
@@ -34,7 +34,7 @@
 
 	arrStrings.SetAt(0, PathFromString(L"SomeString3"));
 
-	EXPECT_EQ(2, arrStrings.GetCount());
+	EXPECT_EQ(2UL, arrStrings.GetCount());
 	EXPECT_STREQ(L"SomeString3", arrStrings.GetAt(0).ToWString().c_str());
 	EXPECT_STREQ(L"SomeString2", arrStrings.GetAt(1).ToWString().c_str());
 }
@@ -55,7 +55,7 @@
 
 	arrStrings.RemoveAt(0);
 
-	EXPECT_EQ(1, arrStrings.GetCount());
+	EXPECT_EQ(1UL, arrStrings.GetCount());
 	EXPECT_STREQ(L"SomeString2", arrStrings.GetAt(0).ToWString().c_str());
 }
 
@@ -75,7 +75,7 @@
 
 	arrStrings.Clear();
 
-	EXPECT_EQ(0, arrStrings.GetCount());
+	EXPECT_EQ(0UL, arrStrings.GetCount());
 }
 
 TEST(TestsTPathContainer, Compare_Empty)
Index: src/libchcore/Tests/TestsTSharedMemory.cpp
===================================================================
diff -u -r776c47d61a5a67d5e2541d58013e221c685460ec -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchcore/Tests/TestsTSharedMemory.cpp	(.../TestsTSharedMemory.cpp)	(revision 776c47d61a5a67d5e2541d58013e221c685460ec)
+++ src/libchcore/Tests/TestsTSharedMemory.cpp	(.../TestsTSharedMemory.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -13,8 +13,8 @@
 	TSharedMemory memory;
 	EXPECT_EQ(nullptr, memory.GetData());
 	EXPECT_EQ(nullptr, memory.GetFullData());
-	EXPECT_EQ(0, memory.GetDataSize());
-	EXPECT_EQ(0, memory.GetSharedMemorySize());
+	EXPECT_EQ(0UL, memory.GetDataSize());
+	EXPECT_EQ(0UL, memory.GetSharedMemorySize());
 }
 
 TEST(TestsTSharedMemory, Create_ZeroSize)
@@ -29,11 +29,11 @@
 	memory.Create(L"UnitTestsSharedMemoryName", 320);
 
 	EXPECT_TRUE(memory.GetData() != nullptr);
-	EXPECT_EQ(0, *(unsigned int*)memory.GetData());
+	EXPECT_EQ(0UL, *(unsigned int*)memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
-	EXPECT_EQ(4, *(unsigned int*)memory.GetFullData());
-	EXPECT_EQ(4, memory.GetDataSize());
-	EXPECT_EQ(324, memory.GetSharedMemorySize());
+	EXPECT_EQ(4UL, *(unsigned int*)memory.GetFullData());
+	EXPECT_EQ(4UL, memory.GetDataSize());
+	EXPECT_EQ(324UL, memory.GetSharedMemorySize());
 }
 
 TEST(TestsTSharedMemory, Create_FromEmptyString)
@@ -42,11 +42,11 @@
 	TSharedMemory memory;
 	memory.Create(L"UnitTestsSharedMemoryName", strData);
 	EXPECT_TRUE(memory.GetData() != nullptr);
-	EXPECT_EQ(0, *(unsigned int*)memory.GetData());
+	EXPECT_EQ(0UL, *(unsigned int*)memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
-	EXPECT_EQ(2, *(unsigned int*)memory.GetFullData());
-	EXPECT_EQ(2, memory.GetDataSize());
-	EXPECT_EQ(6, memory.GetSharedMemorySize());
+	EXPECT_EQ(2UL, *(unsigned int*)memory.GetFullData());
+	EXPECT_EQ(2UL, memory.GetDataSize());
+	EXPECT_EQ(6UL, memory.GetSharedMemorySize());
 }
 
 TEST(TestsTSharedMemory, Create_FromFullString)
@@ -58,8 +58,8 @@
 	EXPECT_EQ(L'S', *memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
 	EXPECT_EQ(22, *memory.GetFullData());
-	EXPECT_EQ(22, memory.GetDataSize());
-	EXPECT_EQ(26, memory.GetSharedMemorySize());
+	EXPECT_EQ(22UL, memory.GetDataSize());
+	EXPECT_EQ(26UL, memory.GetSharedMemorySize());
 }
 
 TEST(TestsTSharedMemory, Create_FromBufferZeroSize)
@@ -87,11 +87,11 @@
 	TSharedMemory memory;
 	memory.Create(L"UnitTestsSharedMemoryName", (BYTE*)pszData, 1);
 	EXPECT_TRUE(memory.GetData() != nullptr);
-	EXPECT_EQ(0, *(unsigned int*)memory.GetData());
+	EXPECT_EQ(0UL, *(unsigned int*)memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
-	EXPECT_EQ(1, *(unsigned int*)memory.GetFullData());
-	EXPECT_EQ(1, memory.GetDataSize());
-	EXPECT_EQ(5, memory.GetSharedMemorySize());
+	EXPECT_EQ(1UL, *(unsigned int*)memory.GetFullData());
+	EXPECT_EQ(1UL, memory.GetDataSize());
+	EXPECT_EQ(5UL, memory.GetSharedMemorySize());
 }
 
 TEST(TestsTSharedMemory, Create_FromFullBuffer)
@@ -103,8 +103,8 @@
 	EXPECT_EQ(L'S', *memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
 	EXPECT_EQ(4, *memory.GetFullData());
-	EXPECT_EQ(4, memory.GetDataSize());
-	EXPECT_EQ(8, memory.GetSharedMemorySize());
+	EXPECT_EQ(4UL, memory.GetDataSize());
+	EXPECT_EQ(8UL, memory.GetSharedMemorySize());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -123,8 +123,8 @@
 	EXPECT_EQ(L'S', *dstMemory.GetData());
 	EXPECT_TRUE(dstMemory.GetFullData() != nullptr);
 	EXPECT_EQ(4, *dstMemory.GetFullData());
-	EXPECT_EQ(4, dstMemory.GetDataSize());
-	EXPECT_EQ(8, dstMemory.GetSharedMemorySize());
+	EXPECT_EQ(4UL, dstMemory.GetDataSize());
+	EXPECT_EQ(8UL, dstMemory.GetSharedMemorySize());
 }
 
 TEST(TestsTSharedMemory, OpenNonExistentMemory)
@@ -147,8 +147,8 @@
 	EXPECT_EQ(L'S', *memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
 	EXPECT_EQ(22, *memory.GetFullData());
-	EXPECT_EQ(22, memory.GetDataSize());
-	EXPECT_EQ(260, memory.GetSharedMemorySize());
+	EXPECT_EQ(22UL, memory.GetDataSize());
+	EXPECT_EQ(260UL, memory.GetSharedMemorySize());
 
 	TString strReadData;
 	memory.Read(strReadData);
@@ -166,8 +166,8 @@
 	EXPECT_EQ(L'S', *memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
 	EXPECT_EQ(22, *memory.GetFullData());
-	EXPECT_EQ(22, memory.GetDataSize());
-	EXPECT_EQ(260, memory.GetSharedMemorySize());
+	EXPECT_EQ(22UL, memory.GetDataSize());
+	EXPECT_EQ(260UL, memory.GetSharedMemorySize());
 
 	TString strReadData;
 	memory.Read(strReadData);
@@ -188,8 +188,8 @@
 	EXPECT_EQ(L'S', *memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
 	EXPECT_EQ(22, *memory.GetFullData());
-	EXPECT_EQ(22, memory.GetDataSize());
-	EXPECT_EQ(26, memory.GetSharedMemorySize());
+	EXPECT_EQ(22UL, memory.GetDataSize());
+	EXPECT_EQ(26UL, memory.GetSharedMemorySize());
 
 	TString strReadData;
 	memory.Read(strReadData);
@@ -210,8 +210,8 @@
 	EXPECT_EQ(L'S', *memory.GetData());
 	EXPECT_TRUE(memory.GetFullData() != nullptr);
 	EXPECT_EQ(22, *memory.GetFullData());
-	EXPECT_EQ(22, memory.GetDataSize());
-	EXPECT_EQ(26, memory.GetSharedMemorySize());
+	EXPECT_EQ(22UL, memory.GetDataSize());
+	EXPECT_EQ(26UL, memory.GetSharedMemorySize());
 
 	TString strReadData;
 	memory.Read(strReadData);
Index: src/libchcore/Tests/TestsTSmartPath.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchcore/Tests/TestsTSmartPath.cpp	(.../TestsTSmartPath.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libchcore/Tests/TestsTSmartPath.cpp	(.../TestsTSmartPath.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -132,7 +132,7 @@
 	path.FromString(_T("c:\\First path\\some directory\\file.txt"));
 	path.SplitPath(vPaths);
 
-	EXPECT_EQ(4, vPaths.GetCount());
+	EXPECT_EQ(4UL, vPaths.GetCount());
 	EXPECT_STREQ(_T("c:"), vPaths.GetAt(0).ToString());
 	EXPECT_STREQ(_T("First path"), vPaths.GetAt(1).ToString());
 	EXPECT_STREQ(_T("some directory"), vPaths.GetAt(2).ToString());
@@ -147,7 +147,7 @@
 	path.FromString(_T(""));
 	path.SplitPath(vPaths);
 
-	EXPECT_EQ(0, vPaths.GetCount());
+	EXPECT_EQ(0UL, vPaths.GetCount());
 }
 
 TEST(TSmartPathTests, CompareLTGTCaseInsensitive)
@@ -1092,20 +1092,20 @@
 {
 	TSmartPath path;
 	path.FromString(_T(""));
-	EXPECT_EQ(0, path.GetLength());
+	EXPECT_EQ(0UL, path.GetLength());
 }
 
 TEST(TSmartPathTests, GetLength_NotInitializedEmpty)
 {
 	TSmartPath path;
-	EXPECT_EQ(0, path.GetLength());
+	EXPECT_EQ(0UL, path.GetLength());
 }
 
 TEST(TSmartPathTests, GetLength_NotEmpty)
 {
 	TSmartPath path;
 	path.FromString(_T("some path"));
-	EXPECT_EQ(9, path.GetLength());
+	EXPECT_EQ(9UL, path.GetLength());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
Index: src/libchengine/Tests/TBufferListTests.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TBufferListTests.cpp	(.../TBufferListTests.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libchengine/Tests/TBufferListTests.cpp	(.../TBufferListTests.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -11,7 +11,7 @@
 {
 	TBufferList bufferList;
 
-	EXPECT_EQ(0, bufferList.GetCount());
+	EXPECT_EQ(0UL, bufferList.GetCount());
 	EXPECT_EQ(true, bufferList.IsEmpty());
 	EXPECT_EQ(nullptr, bufferList.Pop());
 }
@@ -31,7 +31,7 @@
 
 	bufferList.Push(&rBuffer);
 
-	EXPECT_EQ(1, bufferList.GetCount());
+	EXPECT_EQ(1UL, bufferList.GetCount());
 	EXPECT_EQ(false, bufferList.IsEmpty());
 	EXPECT_EQ(&rBuffer, bufferList.Pop());
 }
@@ -45,7 +45,7 @@
 	bufferList.Push(&rBuffer);
 	bufferList.Clear();
 
-	EXPECT_EQ(0, bufferList.GetCount());
+	EXPECT_EQ(0UL, bufferList.GetCount());
 	EXPECT_EQ(true, bufferList.IsEmpty());
 	EXPECT_EQ(nullptr, bufferList.Pop());
 }
Index: src/libchengine/Tests/TOrderedBufferQueueTests.cpp
===================================================================
diff -u -r301444777085263aae7aff911dd56722f302597e -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TOrderedBufferQueueTests.cpp	(.../TOrderedBufferQueueTests.cpp)	(revision 301444777085263aae7aff911dd56722f302597e)
+++ src/libchengine/Tests/TOrderedBufferQueueTests.cpp	(.../TOrderedBufferQueueTests.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -23,7 +23,7 @@
 	TBufferListPtr spEmptyBuffers(std::make_shared<TBufferList>());
 	TOrderedBufferQueue queue(spEmptyBuffers, 0);
 
-	EXPECT_EQ(0, queue.GetCount());
+	EXPECT_EQ(0UL, queue.GetCount());
 	EXPECT_EQ(true, queue.IsEmpty());
 	EXPECT_TIMEOUT(queue.GetHasBuffersEvent());
 	EXPECT_EQ(nullptr, queue.Peek());
@@ -38,7 +38,7 @@
 
 	queue.Push(&buffer);
 
-	EXPECT_EQ(1, queue.GetCount());
+	EXPECT_EQ(1UL, queue.GetCount());
 	EXPECT_EQ(false, queue.IsEmpty());
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer, queue.Peek());
@@ -53,7 +53,7 @@
 
 	queue.Push(&buffer);
 
-	EXPECT_EQ(1, queue.GetCount());
+	EXPECT_EQ(1UL, queue.GetCount());
 	EXPECT_EQ(false, queue.IsEmpty());
 	EXPECT_TIMEOUT(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer, queue.Peek());
@@ -74,7 +74,7 @@
 	queue.Push(&buffer1);
 	queue.Push(&buffer2);
 
-	EXPECT_EQ(2, queue.GetCount());
+	EXPECT_EQ(2UL, queue.GetCount());
 	EXPECT_EQ(false, queue.IsEmpty());
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer2, queue.Peek());
@@ -91,7 +91,7 @@
 	queue.Push(&buffer);
 	EXPECT_EQ(&buffer, queue.Pop());
 
-	EXPECT_EQ(0, queue.GetCount());
+	EXPECT_EQ(0UL, queue.GetCount());
 	EXPECT_EQ(true, queue.IsEmpty());
 	EXPECT_TIMEOUT(queue.GetHasBuffersEvent());
 	EXPECT_EQ(nullptr, queue.Peek());
@@ -106,7 +106,7 @@
 	queue.Push(&buffer);
 	queue.ClearBuffers();
 
-	EXPECT_EQ(1, spEmptyBuffers->GetCount());
+	EXPECT_EQ(1UL, spEmptyBuffers->GetCount());
 }
 
 TEST(TOrderedBufferQueueTests, ExpectedPos_ReleaseBuffersUnordered)
@@ -119,7 +119,7 @@
 	queue.Push(&buffer);
 	queue.ClearBuffers();
 
-	EXPECT_EQ(1, spEmptyBuffers->GetCount());
+	EXPECT_EQ(1UL, spEmptyBuffers->GetCount());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -133,7 +133,7 @@
 	TBufferListPtr spEmptyBuffers(std::make_shared<TBufferList>());
 	TOrderedBufferQueue queue(spEmptyBuffers, 0);
 
-	EXPECT_EQ(0, queue.GetCount());
+	EXPECT_EQ(0UL, queue.GetCount());
 	EXPECT_TIMEOUT(queue.GetHasErrorEvent());
 	EXPECT_EQ(true, queue.IsEmpty());
 }
@@ -151,7 +151,7 @@
 	FallbackCollection collection;
 
 	queue.PushError(&buffer, collection);
-	EXPECT_EQ(1, queue.GetCount());
+	EXPECT_EQ(1UL, queue.GetCount());
 	EXPECT_SIGNALED(queue.GetHasErrorEvent());
 	EXPECT_EQ(true, collection.empty());
 }
@@ -172,12 +172,12 @@
 	queue.PushError(&buffer1, collection);
 	queue.PushError(&buffer2, collection);
 
-	EXPECT_EQ(1, queue.GetCount());
+	EXPECT_EQ(1UL, queue.GetCount());
 	EXPECT_SIGNALED(queue.GetHasErrorEvent());
-	EXPECT_EQ(1, collection.size());
+	EXPECT_EQ(1UL, collection.size());
 	EXPECT_EQ(&buffer2, collection.front());
 	EXPECT_EQ(1000, collection.front()->GetFilePosition());
-	EXPECT_EQ(0, collection.front()->GetErrorCode());
+	EXPECT_EQ(0UL, collection.front()->GetErrorCode());
 }
 
 TEST(TOrderedBufferQueueTests, PushBuffer_TwoFailuresOutOfOrder)
@@ -196,12 +196,12 @@
 	queue.PushError(&buffer2, collection);
 	queue.PushError(&buffer1, collection);
 
-	EXPECT_EQ(1, queue.GetCount());
+	EXPECT_EQ(1UL, queue.GetCount());
 	EXPECT_SIGNALED(queue.GetHasErrorEvent());
-	EXPECT_EQ(1, collection.size());
+	EXPECT_EQ(1UL, collection.size());
 	EXPECT_EQ(&buffer2, collection.front());
 	EXPECT_EQ(1000, collection.front()->GetFilePosition());
-	EXPECT_EQ(0, collection.front()->GetErrorCode());
+	EXPECT_EQ(0UL, collection.front()->GetErrorCode());
 }
 
 TEST(TOrderedBufferQueueTests, PushBuffer_ThrowOnNonErrorBuffer)
@@ -244,10 +244,10 @@
 	queue.PushError(&buffer1, collection);
 	queue.PopError();
 
-	EXPECT_EQ(0, collection.size());
+	EXPECT_EQ(0UL, collection.size());
 	EXPECT_TIMEOUT(queue.GetHasErrorEvent());
 
 	queue.PushError(&buffer2, collection);
-	EXPECT_EQ(0, queue.GetCount());
-	EXPECT_EQ(1, collection.size());
+	EXPECT_EQ(0UL, queue.GetCount());
+	EXPECT_EQ(1UL, collection.size());
 }
Index: src/libchengine/Tests/TOverlappedDataBufferTests.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TOverlappedDataBufferTests.cpp	(.../TOverlappedDataBufferTests.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libchengine/Tests/TOverlappedDataBufferTests.cpp	(.../TOverlappedDataBufferTests.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -34,13 +34,13 @@
 	TOverlappedDataBuffer buffer(32768, &iParam);
 
 	EXPECT_NE(nullptr, buffer.GetBufferPtr());
-	EXPECT_EQ(32768, buffer.GetBufferSize());
-	EXPECT_EQ(0, buffer.GetBytesTransferred());
-	EXPECT_EQ(0, buffer.GetErrorCode());
+	EXPECT_EQ(32768UL, buffer.GetBufferSize());
+	EXPECT_EQ(0UL, buffer.GetBytesTransferred());
+	EXPECT_EQ(0UL, buffer.GetErrorCode());
 	EXPECT_EQ(0, buffer.GetFilePosition());
-	EXPECT_EQ(0, buffer.GetRealDataSize());
-	EXPECT_EQ(0, buffer.GetRequestedDataSize());
-	EXPECT_EQ(0, buffer.GetStatusCode());
+	EXPECT_EQ(0UL, buffer.GetRealDataSize());
+	EXPECT_EQ(0UL, buffer.GetRequestedDataSize());
+	EXPECT_EQ(0UL, buffer.GetStatusCode());
 	EXPECT_FALSE(buffer.IsLastPart());
 }
 
@@ -83,7 +83,7 @@
 	buffer.ReinitializeBuffer(16384);
 
 	EXPECT_NE(nullptr, buffer.GetBufferPtr());
-	EXPECT_EQ(16384, buffer.GetBufferSize());
+	EXPECT_EQ(16384UL, buffer.GetBufferSize());
 }
 
 TEST(TOverlappedDataBufferTests, ReinitializeBuffer_IncreaseSize)
@@ -93,7 +93,7 @@
 	buffer.ReinitializeBuffer(32768);
 
 	EXPECT_NE(nullptr, buffer.GetBufferPtr());
-	EXPECT_EQ(32768, buffer.GetBufferSize());
+	EXPECT_EQ(32768UL, buffer.GetBufferSize());
 }
 
 TEST(TOverlappedDataBufferTests, ReinitializeBuffer_SameSize)
@@ -116,7 +116,7 @@
 
 	buffer.SetRequestedDataSize(123);
 
-	EXPECT_EQ(123, buffer.GetRequestedDataSize());
+	EXPECT_EQ(123UL, buffer.GetRequestedDataSize());
 }
 
 TEST(TOverlappedDataBufferTests, SetRealDataSize_GetRealDataSize)
@@ -125,7 +125,7 @@
 
 	buffer.SetRealDataSize(123);
 
-	EXPECT_EQ(123, buffer.GetRealDataSize());
+	EXPECT_EQ(123UL, buffer.GetRealDataSize());
 }
 
 TEST(TOverlappedDataBufferTests, SetLastPart_IsLastPart)
@@ -143,7 +143,7 @@
 
 	buffer.SetErrorCode(123);
 
-	EXPECT_EQ(123, buffer.GetErrorCode());
+	EXPECT_EQ(123UL, buffer.GetErrorCode());
 }
 
 TEST(TOverlappedDataBufferTests, SetStatusCode_GetStatusCode)
@@ -152,7 +152,7 @@
 
 	buffer.SetStatusCode(123);
 
-	EXPECT_EQ(123, buffer.GetStatusCode());
+	EXPECT_EQ(123UL, buffer.GetStatusCode());
 }
 
 TEST(TOverlappedDataBufferTests, SetBytesTransferred_GetBytesTransferred)
@@ -161,7 +161,7 @@
 
 	buffer.SetBytesTransferred(123);
 
-	EXPECT_EQ(123, buffer.GetBytesTransferred());
+	EXPECT_EQ(123UL, buffer.GetBytesTransferred());
 }
 
 TEST(TOverlappedDataBufferTests, GetFilePosition_SetFilePosition)
@@ -189,13 +189,13 @@
 
 	buffer.InitForRead(320, 600);
 
-	EXPECT_EQ(600, buffer.GetRequestedDataSize());
+	EXPECT_EQ(600UL, buffer.GetRequestedDataSize());
 	EXPECT_EQ(320, buffer.GetFilePosition());
-	EXPECT_EQ(0, buffer.GetRealDataSize());
+	EXPECT_EQ(0UL, buffer.GetRealDataSize());
 	EXPECT_EQ(false, buffer.IsLastPart());
-	EXPECT_EQ(0, buffer.GetErrorCode());
-	EXPECT_EQ(0, buffer.GetStatusCode());
-	EXPECT_EQ(0, buffer.GetBytesTransferred());
+	EXPECT_EQ(0UL, buffer.GetErrorCode());
+	EXPECT_EQ(0UL, buffer.GetStatusCode());
+	EXPECT_EQ(0UL, buffer.GetBytesTransferred());
 }
 
 TEST(TOverlappedDataBufferTests, InitForWrite)
@@ -212,9 +212,9 @@
 
 	buffer.InitForWrite();
 
-	EXPECT_EQ(0, buffer.GetErrorCode());
-	EXPECT_EQ(0, buffer.GetStatusCode());
-	EXPECT_EQ(0, buffer.GetBytesTransferred());
+	EXPECT_EQ(0UL, buffer.GetErrorCode());
+	EXPECT_EQ(0UL, buffer.GetStatusCode());
+	EXPECT_EQ(0UL, buffer.GetBytesTransferred());
 }
 
 TEST(TOverlappedDataBufferTests, Reset)
@@ -232,13 +232,13 @@
 
 	buffer.Reset();
 
-	EXPECT_EQ(0, buffer.GetRequestedDataSize());
+	EXPECT_EQ(0UL, buffer.GetRequestedDataSize());
 	EXPECT_EQ(0, buffer.GetFilePosition());
-	EXPECT_EQ(0, buffer.GetRealDataSize());
+	EXPECT_EQ(0UL, buffer.GetRealDataSize());
 	EXPECT_EQ(false, buffer.IsLastPart());
-	EXPECT_EQ(0, buffer.GetErrorCode());
-	EXPECT_EQ(0, buffer.GetStatusCode());
-	EXPECT_EQ(0, buffer.GetBytesTransferred());
+	EXPECT_EQ(0UL, buffer.GetErrorCode());
+	EXPECT_EQ(0UL, buffer.GetStatusCode());
+	EXPECT_EQ(0UL, buffer.GetBytesTransferred());
 	EXPECT_EQ(nullptr, buffer.GetParam());
 }
 
Index: src/libchengine/Tests/TOverlappedMemoryPoolTests.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TOverlappedMemoryPoolTests.cpp	(.../TOverlappedMemoryPoolTests.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libchengine/Tests/TOverlappedMemoryPoolTests.cpp	(.../TOverlappedMemoryPoolTests.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -15,11 +15,11 @@
 	TOverlappedMemoryPoolPtr spBuffers(std::make_shared<TOverlappedMemoryPool>(3, 32768));
 	TBufferListPtr spBufferList = spBuffers->GetBufferList();
 
-	EXPECT_EQ(3, spBufferList->GetCount());
+	EXPECT_EQ(3UL, spBufferList->GetCount());
 
-	EXPECT_EQ(32768, spBufferList->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBufferList->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBufferList->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBufferList->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBufferList->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBufferList->Pop()->GetBufferSize());
 	EXPECT_EQ(nullptr, spBufferList->Pop());
 }
 
@@ -49,12 +49,12 @@
 	TOverlappedMemoryPoolPtr spBuffers(std::make_shared<TOverlappedMemoryPool>(3, 32768));
 	spBuffers->ReinitializeBuffers(3, 32768);
 
-	EXPECT_EQ(3, spBuffers->GetTotalBufferCount());
-	EXPECT_EQ(32768, spBuffers->GetSingleBufferSize());
+	EXPECT_EQ(3UL, spBuffers->GetTotalBufferCount());
+	EXPECT_EQ(32768UL, spBuffers->GetSingleBufferSize());
 
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
 	EXPECT_EQ(nullptr, spBuffers->GetBufferList()->Pop());
 }
 
@@ -65,12 +65,12 @@
 	TOverlappedMemoryPoolPtr spBuffers(std::make_shared<TOverlappedMemoryPool>(3, 32768));
 	spBuffers->ReinitializeBuffers(3, 65536);
 
-	EXPECT_EQ(3, spBuffers->GetTotalBufferCount());
-	EXPECT_EQ(65536, spBuffers->GetSingleBufferSize());
+	EXPECT_EQ(3UL, spBuffers->GetTotalBufferCount());
+	EXPECT_EQ(65536UL, spBuffers->GetSingleBufferSize());
 
-	EXPECT_EQ(65536, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(65536, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(65536, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(65536UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(65536UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(65536UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
 	EXPECT_EQ(nullptr, spBuffers->GetBufferList()->Pop());
 }
 
@@ -81,12 +81,12 @@
 	TOverlappedMemoryPoolPtr spBuffers(std::make_shared<TOverlappedMemoryPool>(3, 65536));
 	spBuffers->ReinitializeBuffers(3, 32768);
 
-	EXPECT_EQ(3, spBuffers->GetTotalBufferCount());
-	EXPECT_EQ(32768, spBuffers->GetSingleBufferSize());
+	EXPECT_EQ(3UL, spBuffers->GetTotalBufferCount());
+	EXPECT_EQ(32768UL, spBuffers->GetSingleBufferSize());
 
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
 	EXPECT_EQ(nullptr, spBuffers->GetBufferList()->Pop());
 }
 
@@ -97,14 +97,14 @@
 	TOverlappedMemoryPoolPtr spBuffers(std::make_shared<TOverlappedMemoryPool>(3, 32768));
 	spBuffers->ReinitializeBuffers(5, 32768);
 
-	EXPECT_EQ(5, spBuffers->GetTotalBufferCount());
-	EXPECT_EQ(32768, spBuffers->GetSingleBufferSize());
+	EXPECT_EQ(5UL, spBuffers->GetTotalBufferCount());
+	EXPECT_EQ(32768UL, spBuffers->GetSingleBufferSize());
 
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
 	EXPECT_EQ(nullptr, spBuffers->GetBufferList()->Pop());
 }
 
@@ -115,11 +115,11 @@
 	TOverlappedMemoryPoolPtr spBuffers(std::make_shared<TOverlappedMemoryPool>(5, 32768));
 	spBuffers->ReinitializeBuffers(3, 32768);
 
-	EXPECT_EQ(3, spBuffers->GetTotalBufferCount());
-	EXPECT_EQ(32768, spBuffers->GetSingleBufferSize());
+	EXPECT_EQ(3UL, spBuffers->GetTotalBufferCount());
+	EXPECT_EQ(32768UL, spBuffers->GetSingleBufferSize());
 
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
-	EXPECT_EQ(32768, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
+	EXPECT_EQ(32768UL, spBuffers->GetBufferList()->Pop()->GetBufferSize());
 	EXPECT_EQ(nullptr, spBuffers->GetBufferList()->Pop());
 }
Index: src/libchengine/Tests/TReadBufferQueueWrapperTests.cpp
===================================================================
diff -u -r301444777085263aae7aff911dd56722f302597e -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TReadBufferQueueWrapperTests.cpp	(.../TReadBufferQueueWrapperTests.cpp)	(revision 301444777085263aae7aff911dd56722f302597e)
+++ src/libchengine/Tests/TReadBufferQueueWrapperTests.cpp	(.../TReadBufferQueueWrapperTests.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -58,19 +58,19 @@
 
 	EXPECT_EQ(&buffer4, queue.Pop());
 	EXPECT_EQ(0, buffer4.GetFilePosition());
-	EXPECT_EQ(1024, buffer4.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer4.GetRequestedDataSize());
 
 	EXPECT_EQ(&buffer3, queue.Pop());
 	EXPECT_EQ(1024, buffer3.GetFilePosition());
-	EXPECT_EQ(1024, buffer3.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer3.GetRequestedDataSize());
 
 	EXPECT_EQ(&buffer2, queue.Pop());
 	EXPECT_EQ(2048, buffer2.GetFilePosition());
-	EXPECT_EQ(1024, buffer2.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer2.GetRequestedDataSize());
 
 	EXPECT_EQ(&buffer1, queue.Pop());
 	EXPECT_EQ(3072, buffer1.GetFilePosition());
-	EXPECT_EQ(1024, buffer1.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer1.GetRequestedDataSize());
 
 	EXPECT_EQ(nullptr, queue.Pop());
 }
@@ -95,22 +95,22 @@
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer4, queue.Pop());
 	EXPECT_EQ(0, buffer4.GetFilePosition());
-	EXPECT_EQ(1024, buffer4.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer4.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer3, queue.Pop());
 	EXPECT_EQ(1024, buffer3.GetFilePosition());
-	EXPECT_EQ(1024, buffer3.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer3.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer2, queue.Pop());
 	EXPECT_EQ(2048, buffer2.GetFilePosition());
-	EXPECT_EQ(1024, buffer2.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer2.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer1, queue.Pop());
 	EXPECT_EQ(3072, buffer1.GetFilePosition());
-	EXPECT_EQ(1024, buffer1.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer1.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(nullptr, queue.Pop());
@@ -138,22 +138,22 @@
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer4, queue.Pop());
 	EXPECT_EQ(0, buffer4.GetFilePosition());
-	EXPECT_EQ(1024, buffer4.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer4.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer3, queue.Pop());
 	EXPECT_EQ(1024, buffer3.GetFilePosition());
-	EXPECT_EQ(1024, buffer3.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer3.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer2, queue.Pop());
 	EXPECT_EQ(2048, buffer2.GetFilePosition());
-	EXPECT_EQ(1024, buffer2.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer2.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer1, queue.Pop());
 	EXPECT_EQ(3072, buffer1.GetFilePosition());
-	EXPECT_EQ(1024, buffer1.GetRequestedDataSize());
+	EXPECT_EQ(1024UL, buffer1.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(nullptr, queue.Pop());
@@ -218,7 +218,7 @@
 
 	EXPECT_EQ(&buffer1, queue.Pop());
 
-	EXPECT_EQ(0, spList->GetCount());
+	EXPECT_EQ(0UL, spList->GetCount());
 	EXPECT_EQ(nullptr, spList->Pop());
 }
 
@@ -236,14 +236,14 @@
 
 	queue.SetDataSourceFinished(&buffer1);
 
-	EXPECT_EQ(0, spList->GetCount());
+	EXPECT_EQ(0UL, spList->GetCount());
 
 	TOverlappedDataBuffer buffer2(1024, nullptr);
 	buffer2.SetLastPart(true);
 	queue.Push(&buffer2);
 
 	EXPECT_EQ(&buffer1, queue.Pop());
-	EXPECT_EQ(1, spList->GetCount());
+	EXPECT_EQ(1UL, spList->GetCount());
 	EXPECT_EQ(&buffer2, spList->Pop());
 }
 
@@ -263,7 +263,7 @@
 	queue.SetDataSourceFinished(&buffer1);
 
 	EXPECT_EQ(&buffer1, queue.Pop());
-	EXPECT_EQ(0, spList->GetCount());
+	EXPECT_EQ(0UL, spList->GetCount());
 
 	TOverlappedDataBuffer buffer2(1024, nullptr);
 	buffer2.SetFilePosition(1000);
Index: src/libchengine/Tests/TSimpleOrderedBufferQueueTests.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TSimpleOrderedBufferQueueTests.cpp	(.../TSimpleOrderedBufferQueueTests.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libchengine/Tests/TSimpleOrderedBufferQueueTests.cpp	(.../TSimpleOrderedBufferQueueTests.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -12,7 +12,7 @@
 {
 	TSimpleOrderedBufferQueue queue;
 
-	EXPECT_EQ(0, queue.GetCount());
+	EXPECT_EQ(0UL, queue.GetCount());
 	EXPECT_EQ(true, queue.IsEmpty());
 	EXPECT_EQ(nullptr, queue.Peek());
 }
@@ -24,7 +24,7 @@
 
 	queue.Push(&buffer);
 
-	EXPECT_EQ(1, queue.GetCount());
+	EXPECT_EQ(1UL, queue.GetCount());
 	EXPECT_EQ(false, queue.IsEmpty());
 	EXPECT_EQ(&buffer, queue.Peek());
 }
@@ -46,7 +46,7 @@
 	queue.Push(&buffer);
 	EXPECT_EQ(&buffer, queue.Pop());
 
-	EXPECT_EQ(0, queue.GetCount());
+	EXPECT_EQ(0UL, queue.GetCount());
 	EXPECT_EQ(true, queue.IsEmpty());
 	EXPECT_EQ(nullptr, queue.Peek());
 }
@@ -60,7 +60,7 @@
 	queue.Push(&buffer);
 	queue.ClearBuffers(spEmptyBuffers);
 
-	EXPECT_EQ(0, queue.GetCount());
+	EXPECT_EQ(0UL, queue.GetCount());
 	EXPECT_EQ(true, queue.IsEmpty());
 	EXPECT_EQ(nullptr, queue.Peek());
 }
@@ -74,5 +74,5 @@
 	queue.Push(&buffer);
 	queue.ClearBuffers(spReleaseList);
 
-	EXPECT_EQ(1, spReleaseList->GetCount());
+	EXPECT_EQ(1UL, spReleaseList->GetCount());
 }
Index: src/libchengine/Tests/TWriteBufferQueueWrapperTests.cpp
===================================================================
diff -u -r301444777085263aae7aff911dd56722f302597e -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TWriteBufferQueueWrapperTests.cpp	(.../TWriteBufferQueueWrapperTests.cpp)	(revision 301444777085263aae7aff911dd56722f302597e)
+++ src/libchengine/Tests/TWriteBufferQueueWrapperTests.cpp	(.../TWriteBufferQueueWrapperTests.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -20,7 +20,7 @@
 
 	TSharedCountPtr<size_t> spOtfBufferCount(std::make_shared<TSharedCount<size_t>>());
 	TWriteBufferQueueWrapper queue(spQueue, 1, spOtfBufferCount);
-	EXPECT_EQ(0, queue.GetCount());
+	EXPECT_EQ(0UL, queue.GetCount());
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 }
 
@@ -63,19 +63,19 @@
 
 	EXPECT_EQ(&buffer1, queue.Pop());
 	EXPECT_EQ(0, buffer1.GetFilePosition());
-	EXPECT_EQ(1000, buffer1.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer1.GetRequestedDataSize());
 
 	EXPECT_EQ(&buffer2, queue.Pop());
 	EXPECT_EQ(1000, buffer2.GetFilePosition());
-	EXPECT_EQ(1000, buffer2.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer2.GetRequestedDataSize());
 
 	EXPECT_EQ(&buffer3, queue.Pop());
 	EXPECT_EQ(2000, buffer3.GetFilePosition());
-	EXPECT_EQ(1000, buffer3.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer3.GetRequestedDataSize());
 
 	EXPECT_EQ(&buffer4, queue.Pop());
 	EXPECT_EQ(3000, buffer4.GetFilePosition());
-	EXPECT_EQ(1000, buffer4.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer4.GetRequestedDataSize());
 
 	EXPECT_EQ(nullptr, queue.Pop());
 }
@@ -109,22 +109,22 @@
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer1, queue.Pop());
 	EXPECT_EQ(0, buffer1.GetFilePosition());
-	EXPECT_EQ(1000, buffer1.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer1.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer2, queue.Pop());
 	EXPECT_EQ(1000, buffer2.GetFilePosition());
-	EXPECT_EQ(1000, buffer2.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer2.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer3, queue.Pop());
 	EXPECT_EQ(2000, buffer3.GetFilePosition());
-	EXPECT_EQ(1000, buffer3.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer3.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer4, queue.Pop());
 	EXPECT_EQ(3000, buffer4.GetFilePosition());
-	EXPECT_EQ(1000, buffer4.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer4.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(nullptr, queue.Pop());
@@ -161,22 +161,22 @@
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer3, queue.Pop());
 	EXPECT_EQ(2000, buffer3.GetFilePosition());
-	EXPECT_EQ(1000, buffer3.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer3.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer4, queue.Pop());
 	EXPECT_EQ(3000, buffer4.GetFilePosition());
-	EXPECT_EQ(1000, buffer4.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer4.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer1, queue.Pop());
 	EXPECT_EQ(0, buffer1.GetFilePosition());
-	EXPECT_EQ(1000, buffer1.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer1.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(&buffer2, queue.Pop());
 	EXPECT_EQ(1000, buffer2.GetFilePosition());
-	EXPECT_EQ(1000, buffer2.GetRequestedDataSize());
+	EXPECT_EQ(1000UL, buffer2.GetRequestedDataSize());
 
 	EXPECT_SIGNALED(queue.GetHasBuffersEvent());
 	EXPECT_EQ(nullptr, queue.Pop());
Index: src/libchengine/Tests/TestsTBufferSizes.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TestsTBufferSizes.cpp	(.../TestsTBufferSizes.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libchengine/Tests/TestsTBufferSizes.cpp	(.../TestsTBufferSizes.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -23,16 +23,16 @@
 {
 	TBufferSizes tSizes(true, 2, 4096, 8192, 16384, 32768, 65536, 10, 2, 1);
 
-	EXPECT_EQ(2, tSizes.GetBufferCount());
-	EXPECT_EQ(4096, tSizes.GetDefaultSize());
-	EXPECT_EQ(8192, tSizes.GetOneDiskSize());
-	EXPECT_EQ(16384, tSizes.GetTwoDisksSize());
-	EXPECT_EQ(32768, tSizes.GetCDSize());
-	EXPECT_EQ(65536, tSizes.GetLANSize());
+	EXPECT_EQ(2UL, tSizes.GetBufferCount());
+	EXPECT_EQ(4096UL, tSizes.GetDefaultSize());
+	EXPECT_EQ(8192UL, tSizes.GetOneDiskSize());
+	EXPECT_EQ(16384UL, tSizes.GetTwoDisksSize());
+	EXPECT_EQ(32768UL, tSizes.GetCDSize());
+	EXPECT_EQ(65536UL, tSizes.GetLANSize());
 	EXPECT_EQ(true, tSizes.IsOnlyDefault());
-	EXPECT_EQ(10, tSizes.GetMaxReadAheadBuffers());
-	EXPECT_EQ(2, tSizes.GetMaxConcurrentReads());
-	EXPECT_EQ(1, tSizes.GetMaxConcurrentWrites());
+	EXPECT_EQ(10UL, tSizes.GetMaxReadAheadBuffers());
+	EXPECT_EQ(2UL, tSizes.GetMaxConcurrentReads());
+	EXPECT_EQ(1UL, tSizes.GetMaxConcurrentWrites());
 }
 
 TEST(TestsTBufferSizes, ParametrizedConstructor_MinimumCheck)
@@ -46,25 +46,25 @@
 	EXPECT_EQ(TBufferSizes::BufferGranularity, tSizes.GetCDSize());
 	EXPECT_EQ(TBufferSizes::BufferGranularity, tSizes.GetLANSize());
 	EXPECT_EQ(true, tSizes.IsOnlyDefault());
-	EXPECT_EQ(1, tSizes.GetMaxReadAheadBuffers());
-	EXPECT_EQ(1, tSizes.GetMaxConcurrentReads());
-	EXPECT_EQ(1, tSizes.GetMaxConcurrentWrites());
+	EXPECT_EQ(1UL, tSizes.GetMaxReadAheadBuffers());
+	EXPECT_EQ(1UL, tSizes.GetMaxConcurrentReads());
+	EXPECT_EQ(1UL, tSizes.GetMaxConcurrentWrites());
 }
 
 TEST(TestsTBufferSizes, ParametrizedConstructor_RoundingCheck)
 {
 	TBufferSizes tSizes(true, 2, 6543, 9891, 17123, 37012, 72089, 10, 2, 1);
 
-	EXPECT_EQ(2, tSizes.GetBufferCount());
-	EXPECT_EQ(8192, tSizes.GetDefaultSize());
-	EXPECT_EQ(12288, tSizes.GetOneDiskSize());
-	EXPECT_EQ(20480, tSizes.GetTwoDisksSize());
-	EXPECT_EQ(40960, tSizes.GetCDSize());
-	EXPECT_EQ(73728, tSizes.GetLANSize());
+	EXPECT_EQ(2UL, tSizes.GetBufferCount());
+	EXPECT_EQ(8192UL, tSizes.GetDefaultSize());
+	EXPECT_EQ(12288UL, tSizes.GetOneDiskSize());
+	EXPECT_EQ(20480UL, tSizes.GetTwoDisksSize());
+	EXPECT_EQ(40960UL, tSizes.GetCDSize());
+	EXPECT_EQ(73728UL, tSizes.GetLANSize());
 	EXPECT_EQ(true, tSizes.IsOnlyDefault());
-	EXPECT_EQ(10, tSizes.GetMaxReadAheadBuffers());
-	EXPECT_EQ(2, tSizes.GetMaxConcurrentReads());
-	EXPECT_EQ(1, tSizes.GetMaxConcurrentWrites());
+	EXPECT_EQ(10UL, tSizes.GetMaxReadAheadBuffers());
+	EXPECT_EQ(2UL, tSizes.GetMaxConcurrentReads());
+	EXPECT_EQ(1UL, tSizes.GetMaxConcurrentWrites());
 }
 
 TEST(TestsTBufferSizes, Clear)
@@ -80,9 +80,9 @@
 	EXPECT_EQ(TBufferSizes::BufferGranularity, tSizes.GetCDSize());
 	EXPECT_EQ(TBufferSizes::BufferGranularity, tSizes.GetLANSize());
 	EXPECT_EQ(false, tSizes.IsOnlyDefault());
-	EXPECT_EQ(1, tSizes.GetMaxReadAheadBuffers());
-	EXPECT_EQ(1, tSizes.GetMaxConcurrentReads());
-	EXPECT_EQ(1, tSizes.GetMaxConcurrentWrites());
+	EXPECT_EQ(1UL, tSizes.GetMaxReadAheadBuffers());
+	EXPECT_EQ(1UL, tSizes.GetMaxConcurrentReads());
+	EXPECT_EQ(1UL, tSizes.GetMaxConcurrentWrites());
 }
 
 TEST(TestsTBufferSizes, SetOnlyDefault_IsOnlyDefault)
@@ -101,7 +101,7 @@
 
 	tSizes.SetDefaultSize(8192);
 
-	EXPECT_EQ(8192, tSizes.GetDefaultSize());
+	EXPECT_EQ(8192UL, tSizes.GetDefaultSize());
 }
 
 TEST(TestsTBufferSizes, SetDefaultSize_GetDefaultSize_MinCheck)
@@ -110,7 +110,7 @@
 
 	tSizes.SetDefaultSize(1);
 
-	EXPECT_EQ(4096, tSizes.GetDefaultSize());
+	EXPECT_EQ(4096UL, tSizes.GetDefaultSize());
 }
 
 TEST(TestsTBufferSizes, SetDefaultSize_GetDefaultSize_RoundCheck)
@@ -119,7 +119,7 @@
 
 	tSizes.SetDefaultSize(8193);
 
-	EXPECT_EQ(12288, tSizes.GetDefaultSize());
+	EXPECT_EQ(12288UL, tSizes.GetDefaultSize());
 }
 
 /////////////////////////////////////////////////////////////////////////
@@ -129,7 +129,7 @@
 
 	tSizes.SetOneDiskSize(8192);
 
-	EXPECT_EQ(8192, tSizes.GetOneDiskSize());
+	EXPECT_EQ(8192UL, tSizes.GetOneDiskSize());
 }
 
 TEST(TestsTBufferSizes, SetOneDiskSize_GetOneDiskSize_MinCheck)
@@ -138,7 +138,7 @@
 
 	tSizes.SetOneDiskSize(1);
 
-	EXPECT_EQ(4096, tSizes.GetOneDiskSize());
+	EXPECT_EQ(4096UL, tSizes.GetOneDiskSize());
 }
 
 TEST(TestsTBufferSizes, SetOneDiskSize_GetOneDiskSize_RoundCheck)
@@ -147,7 +147,7 @@
 
 	tSizes.SetOneDiskSize(8193);
 
-	EXPECT_EQ(12288, tSizes.GetOneDiskSize());
+	EXPECT_EQ(12288UL, tSizes.GetOneDiskSize());
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -157,7 +157,7 @@
 
 	tSizes.SetTwoDisksSize(8192);
 
-	EXPECT_EQ(8192, tSizes.GetTwoDisksSize());
+	EXPECT_EQ(8192UL, tSizes.GetTwoDisksSize());
 }
 
 TEST(TestsTBufferSizes, SetTwoDisksSize_GetTwoDisksSize_MinCheck)
@@ -166,7 +166,7 @@
 
 	tSizes.SetTwoDisksSize(1);
 
-	EXPECT_EQ(4096, tSizes.GetTwoDisksSize());
+	EXPECT_EQ(4096UL, tSizes.GetTwoDisksSize());
 }
 
 TEST(TestsTBufferSizes, SetTwoDisksSize_GetTwoDisksSize_RoundCheck)
@@ -175,7 +175,7 @@
 
 	tSizes.SetTwoDisksSize(8193);
 
-	EXPECT_EQ(12288, tSizes.GetTwoDisksSize());
+	EXPECT_EQ(12288UL, tSizes.GetTwoDisksSize());
 }
 ////////////////////////////////////////////////////////////////////////
 TEST(TestsTBufferSizes, SetCDSize_GetCDSize_Rounded)
@@ -184,7 +184,7 @@
 
 	tSizes.SetCDSize(8192);
 
-	EXPECT_EQ(8192, tSizes.GetCDSize());
+	EXPECT_EQ(8192UL, tSizes.GetCDSize());
 }
 
 TEST(TestsTBufferSizes, SetCDSize_GetCDSize_MinCheck)
@@ -193,7 +193,7 @@
 
 	tSizes.SetCDSize(1);
 
-	EXPECT_EQ(4096, tSizes.GetCDSize());
+	EXPECT_EQ(4096UL, tSizes.GetCDSize());
 }
 
 TEST(TestsTBufferSizes, SetCDSize_GetCDSize_RoundCheck)
@@ -202,7 +202,7 @@
 
 	tSizes.SetCDSize(8193);
 
-	EXPECT_EQ(12288, tSizes.GetCDSize());
+	EXPECT_EQ(12288UL, tSizes.GetCDSize());
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -212,7 +212,7 @@
 
 	tSizes.SetLANSize(8192);
 
-	EXPECT_EQ(8192, tSizes.GetLANSize());
+	EXPECT_EQ(8192UL, tSizes.GetLANSize());
 }
 
 TEST(TestsTBufferSizes, SetLANSize_GetLANSize_MinCheck)
@@ -221,7 +221,7 @@
 
 	tSizes.SetLANSize(1);
 
-	EXPECT_EQ(4096, tSizes.GetLANSize());
+	EXPECT_EQ(4096UL, tSizes.GetLANSize());
 }
 
 TEST(TestsTBufferSizes, SetLANSize_GetLANSize_RoundCheck)
@@ -230,7 +230,7 @@
 
 	tSizes.SetLANSize(8193);
 
-	EXPECT_EQ(12288, tSizes.GetLANSize());
+	EXPECT_EQ(12288UL, tSizes.GetLANSize());
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -240,7 +240,7 @@
 
 	tSizes.SetBufferCount(5);
 
-	EXPECT_EQ(5, tSizes.GetBufferCount());
+	EXPECT_EQ(5UL, tSizes.GetBufferCount());
 }
 
 TEST(TestsTBufferSizes, SetBufferCount_GetBufferCount_MinSize)
@@ -249,7 +249,7 @@
 
 	tSizes.SetBufferCount(0);
 
-	EXPECT_EQ(1, tSizes.GetBufferCount());
+	EXPECT_EQ(1UL, tSizes.GetBufferCount());
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -263,11 +263,11 @@
 	tSizes.SetSizeByType(TBufferSizes::eBuffer_CD, 65536);
 	tSizes.SetSizeByType(TBufferSizes::eBuffer_LAN, 131072);
 
-	EXPECT_EQ(8192, tSizes.GetSizeByType(TBufferSizes::eBuffer_Default));
-	EXPECT_EQ(16384, tSizes.GetSizeByType(TBufferSizes::eBuffer_OneDisk));
-	EXPECT_EQ(32768, tSizes.GetSizeByType(TBufferSizes::eBuffer_TwoDisks));
-	EXPECT_EQ(65536, tSizes.GetSizeByType(TBufferSizes::eBuffer_CD));
-	EXPECT_EQ(131072, tSizes.GetSizeByType(TBufferSizes::eBuffer_LAN));
+	EXPECT_EQ(8192UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_Default));
+	EXPECT_EQ(16384UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_OneDisk));
+	EXPECT_EQ(32768UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_TwoDisks));
+	EXPECT_EQ(65536UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_CD));
+	EXPECT_EQ(131072UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_LAN));
 }
 
 TEST(TestsTBufferSizes, SetSizeByType_GetSizeByType_RoundCheck)
@@ -280,11 +280,11 @@
 	tSizes.SetSizeByType(TBufferSizes::eBuffer_CD, 65530);
 	tSizes.SetSizeByType(TBufferSizes::eBuffer_LAN, 131070);
 
-	EXPECT_EQ(8192, tSizes.GetSizeByType(TBufferSizes::eBuffer_Default));
-	EXPECT_EQ(16384, tSizes.GetSizeByType(TBufferSizes::eBuffer_OneDisk));
-	EXPECT_EQ(32768, tSizes.GetSizeByType(TBufferSizes::eBuffer_TwoDisks));
-	EXPECT_EQ(65536, tSizes.GetSizeByType(TBufferSizes::eBuffer_CD));
-	EXPECT_EQ(131072, tSizes.GetSizeByType(TBufferSizes::eBuffer_LAN));
+	EXPECT_EQ(8192UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_Default));
+	EXPECT_EQ(16384UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_OneDisk));
+	EXPECT_EQ(32768UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_TwoDisks));
+	EXPECT_EQ(65536UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_CD));
+	EXPECT_EQ(131072UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_LAN));
 }
 
 TEST(TestsTBufferSizes, SetSizeByType_GetSizeByType_MinSize)
@@ -297,11 +297,11 @@
 	tSizes.SetSizeByType(TBufferSizes::eBuffer_CD, 0);
 	tSizes.SetSizeByType(TBufferSizes::eBuffer_LAN, 0);
 
-	EXPECT_EQ(4096, tSizes.GetSizeByType(TBufferSizes::eBuffer_Default));
-	EXPECT_EQ(4096, tSizes.GetSizeByType(TBufferSizes::eBuffer_OneDisk));
-	EXPECT_EQ(4096, tSizes.GetSizeByType(TBufferSizes::eBuffer_TwoDisks));
-	EXPECT_EQ(4096, tSizes.GetSizeByType(TBufferSizes::eBuffer_CD));
-	EXPECT_EQ(4096, tSizes.GetSizeByType(TBufferSizes::eBuffer_LAN));
+	EXPECT_EQ(4096UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_Default));
+	EXPECT_EQ(4096UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_OneDisk));
+	EXPECT_EQ(4096UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_TwoDisks));
+	EXPECT_EQ(4096UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_CD));
+	EXPECT_EQ(4096UL, tSizes.GetSizeByType(TBufferSizes::eBuffer_LAN));
 }
 
 TEST(TestsTBufferSizes, SetSizeByType_GetSizeByType_OutOfRange)
@@ -317,40 +317,40 @@
 {
 	TBufferSizes tSizes(false, 1, 16384, 0, 0, 0, 0, 0, 0, 0);
 
-	EXPECT_EQ(16384, tSizes.GetMaxSize());
+	EXPECT_EQ(16384UL, tSizes.GetMaxSize());
 }
 
 TEST(TestsTBufferSizes, GetMaxSize_OneDisk)
 {
 	TBufferSizes tSizes(false, 1, 0, 16384, 0, 0, 0, 0, 0, 0);
 
-	EXPECT_EQ(16384, tSizes.GetMaxSize());
+	EXPECT_EQ(16384UL, tSizes.GetMaxSize());
 }
 
 TEST(TestsTBufferSizes, GetMaxSize_TwoDisks)
 {
 	TBufferSizes tSizes(false, 1, 0, 0, 16384, 0, 0, 0, 0, 0);
 
-	EXPECT_EQ(16384, tSizes.GetMaxSize());
+	EXPECT_EQ(16384UL, tSizes.GetMaxSize());
 }
 
 TEST(TestsTBufferSizes, GetMaxSize_CD)
 {
 	TBufferSizes tSizes(false, 1, 0, 0, 0, 16384, 0, 0, 0, 0);
 
-	EXPECT_EQ(16384, tSizes.GetMaxSize());
+	EXPECT_EQ(16384UL, tSizes.GetMaxSize());
 }
 
 TEST(TestsTBufferSizes, GetMaxSize_LAN)
 {
 	TBufferSizes tSizes(false, 1, 0, 0, 0, 0, 16384, 0, 0, 0);
 
-	EXPECT_EQ(16384, tSizes.GetMaxSize());
+	EXPECT_EQ(16384UL, tSizes.GetMaxSize());
 }
 
 TEST(TestsTBufferSizes, GetMaxSize_OnlyDefault)
 {
 	TBufferSizes tSizes(true, 1, 16384, 0, 0, 0, 32768, 0, 0, 0);
 
-	EXPECT_EQ(16384, tSizes.GetMaxSize());
+	EXPECT_EQ(16384UL, tSizes.GetMaxSize());
 }
Index: src/libchengine/Tests/TestsTConfig.cpp
===================================================================
diff -u -r1019bc9df4e044491b7102c37c8cac33cf56fb4a -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TestsTConfig.cpp	(.../TestsTConfig.cpp)	(revision 1019bc9df4e044491b7102c37c8cac33cf56fb4a)
+++ src/libchengine/Tests/TestsTConfig.cpp	(.../TestsTConfig.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -288,13 +288,13 @@
 	cfg.SetValue(_T("Root.Node.Value2"), (unsigned int)4294967295);
 
 	// check if stored successfully (typed get)
-	EXPECT_EQ(1489, cfg.GetUInt(_T("Root.Node.Value1")));
+	EXPECT_EQ(1489UL, cfg.GetUInt(_T("Root.Node.Value1")));
 	EXPECT_EQ(4294967295, cfg.GetUInt(_T("Root.Node.Value2")));
 
 	// check if stored successfully (GetValue)
 	unsigned int value = 0;
 	cfg.GetValue(_T("Root.Node.Value1"), value);
-	EXPECT_EQ(1489, value);
+	EXPECT_EQ(1489UL, value);
 	cfg.GetValue(_T("Root.Node.Value2"), value);
 	EXPECT_EQ(4294967295, value);
 }
@@ -309,7 +309,7 @@
 	// store in string
 	cfg.ReadFromString(strXmlData);
 
-	EXPECT_EQ(1489, cfg.GetUInt(_T("Root.Node.Value1")));
+	EXPECT_EQ(1489UL, cfg.GetUInt(_T("Root.Node.Value1")));
 	EXPECT_EQ(4294967295, cfg.GetUInt(_T("Root.Node.Value2")));
 
 	TString strWriteXmlData;
@@ -548,7 +548,7 @@
 	TStringArray arrRead;
 	m_cfg.GetValue(_T("CHConfig.Core.Notifications.PathList.Path"), arrRead);
 
-	EXPECT_EQ(arrRead.GetCount(), 4);
+	EXPECT_EQ(arrRead.GetCount(), 4UL);
 	EXPECT_EQ(TString(_T("c:\\Windows\\System32")), arrRead.GetAt(0));
 	EXPECT_EQ(TString(_T("d:\\Movies")), arrRead.GetAt(1));
 	EXPECT_EQ(TString(_T("x:\\Music")), arrRead.GetAt(2));
@@ -620,7 +620,7 @@
 
 	m_cfg.ExtractMultiSubConfigs(_T("CHConfig.Core.CompositeObjects.Object"), cfgSubArray);
 
-	EXPECT_EQ(2, cfgSubArray.GetCount());
+	EXPECT_EQ(2UL, cfgSubArray.GetCount());
 
 	EXPECT_EQ(TString(_T("FirstName")), cfgSubArray.GetAt(0).GetString(_T("Name")));
 	EXPECT_EQ(TString(_T("<WINDOWS>\\FirstPath")), cfgSubArray.GetAt(0).GetString(_T("Path")));
Index: src/libchengine/Tests/TestsTFileFilter.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libchengine/Tests/TestsTFileFilter.cpp	(.../TestsTFileFilter.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libchengine/Tests/TestsTFileFilter.cpp	(.../TestsTFileFilter.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -10,7 +10,7 @@
 	TFileFilter filter;
 
 	// other
-	EXPECT_EQ(0, filter.GetObjectID());
+	EXPECT_EQ(0UL, filter.GetObjectID());
 	
 	EXPECT_EQ(false, filter.GetUseMask());
 	EXPECT_STREQ(L"", filter.GetCombinedMask().c_str());
Index: src/libstring/Tests/TestsTString.cpp
===================================================================
diff -u -rfadd6c9c628de875716d96c3a497b5bc6c8dca8a -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libstring/Tests/TestsTString.cpp	(.../TestsTString.cpp)	(revision fadd6c9c628de875716d96c3a497b5bc6c8dca8a)
+++ src/libstring/Tests/TestsTString.cpp	(.../TestsTString.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -512,16 +512,16 @@
 TEST(TStringTests, FindFirstOf_WithPtrToString)
 {
 	TString strValue(_T("Some string"));
-	EXPECT_EQ(strValue.FindFirstOf(_T("er"), 3), 3);
-	EXPECT_EQ(strValue.FindFirstOf(_T("er"), 4), 7);
+	EXPECT_EQ(strValue.FindFirstOf(_T("er"), 3), 3UL);
+	EXPECT_EQ(strValue.FindFirstOf(_T("er"), 4), 7UL);
 	EXPECT_EQ(strValue.FindFirstOf(_T(""), 0), TString::npos);
 	EXPECT_EQ(strValue.FindFirstOf(nullptr, 0), TString::npos);
 }
 
 TEST(TStringTests, FindLastOf_WithPtrToString)
 {
 	TString strValue(_T("Some string"));
-	EXPECT_EQ(strValue.FindLastOf(_T("er")), 7);
+	EXPECT_EQ(strValue.FindLastOf(_T("er")), 7UL);
 	EXPECT_EQ(strValue.FindLastOf(_T("")), TString::npos);
 	EXPECT_EQ(strValue.FindLastOf(nullptr), TString::npos);
 }
@@ -530,7 +530,7 @@
 TEST(TStringTests, Find_WithPtrToString)
 {
 	TString strValue(_T("Some string"));
-	EXPECT_EQ(strValue.Find(_T("tri"), 6), 6);
+	EXPECT_EQ(strValue.Find(_T("tri"), 6), 6UL);
 	EXPECT_EQ(strValue.Find(_T("tri"), 7), TString::npos);
 	EXPECT_EQ(strValue.Find(_T(""), 0), TString::npos);
 	EXPECT_EQ(strValue.Find(nullptr, 0), TString::npos);
@@ -592,7 +592,7 @@
 	pszBuffer[4] = _T('\0');
 	strValue.ReleaseBuffer();
 	
-	EXPECT_EQ(strValue.GetLength(), 4);
+	EXPECT_EQ(strValue.GetLength(), 4UL);
 }
 
 TEST(TStringTests, GetAndReleaseBufferSetLength)
@@ -602,7 +602,7 @@
 	pszBuffer[4] = _T('t');
 	strValue.ReleaseBufferSetLength(1);
 
-	EXPECT_EQ(strValue.GetLength(), 1);
+	EXPECT_EQ(strValue.GetLength(), 1UL);
 	EXPECT_EQ(strValue, _T("S"));
 }
 
@@ -621,7 +621,7 @@
 {
 	TString strValue(_T("Some string"));
 
-	EXPECT_EQ(strValue.GetLength(), 11);
+	EXPECT_EQ(strValue.GetLength(), 11UL);
 }
 
 // corner cases and detected bugs
Index: src/libstring/Tests/TestsTStringArray.cpp
===================================================================
diff -u -rbc3ebabeccf483d086fd58d06ddbc4d8a55c1dfc -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libstring/Tests/TestsTStringArray.cpp	(.../TestsTStringArray.cpp)	(revision bc3ebabeccf483d086fd58d06ddbc4d8a55c1dfc)
+++ src/libstring/Tests/TestsTStringArray.cpp	(.../TestsTStringArray.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -10,7 +10,7 @@
 {
 	TStringArray arrStrings;
 
-	EXPECT_EQ(0, arrStrings.GetCount());
+	EXPECT_EQ(0UL, arrStrings.GetCount());
 }
 
 TEST(TestsTStringArray, AddElements)
@@ -20,7 +20,7 @@
 	arrStrings.Add(TString(L"SomeString1"));
 	arrStrings.Add(TString(L"SomeString2"));
 
-	EXPECT_EQ(2, arrStrings.GetCount());
+	EXPECT_EQ(2UL, arrStrings.GetCount());
 	EXPECT_STREQ(L"SomeString1", arrStrings.GetAt(0).c_str());
 	EXPECT_STREQ(L"SomeString2", arrStrings.GetAt(1).c_str());
 }
@@ -32,7 +32,7 @@
 	arrStrings.InsertAt(0, TString(L"SomeString1"));
 	arrStrings.InsertAt(0, TString(L"SomeString2"));
 
-	EXPECT_EQ(2, arrStrings.GetCount());
+	EXPECT_EQ(2UL, arrStrings.GetCount());
 	EXPECT_STREQ(L"SomeString1", arrStrings.GetAt(1).c_str());
 	EXPECT_STREQ(L"SomeString2", arrStrings.GetAt(0).c_str());
 }
@@ -53,7 +53,7 @@
 
 	arrStrings.SetAt(0, TString(L"SomeString3"));
 
-	EXPECT_EQ(2, arrStrings.GetCount());
+	EXPECT_EQ(2UL, arrStrings.GetCount());
 	EXPECT_STREQ(L"SomeString3", arrStrings.GetAt(0).c_str());
 	EXPECT_STREQ(L"SomeString2", arrStrings.GetAt(1).c_str());
 }
@@ -74,7 +74,7 @@
 
 	arrStrings.RemoveAt(0);
 
-	EXPECT_EQ(1, arrStrings.GetCount());
+	EXPECT_EQ(1UL, arrStrings.GetCount());
 	EXPECT_STREQ(L"SomeString2", arrStrings.GetAt(0).c_str());
 }
 
@@ -94,7 +94,7 @@
 
 	arrStrings.Clear();
 
-	EXPECT_EQ(0, arrStrings.GetCount());
+	EXPECT_EQ(0UL, arrStrings.GetCount());
 }
 
 TEST(TestsTStringArray, Compare_Empty)
Index: src/libstring/Tests/TestsTStringPatternArray.cpp
===================================================================
diff -u -r0d5b67ee96b435d63f7bf075dc8e28603793b187 -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libstring/Tests/TestsTStringPatternArray.cpp	(.../TestsTStringPatternArray.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
+++ src/libstring/Tests/TestsTStringPatternArray.cpp	(.../TestsTStringPatternArray.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -10,7 +10,7 @@
 {
 	TStringPatternArray arrPatterns;
 
-	EXPECT_EQ(0, arrPatterns.GetCount());
+	EXPECT_EQ(0UL, arrPatterns.GetCount());
 }
 
 TEST(TestsTStringPatternArray, AddElements)
@@ -20,7 +20,7 @@
 	arrPatterns.Add(TStringPattern(L"*.bat", TStringPattern::EPatternType::eType_Wildcard));
 	arrPatterns.Add(TStringPattern(L"*.exe", TStringPattern::EPatternType::eType_Wildcard));
 
-	EXPECT_EQ(2, arrPatterns.GetCount());
+	EXPECT_EQ(2UL, arrPatterns.GetCount());
 	EXPECT_STREQ(L"*.bat", arrPatterns.GetAt(0).ToString().c_str());
 	EXPECT_STREQ(L"*.exe", arrPatterns.GetAt(1).ToString().c_str());
 }
@@ -32,7 +32,7 @@
 	arrPatterns.InsertAt(0, TStringPattern(L"*.bat", TStringPattern::EPatternType::eType_Wildcard));
 	arrPatterns.InsertAt(0, TStringPattern(L"*.exe", TStringPattern::EPatternType::eType_Wildcard));
 
-	EXPECT_EQ(2, arrPatterns.GetCount());
+	EXPECT_EQ(2UL, arrPatterns.GetCount());
 	EXPECT_STREQ(L"*.bat", arrPatterns.GetAt(1).ToString().c_str());
 	EXPECT_STREQ(L"*.exe", arrPatterns.GetAt(0).ToString().c_str());
 }
@@ -46,7 +46,7 @@
 
 	arrPatterns.SetAt(0, TStringPattern(L"*.com", TStringPattern::EPatternType::eType_Wildcard));
 
-	EXPECT_EQ(2, arrPatterns.GetCount());
+	EXPECT_EQ(2UL, arrPatterns.GetCount());
 	EXPECT_STREQ(L"*.com", arrPatterns.GetAt(0).ToString().c_str());
 	EXPECT_STREQ(L"*.exe", arrPatterns.GetAt(1).ToString().c_str());
 }
@@ -60,7 +60,7 @@
 
 	arrPatterns.RemoveAt(0);
 
-	EXPECT_EQ(1, arrPatterns.GetCount());
+	EXPECT_EQ(1UL, arrPatterns.GetCount());
 	EXPECT_STREQ(L"*.exe", arrPatterns.GetAt(0).ToString().c_str());
 }
 
@@ -73,7 +73,7 @@
 
 	arrPatterns.Clear();
 
-	EXPECT_EQ(0, arrPatterns.GetCount());
+	EXPECT_EQ(0UL, arrPatterns.GetCount());
 }
 
 /////////////////////////////////////////////////
@@ -130,7 +130,7 @@
 	arrPatterns.Add(TStringPattern(L"autostart.*", TStringPattern::EPatternType::eType_Wildcard));
 
 	TStringArray arrElements = arrPatterns.ToSerializedStringArray();
-	EXPECT_EQ(2, arrElements.GetCount());
+	EXPECT_EQ(2UL, arrElements.GetCount());
 	EXPECT_STREQ(L"*.bat", arrElements.GetAt(0).c_str());
 	EXPECT_STREQ(L"autostart.*", arrElements.GetAt(1).c_str());
 }
Index: src/libstring/Tests/TestsTStringSet.cpp
===================================================================
diff -u -rbc3ebabeccf483d086fd58d06ddbc4d8a55c1dfc -r07f5ed57f11f0b908313f692fc4830401f0db552
--- src/libstring/Tests/TestsTStringSet.cpp	(.../TestsTStringSet.cpp)	(revision bc3ebabeccf483d086fd58d06ddbc4d8a55c1dfc)
+++ src/libstring/Tests/TestsTStringSet.cpp	(.../TestsTStringSet.cpp)	(revision 07f5ed57f11f0b908313f692fc4830401f0db552)
@@ -9,7 +9,7 @@
 {
 	TStringSet setStrings;
 
-	EXPECT_EQ(0, setStrings.GetCount());
+	EXPECT_EQ(0UL, setStrings.GetCount());
 }
 
 TEST(TestsTStringSet, InsertElements)
@@ -19,7 +19,7 @@
 	setStrings.Insert(TString(L"SomeString1"));
 	setStrings.Insert(TString(L"SomeString2"));
 
-	EXPECT_EQ(2, setStrings.GetCount());
+	EXPECT_EQ(2UL, setStrings.GetCount());
 	EXPECT_TRUE(setStrings.HasValue(L"SomeString1"));
 	EXPECT_TRUE(setStrings.HasValue(L"SomeString2"));
 	EXPECT_FALSE(setStrings.HasValue(TString()));
@@ -38,7 +38,7 @@
 
 	setStrings.Insert(arrPatterns2);
 
-	EXPECT_EQ(3, setStrings.GetCount());
+	EXPECT_EQ(3UL, setStrings.GetCount());
 	EXPECT_TRUE(setStrings.HasValue(L"SomeString1"));
 	EXPECT_TRUE(setStrings.HasValue(L"SomeString2"));
 	EXPECT_TRUE(setStrings.HasValue(L"SomeString3"));
@@ -53,7 +53,7 @@
 
 	setStrings.Remove(L"SomeString1");
 
-	EXPECT_EQ(1, setStrings.GetCount());
+	EXPECT_EQ(1UL, setStrings.GetCount());
 	EXPECT_FALSE(setStrings.HasValue(L"SomeString1"));
 	EXPECT_TRUE(setStrings.HasValue(L"SomeString2"));
 	EXPECT_FALSE(setStrings.HasValue(TString()));
@@ -68,7 +68,7 @@
 
 	setStrings.Clear();
 
-	EXPECT_EQ(0, setStrings.GetCount());
+	EXPECT_EQ(0UL, setStrings.GetCount());
 }
 
 TEST(TestsTStringSet, IsEmpty_Empty)