Cleaned-up tests compilation warnings signed/unsigned cmp

test/hashing/test_md5.cpp

@@ -65,7 +65,7 @@ TEST(TestHashingMD5, hashABC) {
 TEST(TestHashingMD5, hashMessageDigest) {
     MD5 hash;
 
-    EXPECT_EQ(128, hash.getDigestLength());
+	EXPECT_EQ(128U, hash.getDigestLength());
 
     char message[] = "message digest";
     hash.update(wrapMemory(message, sizeof(message) - 1));

test/hashing/test_murmur3.cpp

@@ -71,15 +71,15 @@ TEST(TestHashingMurmur3, hashABC128) {
 }
 
 TEST(TestHashingMurmur3, hashMessageDigest32) {
-    EXPECT_EQ(32, Murmur3_32(0).getDigestLength());
+	EXPECT_EQ(32U, Murmur3_32(0).getDigestLength());
 
     char message[] = "message digest";
     EXPECT_EQ(std::initializer_list<byte>({0x63, 0x8F, 0x41, 0x69}),
                             Murmur3_32(0).update(wrapMemory(message, sizeof(message) - 1)).digest());
 }
 
 TEST(TestHashingMurmur3, hashMessageDigest128) {
-    EXPECT_EQ(128, Murmur3_128(0).getDigestLength());
+	EXPECT_EQ(128U, Murmur3_128(0).getDigestLength());
 
     char message[] = "message digest";
     EXPECT_EQ(std::initializer_list<byte>({0xfc, 0x7d, 0x14, 0x76, 0x2d, 0x2c, 0x5d, 0x87,

test/hashing/test_sha1.cpp

@@ -80,7 +80,7 @@ TEST(TestHashingSHA1, hashABC) {
 TEST(TestHashingSHA1, hashMessageDigest) {
     Sha1 hash;
 
-    EXPECT_EQ(160, hash.getDigestLength());
+	EXPECT_EQ(160U, hash.getDigestLength());
 
     char message[] = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
     hash.update(wrapMemory(message, sizeof(message) - 1));

test/hashing/test_sha256.cpp

@@ -72,7 +72,7 @@ TEST(TestHashingSHA256, hashABC) {
 TEST(TestHashingSHA256, hashMessageDigest) {
     Sha256 hash;
 
-    EXPECT_EQ(256, hash.getDigestLength());
+	EXPECT_EQ(256U, hash.getDigestLength());
 
     char message[] = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
     hash.update(wrapMemory(message, sizeof(message) - 1));

test/test_array.cpp

@@ -404,7 +404,7 @@ TEST_F(TestArray, testMoveAssignment) {
         EXPECT_TRUE(!array.empty());
         const int src1[] = {1, 2, 3};
 
-        EXPECT_EQ(3, array.size());
+		EXPECT_EQ(3U, array.size());
         for (auto i = ZERO, end = array.size(); i < end; ++i) {
             EXPECT_EQ(src1[i], array[i]);
         }
@@ -421,7 +421,7 @@ TEST_F(TestArray, testMoveAssignment) {
         EXPECT_TRUE(!array.empty());
 
         std::string const src[] = {"tasrd", "", "hhha", "asd"};
-        EXPECT_EQ(4, array.size());
+		EXPECT_EQ(4U, array.size());
         for (auto i = ZERO, end = array.size(); i < end; ++i) {
             EXPECT_EQ(src[i], array[i]);
         }
@@ -446,7 +446,7 @@ TEST_F(TestArray, testMoveAssignment) {
 
 		array = maybeArray.moveResult();
         EXPECT_TRUE(!array.empty());
-        EXPECT_EQ(4, array.size());
+		EXPECT_EQ(4U, array.size());
 
         for (auto i = ZERO, end = array.size(); i < end; ++i) {
             EXPECT_EQ(src[i].iValue, array[i].iValue);
@@ -628,7 +628,7 @@ TEST_F(TestArray, testIndexOf) {
 
 	auto maybeIndex1 = array.indexOf(2);
 	EXPECT_TRUE(maybeIndex1.isSome());
-	EXPECT_EQ(1, maybeIndex1.get());
+	EXPECT_EQ(1U, maybeIndex1.get());
 
 	EXPECT_TRUE(array.indexOf(42).isNone());
 }

test/test_arrayView.cpp

@@ -248,8 +248,8 @@ TEST_F(TestArrayView, testEmpty) {
 TEST_F(TestArrayView, testConstructionFromMemoryResource) {
     byte buffer[32];  // 32 bytes is 8 u32.
 
-    EXPECT_EQ(32, arrayView(buffer).size());
-    EXPECT_EQ(8, arrayView(reinterpret_cast<uint32*>(buffer), sizeof (buffer) / sizeof (uint32)).size());
+	EXPECT_EQ(32U, arrayView(buffer).size());
+	EXPECT_EQ(8U, arrayView(reinterpret_cast<uint32*>(buffer), sizeof (buffer) / sizeof (uint32)).size());
 }
 
 
@@ -830,14 +830,14 @@ TEST_F(TestArrayView, slice) {
     EXPECT_EQ(array, array.slice(0, array.size()));
 
     auto halfView = array.slice(12, 22);
-    EXPECT_EQ(10, halfView.size());
+	EXPECT_EQ(10U, halfView.size());
     for (ArrayView<int>::size_type i = 0; i < halfView.size(); ++i) {
-        EXPECT_EQ(12 + i, halfView[i]);
+		EXPECT_EQ(static_cast<int>(12 + i), halfView[i]);
     }
 
     EXPECT_TRUE(array.slice(12, 12).empty());
     EXPECT_TRUE(array.slice(128, 300).empty());
-    EXPECT_EQ(14, array.slice(10, 300).size());
+	EXPECT_EQ(14U, array.slice(10, 300).size());
     EXPECT_TRUE(array.slice(128, 21).empty());
     EXPECT_TRUE(array.slice(21, 7).empty());
 }
@@ -928,7 +928,7 @@ TEST_F(TestArrayView, sizeNarrowing) {
 	byte buffer[sizeof (MisalignedType) * 3 + sizeof (MisalignedType) / 2];
 
 	auto value = arrayView<MisalignedType>(wrapMemory(buffer), 4);
-	ASSERT_EQ(value.size(), 3);  // FIXME: Maybe we should return Err() in this case as it is a narrowing
+	ASSERT_EQ(3U, value.size());  // FIXME: Maybe we should return Err() in this case as it is a narrowing
 }
 
 /*

test/test_base16.cpp

@@ -26,23 +26,23 @@ using namespace Solace;
 
 
 TEST(TestBase16, testEncodedSize) {
-    EXPECT_EQ(0, Base16Encoder::encodedSize(0));
-    EXPECT_EQ(2, Base16Encoder::encodedSize(1));
-    EXPECT_EQ(4, Base16Encoder::encodedSize(2));
-    EXPECT_EQ(6, Base16Encoder::encodedSize(3));
-    EXPECT_EQ(8, Base16Encoder::encodedSize(4));
-    EXPECT_EQ(10, Base16Encoder::encodedSize(5));
-    EXPECT_EQ(12, Base16Encoder::encodedSize(6));
+	EXPECT_EQ(0U, Base16Encoder::encodedSize(0));
+	EXPECT_EQ(2U, Base16Encoder::encodedSize(1));
+	EXPECT_EQ(4U, Base16Encoder::encodedSize(2));
+	EXPECT_EQ(6U, Base16Encoder::encodedSize(3));
+	EXPECT_EQ(8U, Base16Encoder::encodedSize(4));
+	EXPECT_EQ(10U, Base16Encoder::encodedSize(5));
+	EXPECT_EQ(12U, Base16Encoder::encodedSize(6));
 }
 
 TEST(TestBase16, testDecodedSize) {
-    EXPECT_EQ(0, Base16Decoder::encodedSize(0));
-    EXPECT_EQ(0, Base16Decoder::encodedSize(1));
-    EXPECT_EQ(1, Base16Decoder::encodedSize(2));
-    EXPECT_EQ(1, Base16Decoder::encodedSize(3));
-    EXPECT_EQ(2, Base16Decoder::encodedSize(4));
-    EXPECT_EQ(2, Base16Decoder::encodedSize(5));
-    EXPECT_EQ(3, Base16Decoder::encodedSize(6));
+	EXPECT_EQ(0U, Base16Decoder::encodedSize(0));
+	EXPECT_EQ(0U, Base16Decoder::encodedSize(1));
+	EXPECT_EQ(1U, Base16Decoder::encodedSize(2));
+	EXPECT_EQ(1U, Base16Decoder::encodedSize(3));
+	EXPECT_EQ(2U, Base16Decoder::encodedSize(4));
+	EXPECT_EQ(2U, Base16Decoder::encodedSize(5));
+	EXPECT_EQ(3U, Base16Decoder::encodedSize(6));
 }
 
 TEST(TestBase16, testBasicEncoding) {

test/test_base64.cpp

@@ -28,24 +28,24 @@ using namespace Solace;
 
 
 TEST(TestBase64, testEncodedSize) {
-    EXPECT_EQ(0, Base64Encoder::encodedSize(0));
-    EXPECT_EQ(4, Base64Encoder::encodedSize(1));
-    EXPECT_EQ(4, Base64Encoder::encodedSize(2));
-    EXPECT_EQ(4, Base64Encoder::encodedSize(3));
-    EXPECT_EQ(8, Base64Encoder::encodedSize(4));
-    EXPECT_EQ(8, Base64Encoder::encodedSize(5));
-    EXPECT_EQ(8, Base64Encoder::encodedSize(6));
+	EXPECT_EQ(0U, Base64Encoder::encodedSize(0));
+	EXPECT_EQ(4U, Base64Encoder::encodedSize(1));
+	EXPECT_EQ(4U, Base64Encoder::encodedSize(2));
+	EXPECT_EQ(4U, Base64Encoder::encodedSize(3));
+	EXPECT_EQ(8U, Base64Encoder::encodedSize(4));
+	EXPECT_EQ(8U, Base64Encoder::encodedSize(5));
+	EXPECT_EQ(8U, Base64Encoder::encodedSize(6));
 }
 
 TEST(TestBase64, testDecodedSize) {
     const char* nullStr = nullptr;
-    EXPECT_EQ(0, Base64Decoder::decodedSize(wrapMemory(nullStr, 0)));
-    EXPECT_EQ(1, Base64Decoder::decodedSize(wrapMemory("Zg==", 4)));
-    EXPECT_EQ(2, Base64Decoder::decodedSize(wrapMemory("Zm8=", 4)));
-    EXPECT_EQ(3, Base64Decoder::decodedSize(wrapMemory("Zm9v", 4)));
-    EXPECT_EQ(4, Base64Decoder::decodedSize(wrapMemory("Zm9vYg==", 8)));
-    EXPECT_EQ(5, Base64Decoder::decodedSize(wrapMemory("Zm9vYmE=", 8)));
-    EXPECT_EQ(6, Base64Decoder::decodedSize(wrapMemory("Zm9vYmFy", 8)));
+	EXPECT_EQ(0U, Base64Decoder::decodedSize(wrapMemory(nullStr, 0)));
+	EXPECT_EQ(1U, Base64Decoder::decodedSize(wrapMemory("Zg==", 4)));
+	EXPECT_EQ(2U, Base64Decoder::decodedSize(wrapMemory("Zm8=", 4)));
+	EXPECT_EQ(3U, Base64Decoder::decodedSize(wrapMemory("Zm9v", 4)));
+	EXPECT_EQ(4U, Base64Decoder::decodedSize(wrapMemory("Zm9vYg==", 8)));
+	EXPECT_EQ(5U, Base64Decoder::decodedSize(wrapMemory("Zm9vYmE=", 8)));
+	EXPECT_EQ(6U, Base64Decoder::decodedSize(wrapMemory("Zm9vYmFy", 8)));
 }
 
 TEST(TestBase64, testBasicEncoding) {

test/test_byteReader.cpp

@@ -30,9 +30,9 @@ using size_type = ByteReader::size_type;
 TEST(TestReadBuffer, defaultConstructedBufferIsEmpty) {
     ByteReader buffer;
 
-    EXPECT_EQ(0, buffer.capacity());
-    EXPECT_EQ(0, buffer.limit());
-    EXPECT_EQ(0, buffer.position());
+	EXPECT_EQ(0U, buffer.capacity());
+	EXPECT_EQ(0U, buffer.limit());
+	EXPECT_EQ(0U, buffer.position());
 }
 
 
@@ -43,7 +43,7 @@ TEST(TestReadBuffer, constructFromImmutableMemory) {
     ByteReader buffer(wrapMemory(bytes));
     EXPECT_EQ(testSize, buffer.capacity());
     EXPECT_EQ(testSize, buffer.limit());
-    EXPECT_EQ(0, buffer.position());
+	EXPECT_EQ(0U, buffer.position());
 }
 
 TEST(TestReadBuffer, constructFromMutableMemory) {
@@ -55,7 +55,7 @@ TEST(TestReadBuffer, constructFromMutableMemory) {
 	ByteReader buffer(mv(memView));
     EXPECT_EQ(testSize, buffer.capacity());
     EXPECT_EQ(testSize, buffer.limit());
-    EXPECT_EQ(0, buffer.position());
+	EXPECT_EQ(0U, buffer.position());
 }
 
 
@@ -68,11 +68,11 @@ TEST(TestReadBuffer, testPositioning) {
     EXPECT_TRUE(buffer.position(4).isOk());
     EXPECT_EQ(size_type(4), buffer.position());
     EXPECT_TRUE(buffer.position(0).isOk());
-    EXPECT_EQ(0, buffer.position());
+	EXPECT_EQ(0U, buffer.position());
     // Can't go beyond the limit
     EXPECT_TRUE(buffer.position(buffer.limit() + 3).isError());
 
-    EXPECT_EQ(0, buffer.position());
+	EXPECT_EQ(0U, buffer.position());
     EXPECT_TRUE(buffer.advance(5).isOk());
     EXPECT_EQ(size_type(5), buffer.position());
 
@@ -162,7 +162,7 @@ TEST(TestReadBuffer, testReadFromOffset) {
     }
 
     // Make sure we have not moved position
-    EXPECT_EQ(0, buffer.position());
+	EXPECT_EQ(0U, buffer.position());
 
     // We can't read more data than there is in the buffer
     EXPECT_TRUE(buffer.read(testSize - 3, destView, 12).isError());

test/test_byteWriter.cpp

@@ -34,7 +34,7 @@ TEST(TestByteWriter, testPositioning) {
 
     EXPECT_EQ(testSize, buffer.capacity());
     EXPECT_EQ(testSize, buffer.limit());
-    EXPECT_EQ(0, buffer.position());
+	EXPECT_EQ(0U, buffer.position());
 
     EXPECT_TRUE(buffer.position(buffer.position() + 12).isOk());
     EXPECT_TRUE(buffer.position(0).isOk());

test/test_char.cpp

@@ -29,8 +29,8 @@ TEST(TestChar, testConstruction) {
 
     {
         const Char c;
-        EXPECT_EQ(0, c.getBytesCount());
-        EXPECT_EQ(0, c.getValue());
+		EXPECT_EQ(0U, c.getBytesCount());
+		EXPECT_EQ(0U, c.getValue());
     }
 
     {

test/test_dictionary.cpp

@@ -30,8 +30,8 @@ TEST(TestDictionary, testEmptyIntegralDictionaryIsEmpty) {
     Dictionary<int32, int32> v;
 
     EXPECT_TRUE(v.empty());
-    EXPECT_EQ(0, v.size());
-    EXPECT_EQ(0, v.capacity());
+	EXPECT_EQ(0U, v.size());
+	EXPECT_EQ(0U, v.capacity());
 }
 
 
@@ -42,19 +42,19 @@ TEST(TestDictionary, testEmptyDictionaryIsEmpty) {
     Dictionary<int32, SimpleType> v;
 
     EXPECT_TRUE(v.empty());
-    EXPECT_EQ(0, v.size());
-    EXPECT_EQ(0, v.capacity());
-    EXPECT_EQ(0, SimpleType::InstanceCount);
+	EXPECT_EQ(0U, v.size());
+	EXPECT_EQ(0U, v.capacity());
+	EXPECT_EQ(0, SimpleType::InstanceCount);
 }
 
 TEST(TestDictionary, factoryIntergralWithCapacity) {
 	auto maybeDict = makeDictionary<int32, int32>(10);
 	ASSERT_TRUE(maybeDict.isOk());
 	auto& v = maybeDict.unwrap();
 
-    EXPECT_EQ(10, v.capacity());
+	EXPECT_EQ(10U, v.capacity());
     EXPECT_TRUE(v.empty());
-    EXPECT_EQ(0, v.size());
+	EXPECT_EQ(0U, v.size());
 }
 
 TEST(TestDictionary, factoryWithCapacityCreatesNoObjects) {
@@ -63,9 +63,9 @@ TEST(TestDictionary, factoryWithCapacityCreatesNoObjects) {
 	ASSERT_TRUE(maybeDict.isOk());
 	auto& v = maybeDict.unwrap();
 
-    EXPECT_EQ(10, v.capacity());
+	EXPECT_EQ(10U, v.capacity());
     EXPECT_TRUE(v.empty());
-    EXPECT_EQ(0, v.size());
+	EXPECT_EQ(0U, v.size());
     EXPECT_EQ(0, SimpleType::InstanceCount);
 }
 
@@ -84,16 +84,16 @@ TEST(TestDictionary, addIntoIntegralNonEmptyCollection) {
 	ASSERT_TRUE(maybeDict.isOk());
 	auto& v = maybeDict.unwrap();
 
-    EXPECT_EQ(10, v.capacity());
+	EXPECT_EQ(10U, v.capacity());
     EXPECT_TRUE(v.empty());
 
     v.put(321, 99888);
     EXPECT_FALSE(v.empty());
-    EXPECT_EQ(1, v.size());
+	EXPECT_EQ(1U, v.size());
 
     v.put(132, 99888);
     EXPECT_FALSE(v.empty());
-    EXPECT_EQ(2, v.size());
+	EXPECT_EQ(2U, v.size());
 }
 
 TEST(TestDictionary, addIntoNonEmptyCollection) {
@@ -103,16 +103,16 @@ TEST(TestDictionary, addIntoNonEmptyCollection) {
 		ASSERT_TRUE(maybeDict.isOk());
 		auto& v = maybeDict.unwrap();
 
-        EXPECT_EQ(10, v.capacity());
+		EXPECT_EQ(10U, v.capacity());
         EXPECT_TRUE(v.empty());
 
         v.put(321, 99888, 2, 3);
         EXPECT_FALSE(v.empty());
-        EXPECT_EQ(1, v.size());
+		EXPECT_EQ(1U, v.size());
 
         v.put(132, 99888, 3, 2);
         EXPECT_FALSE(v.empty());
-        EXPECT_EQ(2, v.size());
+		EXPECT_EQ(2U, v.size());
     }
 
     ASSERT_EQ(0, SimpleType::InstanceCount);