diff --git a/libpldm/tests/libpldm_bios_table_test.cpp b/libpldm/tests/libpldm_bios_table_test.cpp
index 93477de..aeb1ac3 100644
--- a/libpldm/tests/libpldm_bios_table_test.cpp
+++ b/libpldm/tests/libpldm_bios_table_test.cpp
@@ -410,10 +410,10 @@
         integerEntry.data());
     pldm_bios_table_attr_entry_integer_decode(entry, &lower, &upper, &scalar,
                                               &def);
-    EXPECT_EQ(lower, 1);
-    EXPECT_EQ(upper, 10);
-    EXPECT_EQ(scalar, 2);
-    EXPECT_EQ(def, 3);
+    EXPECT_EQ(lower, 1u);
+    EXPECT_EQ(upper, 10u);
+    EXPECT_EQ(scalar, 2u);
+    EXPECT_EQ(def, 3u);
 }
 
 TEST(AttrTable, ItearatorTest)
@@ -745,7 +745,7 @@
     auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
         integerEntry.data());
     auto cv = pldm_bios_table_attr_value_entry_integer_decode_cv(entry);
-    EXPECT_EQ(cv, 10);
+    EXPECT_EQ(cv, 10u);
 }
 
 TEST(AttrValTable, IteratorTest)
@@ -1101,11 +1101,11 @@
 
 TEST(PadAndChecksum, PadAndChecksum)
 {
-    EXPECT_EQ(4, pldm_bios_table_pad_checksum_size(0));
-    EXPECT_EQ(7, pldm_bios_table_pad_checksum_size(1));
-    EXPECT_EQ(6, pldm_bios_table_pad_checksum_size(2));
-    EXPECT_EQ(5, pldm_bios_table_pad_checksum_size(3));
-    EXPECT_EQ(4, pldm_bios_table_pad_checksum_size(4));
+    EXPECT_EQ(4u, pldm_bios_table_pad_checksum_size(0));
+    EXPECT_EQ(7u, pldm_bios_table_pad_checksum_size(1));
+    EXPECT_EQ(6u, pldm_bios_table_pad_checksum_size(2));
+    EXPECT_EQ(5u, pldm_bios_table_pad_checksum_size(3));
+    EXPECT_EQ(4u, pldm_bios_table_pad_checksum_size(4));
 
     // The table is borrowed from
     // https://github.com/openbmc/pldm/commit/69d3e7fb2d9935773f4fbf44326c33f3fc0a3c38
diff --git a/libpldm/tests/libpldm_fru_test.cpp b/libpldm/tests/libpldm_fru_test.cpp
index 350d1b9..97177c0 100644
--- a/libpldm/tests/libpldm_fru_test.cpp
+++ b/libpldm/tests/libpldm_fru_test.cpp
@@ -14,7 +14,7 @@
     auto rc = encode_get_fru_record_table_metadata_req(0, requestPtr);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(requestPtr->hdr.request, PLDM_REQUEST);
-    ASSERT_EQ(requestPtr->hdr.instance_id, 0);
+    ASSERT_EQ(requestPtr->hdr.instance_id, 0u);
     ASSERT_EQ(requestPtr->hdr.type, PLDM_FRU);
     ASSERT_EQ(requestPtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
 }
@@ -63,13 +63,13 @@
         &total_record_set_identifiers, &total_table_records, &checksum);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(fru_data_major_version, 0x12);
-    ASSERT_EQ(fru_data_minor_version, 0x21);
-    ASSERT_EQ(fru_table_maximum_size, 0x1234ABCD);
-    ASSERT_EQ(fru_table_length, 0x56781234);
-    ASSERT_EQ(total_record_set_identifiers, 0x34EF);
-    ASSERT_EQ(total_table_records, 0xEEEF);
-    ASSERT_EQ(checksum, 0x6543FA71);
+    ASSERT_EQ(fru_data_major_version, 0x12u);
+    ASSERT_EQ(fru_data_minor_version, 0x21u);
+    ASSERT_EQ(fru_table_maximum_size, 0x1234ABCDu);
+    ASSERT_EQ(fru_table_length, 0x56781234u);
+    ASSERT_EQ(total_record_set_identifiers, 0x34EFu);
+    ASSERT_EQ(total_table_records, 0xEEEFu);
+    ASSERT_EQ(checksum, 0x6543FA71u);
 
     response->fru_data_major_version = 0x00;
     response->fru_data_minor_version = 0x00;
@@ -92,17 +92,17 @@
         &total_record_set_identifiers, &total_table_records, &checksum);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
-    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0u);
     ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
     ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
     ASSERT_EQ(completion_code, PLDM_ERROR_INVALID_LENGTH);
-    ASSERT_EQ(fru_data_major_version, 0x00);
-    ASSERT_EQ(fru_data_minor_version, 0x00);
-    ASSERT_EQ(fru_table_maximum_size, 0x00000000);
-    ASSERT_EQ(fru_table_length, 0x00000000);
-    ASSERT_EQ(total_record_set_identifiers, 0x0000);
-    ASSERT_EQ(total_table_records, 0x0000);
-    ASSERT_EQ(checksum, 0x00000000);
+    ASSERT_EQ(fru_data_major_version, 0x00u);
+    ASSERT_EQ(fru_data_minor_version, 0x00u);
+    ASSERT_EQ(fru_table_maximum_size, 0x00000000u);
+    ASSERT_EQ(fru_table_length, 0x00000000u);
+    ASSERT_EQ(total_record_set_identifiers, 0x0000u);
+    ASSERT_EQ(total_table_records, 0x0000u);
+    ASSERT_EQ(checksum, 0x00000000u);
 }
 
 TEST(GetFruRecordTableMetadata, testBadDecodeResponse)
@@ -214,17 +214,17 @@
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
-    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0u);
     ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
     ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
     ASSERT_EQ(response->completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(response->fru_data_major_version, 0x12);
-    ASSERT_EQ(response->fru_data_minor_version, 0x21);
-    ASSERT_EQ(response->fru_table_maximum_size, 0x1234ABCD);
-    ASSERT_EQ(response->fru_table_length, 0x56781234);
-    ASSERT_EQ(response->total_record_set_identifiers, 0x34EF);
-    ASSERT_EQ(response->total_table_records, 0xEEEF);
-    ASSERT_EQ(response->checksum, 0x6543FA71);
+    ASSERT_EQ(response->fru_data_major_version, 0x12u);
+    ASSERT_EQ(response->fru_data_minor_version, 0x21u);
+    ASSERT_EQ(response->fru_table_maximum_size, 0x1234ABCDu);
+    ASSERT_EQ(response->fru_table_length, 0x56781234u);
+    ASSERT_EQ(response->total_record_set_identifiers, 0x34EFu);
+    ASSERT_EQ(response->total_table_records, 0xEEEFu);
+    ASSERT_EQ(response->checksum, 0x6543FA71u);
 
     response->fru_data_major_version = 0;
     response->fru_data_major_version = 0x00;
@@ -242,17 +242,17 @@
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
-    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0u);
     ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
     ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
     ASSERT_EQ(completion_code, PLDM_ERROR_INVALID_DATA);
-    ASSERT_EQ(response->fru_data_major_version, 0x00);
-    ASSERT_EQ(response->fru_data_minor_version, 0x00);
-    ASSERT_EQ(response->fru_table_maximum_size, 0x00000000);
-    ASSERT_EQ(response->fru_table_length, 0x00000000);
-    ASSERT_EQ(response->total_record_set_identifiers, 0x0000);
-    ASSERT_EQ(response->total_table_records, 0x0000);
-    ASSERT_EQ(response->checksum, 0x00000000);
+    ASSERT_EQ(response->fru_data_major_version, 0x00u);
+    ASSERT_EQ(response->fru_data_minor_version, 0x00u);
+    ASSERT_EQ(response->fru_table_maximum_size, 0x00000000u);
+    ASSERT_EQ(response->fru_table_length, 0x00000000u);
+    ASSERT_EQ(response->total_record_set_identifiers, 0x0000u);
+    ASSERT_EQ(response->total_table_records, 0x0000u);
+    ASSERT_EQ(response->checksum, 0x00000000u);
 }
 
 TEST(GetFruRecordTableMetadata, testBadEncodeResponse)
@@ -281,13 +281,13 @@
 
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(response->fru_data_major_version, 0x00);
-    ASSERT_EQ(response->fru_data_minor_version, 0x00);
-    ASSERT_EQ(response->fru_table_maximum_size, 0x00000000);
-    ASSERT_EQ(response->fru_table_length, 0x00000000);
-    ASSERT_EQ(response->total_record_set_identifiers, 0x0000);
-    ASSERT_EQ(response->total_table_records, 0x0000);
-    ASSERT_EQ(response->checksum, 0x00000000);
+    ASSERT_EQ(response->fru_data_major_version, 0x00u);
+    ASSERT_EQ(response->fru_data_minor_version, 0x00u);
+    ASSERT_EQ(response->fru_table_maximum_size, 0x00000000u);
+    ASSERT_EQ(response->fru_table_length, 0x00000000u);
+    ASSERT_EQ(response->total_record_set_identifiers, 0x0000u);
+    ASSERT_EQ(response->total_table_records, 0x0000u);
+    ASSERT_EQ(response->checksum, 0x00000000u);
 }
 
 TEST(GetFruRecordTable, testGoodDecodeRequest)
@@ -359,7 +359,7 @@
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
-    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0u);
     ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
     ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE);
     ASSERT_EQ(response->completion_code, PLDM_SUCCESS);
@@ -382,7 +382,7 @@
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
-    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0u);
     ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
     ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE);
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR);
@@ -415,7 +415,7 @@
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(requestPtr->hdr.request, PLDM_REQUEST);
-    ASSERT_EQ(requestPtr->hdr.instance_id, 0);
+    ASSERT_EQ(requestPtr->hdr.instance_id, 0u);
     ASSERT_EQ(requestPtr->hdr.type, PLDM_FRU);
     ASSERT_EQ(requestPtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE);
     ASSERT_EQ(le32toh(data_transfer_handle), request->data_transfer_handle);
diff --git a/libpldm/tests/libpldm_pdr_test.cpp b/libpldm/tests/libpldm_pdr_test.cpp
index c0fbe32..bbf950d 100644
--- a/libpldm/tests/libpldm_pdr_test.cpp
+++ b/libpldm/tests/libpldm_pdr_test.cpp
@@ -8,8 +8,8 @@
 TEST(PDRAccess, testInit)
 {
     auto repo = pldm_pdr_init();
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0);
-    EXPECT_EQ(pldm_pdr_get_repo_size(repo), 0);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
+    EXPECT_EQ(pldm_pdr_get_repo_size(repo), 0u);
     pldm_pdr_destroy(repo);
 }
 
@@ -19,19 +19,19 @@
 
     std::array<uint8_t, 10> data{};
     auto handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(handle, 1);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(handle, 1u);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size());
 
-    handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(handle, 2);
-    handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(handle, 3);
-    handle = pldm_pdr_add(repo, data.data(), data.size(), htole32(0xdeeddeed),
+    handle = pldm_pdr_add(repo, data.data(), data.size(), 0u, false);
+    EXPECT_EQ(handle, 2u);
+    handle = pldm_pdr_add(repo, data.data(), data.size(), 0u, false);
+    EXPECT_EQ(handle, 3u);
+    handle = pldm_pdr_add(repo, data.data(), data.size(), htole32(0xdeeddeedu),
                           false);
     EXPECT_EQ(handle, htole32(0xdeeddeed));
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
-    EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size() * 4);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
+    EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size() * 4u);
 
     pldm_pdr_destroy(repo);
 }
@@ -42,33 +42,33 @@
 
     auto repo = pldm_pdr_init();
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -77,10 +77,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -89,10 +89,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 6);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 6u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -101,10 +101,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 5);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -113,10 +113,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 5);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -125,10 +125,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -137,10 +137,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 5);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -149,10 +149,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -161,10 +161,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -173,10 +173,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -185,10 +185,10 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
@@ -197,12 +197,12 @@
     pldm_pdr_add(repo, data.data(), data.size(), 0, false);
     pldm_pdr_add(repo, data.data(), data.size(), 0, true);
     pldm_pdr_remove_remote_pdrs(repo);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
     auto handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    EXPECT_EQ(handle, 3);
+    EXPECT_EQ(handle, 3u);
     handle = pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    EXPECT_EQ(handle, 4);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
+    EXPECT_EQ(handle, 4u);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
 }
 
@@ -213,7 +213,7 @@
     std::array<uint32_t, 10> in{100, 345, 3, 6, 89, 0, 11, 45, 23434, 123123};
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in.data()), sizeof(in), 1,
                  false);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in));
     uint32_t size{};
     uint32_t nextRecHdl{};
@@ -221,7 +221,7 @@
     auto hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in));
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(nextRecHdl, 0u);
     EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0);
     outData = nullptr;
 
@@ -229,15 +229,15 @@
     EXPECT_EQ(hdl, hdl2);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in));
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(nextRecHdl, 0u);
     EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0);
     outData = nullptr;
 
     hdl = pldm_pdr_find_record(repo, htole32(0xdeaddead), &outData, &size,
                                &nextRecHdl);
     EXPECT_EQ(hdl, nullptr);
-    EXPECT_EQ(size, 0);
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(size, 0u);
+    EXPECT_EQ(nextRecHdl, 0u);
     EXPECT_EQ(outData, nullptr);
     outData = nullptr;
 
@@ -249,39 +249,39 @@
                  false);
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 4,
                  true);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in2) * 4);
     hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in));
-    EXPECT_EQ(nextRecHdl, 2);
+    EXPECT_EQ(nextRecHdl, 2u);
     EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0);
     outData = nullptr;
     hdl2 = pldm_pdr_find_record(repo, 1, &outData, &size, &nextRecHdl);
     EXPECT_EQ(hdl, hdl2);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in));
-    EXPECT_EQ(nextRecHdl, 2);
+    EXPECT_EQ(nextRecHdl, 2u);
     EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0);
     outData = nullptr;
     hdl = pldm_pdr_find_record(repo, 2, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in2));
-    EXPECT_EQ(nextRecHdl, 3);
+    EXPECT_EQ(nextRecHdl, 3u);
     EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0);
     outData = nullptr;
     hdl = pldm_pdr_find_record(repo, 3, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(pldm_pdr_record_is_remote(hdl), false);
     EXPECT_EQ(size, sizeof(in2));
-    EXPECT_EQ(nextRecHdl, 4);
+    EXPECT_EQ(nextRecHdl, 4u);
     EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0);
     outData = nullptr;
     hdl = pldm_pdr_find_record(repo, 4, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(pldm_pdr_record_is_remote(hdl), true);
     EXPECT_EQ(size, sizeof(in2));
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(nextRecHdl, 0u);
     EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0);
     outData = nullptr;
 
@@ -295,7 +295,7 @@
     std::array<uint32_t, 10> in{100, 345, 3, 6, 89, 0, 11, 45, 23434, 123123};
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in.data()), sizeof(in), 1,
                  false);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in));
     uint32_t size{};
     uint32_t nextRecHdl{};
@@ -303,7 +303,7 @@
     auto hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in));
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(nextRecHdl, 0u);
     EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0);
     outData = nullptr;
 
@@ -315,24 +315,24 @@
                  false);
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 4,
                  false);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in2) * 4);
     hdl = pldm_pdr_get_next_record(repo, hdl, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in2));
-    EXPECT_EQ(nextRecHdl, 3);
+    EXPECT_EQ(nextRecHdl, 3u);
     EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0);
     outData = nullptr;
     hdl = pldm_pdr_get_next_record(repo, hdl, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in2));
-    EXPECT_EQ(nextRecHdl, 4);
+    EXPECT_EQ(nextRecHdl, 4u);
     EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0);
     outData = nullptr;
     hdl = pldm_pdr_get_next_record(repo, hdl, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(in2));
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(nextRecHdl, 0u);
     EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0);
     outData = nullptr;
 
@@ -376,7 +376,7 @@
         pldm_pdr_find_record_by_type(repo, 5, nullptr, &outData, &size);
     EXPECT_EQ(fifthRec, nullptr);
     EXPECT_EQ(outData, nullptr);
-    EXPECT_EQ(size, 0);
+    EXPECT_EQ(size, 0u);
 
     auto rec =
         pldm_pdr_find_record_by_type(repo, 3, secondRec, &outData, &size);
@@ -397,8 +397,8 @@
     auto repo = pldm_pdr_init();
 
     auto handle = pldm_pdr_add_fru_record_set(repo, 1, 10, 1, 0, 100);
-    EXPECT_EQ(handle, 1);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1);
+    EXPECT_EQ(handle, 1u);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo),
               sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set));
     uint32_t size{};
@@ -407,9 +407,9 @@
     auto hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set));
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(nextRecHdl, 0u);
     pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(outData);
-    EXPECT_EQ(hdr->version, 1);
+    EXPECT_EQ(hdr->version, 1u);
     EXPECT_EQ(hdr->type, PLDM_PDR_FRU_RECORD_SET);
     EXPECT_EQ(hdr->length, htole16(sizeof(pldm_pdr_fru_record_set)));
     EXPECT_EQ(hdr->record_handle, htole32(1));
@@ -423,16 +423,16 @@
     outData = nullptr;
 
     handle = pldm_pdr_add_fru_record_set(repo, 2, 11, 2, 1, 101);
-    EXPECT_EQ(handle, 2);
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2);
+    EXPECT_EQ(handle, 2u);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo),
               2 * (sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set)));
     hdl = pldm_pdr_find_record(repo, 2, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set));
-    EXPECT_EQ(nextRecHdl, 0);
+    EXPECT_EQ(nextRecHdl, 0u);
     hdr = reinterpret_cast<pldm_pdr_hdr*>(outData);
-    EXPECT_EQ(hdr->version, 1);
+    EXPECT_EQ(hdr->version, 1u);
     EXPECT_EQ(hdr->type, PLDM_PDR_FRU_RECORD_SET);
     EXPECT_EQ(hdr->length, htole16(sizeof(pldm_pdr_fru_record_set)));
     EXPECT_EQ(hdr->record_handle, htole32(2));
@@ -448,9 +448,9 @@
     hdl = pldm_pdr_find_record(repo, 1, &outData, &size, &nextRecHdl);
     EXPECT_NE(hdl, nullptr);
     EXPECT_EQ(size, sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set));
-    EXPECT_EQ(nextRecHdl, 2);
+    EXPECT_EQ(nextRecHdl, 2u);
     hdr = reinterpret_cast<pldm_pdr_hdr*>(outData);
-    EXPECT_EQ(hdr->version, 1);
+    EXPECT_EQ(hdr->version, 1u);
     EXPECT_EQ(hdr->type, PLDM_PDR_FRU_RECORD_SET);
     EXPECT_EQ(hdr->length, htole16(sizeof(pldm_pdr_fru_record_set)));
     EXPECT_EQ(hdr->record_handle, htole32(1));
@@ -489,10 +489,10 @@
                          repo, pldm_pdr_fru_record_set_find_by_rsi(
                                    repo, 3, &terminusHdl, &entityType,
                                    &entityInstanceNum, &containerId)));
-    EXPECT_EQ(terminusHdl, 1);
-    EXPECT_EQ(entityType, 1);
-    EXPECT_EQ(entityInstanceNum, 2);
-    EXPECT_EQ(containerId, 100);
+    EXPECT_EQ(terminusHdl, 1u);
+    EXPECT_EQ(entityType, 1u);
+    EXPECT_EQ(entityInstanceNum, 2u);
+    EXPECT_EQ(containerId, 100u);
     EXPECT_EQ(nullptr, pldm_pdr_fru_record_set_find_by_rsi(
                            repo, 4, &terminusHdl, &entityType,
                            &entityInstanceNum, &containerId));
@@ -573,38 +573,38 @@
     size_t num{};
     pldm_entity* out = nullptr;
     pldm_entity_association_tree_visit(tree, &out, &num);
-    EXPECT_EQ(num, 9);
+    EXPECT_EQ(num, 9u);
 
-    EXPECT_EQ(out[0].entity_type, 1);
-    EXPECT_EQ(out[0].entity_instance_num, 1);
-    EXPECT_EQ(out[0].entity_container_id, 0);
+    EXPECT_EQ(out[0].entity_type, 1u);
+    EXPECT_EQ(out[0].entity_instance_num, 1u);
+    EXPECT_EQ(out[0].entity_container_id, 0u);
 
-    EXPECT_EQ(out[1].entity_type, 2);
-    EXPECT_EQ(out[1].entity_instance_num, 1);
-    EXPECT_EQ(out[1].entity_container_id, 1);
-    EXPECT_EQ(out[2].entity_type, 2);
-    EXPECT_EQ(out[2].entity_instance_num, 2);
-    EXPECT_EQ(out[2].entity_container_id, 1);
-    EXPECT_EQ(out[3].entity_type, 3);
-    EXPECT_EQ(out[3].entity_instance_num, 1);
-    EXPECT_EQ(out[3].entity_container_id, 1);
+    EXPECT_EQ(out[1].entity_type, 2u);
+    EXPECT_EQ(out[1].entity_instance_num, 1u);
+    EXPECT_EQ(out[1].entity_container_id, 1u);
+    EXPECT_EQ(out[2].entity_type, 2u);
+    EXPECT_EQ(out[2].entity_instance_num, 2u);
+    EXPECT_EQ(out[2].entity_container_id, 1u);
+    EXPECT_EQ(out[3].entity_type, 3u);
+    EXPECT_EQ(out[3].entity_instance_num, 1u);
+    EXPECT_EQ(out[3].entity_container_id, 1u);
 
-    EXPECT_EQ(out[4].entity_type, 4);
-    EXPECT_EQ(out[4].entity_instance_num, 1);
-    EXPECT_EQ(out[4].entity_container_id, 2);
-    EXPECT_EQ(out[5].entity_type, 5);
-    EXPECT_EQ(out[5].entity_instance_num, 1);
-    EXPECT_EQ(out[5].entity_container_id, 2);
-    EXPECT_EQ(out[6].entity_type, 5);
-    EXPECT_EQ(out[6].entity_instance_num, 2);
-    EXPECT_EQ(out[6].entity_container_id, 2);
+    EXPECT_EQ(out[4].entity_type, 4u);
+    EXPECT_EQ(out[4].entity_instance_num, 1u);
+    EXPECT_EQ(out[4].entity_container_id, 2u);
+    EXPECT_EQ(out[5].entity_type, 5u);
+    EXPECT_EQ(out[5].entity_instance_num, 1u);
+    EXPECT_EQ(out[5].entity_container_id, 2u);
+    EXPECT_EQ(out[6].entity_type, 5u);
+    EXPECT_EQ(out[6].entity_instance_num, 2u);
+    EXPECT_EQ(out[6].entity_container_id, 2u);
 
-    EXPECT_EQ(out[7].entity_type, 7);
-    EXPECT_EQ(out[7].entity_instance_num, 1);
-    EXPECT_EQ(out[7].entity_container_id, 4);
-    EXPECT_EQ(out[8].entity_type, 6);
-    EXPECT_EQ(out[8].entity_instance_num, 1);
-    EXPECT_EQ(out[8].entity_container_id, 3);
+    EXPECT_EQ(out[7].entity_type, 7u);
+    EXPECT_EQ(out[7].entity_instance_num, 1u);
+    EXPECT_EQ(out[7].entity_container_id, 4u);
+    EXPECT_EQ(out[8].entity_type, 6u);
+    EXPECT_EQ(out[8].entity_instance_num, 1u);
+    EXPECT_EQ(out[8].entity_container_id, 3u);
 
     free(out);
     pldm_entity_association_tree_destroy(tree);
@@ -626,10 +626,10 @@
     size_t num{};
     pldm_entity* out = nullptr;
     pldm_entity_association_tree_visit(tree, &out, &num);
-    EXPECT_EQ(num, 1);
-    EXPECT_EQ(out[0].entity_type, 1);
-    EXPECT_EQ(out[0].entity_instance_num, 1);
-    EXPECT_EQ(out[0].entity_container_id, 0);
+    EXPECT_EQ(num, 1u);
+    EXPECT_EQ(out[0].entity_type, 1u);
+    EXPECT_EQ(out[0].entity_instance_num, 1u);
+    EXPECT_EQ(out[0].entity_container_id, 0u);
     free(out);
     pldm_entity_association_tree_destroy(tree);
 
@@ -645,16 +645,16 @@
                                             PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
     pldm_entity_association_tree_visit(tree, &out, &num);
-    EXPECT_EQ(num, 3);
-    EXPECT_EQ(out[0].entity_type, 1);
-    EXPECT_EQ(out[0].entity_instance_num, 1);
-    EXPECT_EQ(out[0].entity_container_id, 0);
-    EXPECT_EQ(out[1].entity_type, 1);
-    EXPECT_EQ(out[1].entity_instance_num, 2);
-    EXPECT_EQ(out[1].entity_container_id, 0);
-    EXPECT_EQ(out[2].entity_type, 2);
-    EXPECT_EQ(out[2].entity_instance_num, 1);
-    EXPECT_EQ(out[2].entity_container_id, 0);
+    EXPECT_EQ(num, 3u);
+    EXPECT_EQ(out[0].entity_type, 1u);
+    EXPECT_EQ(out[0].entity_instance_num, 1u);
+    EXPECT_EQ(out[0].entity_container_id, 0u);
+    EXPECT_EQ(out[1].entity_type, 1u);
+    EXPECT_EQ(out[1].entity_instance_num, 2u);
+    EXPECT_EQ(out[1].entity_container_id, 0u);
+    EXPECT_EQ(out[2].entity_type, 2u);
+    EXPECT_EQ(out[2].entity_instance_num, 1u);
+    EXPECT_EQ(out[2].entity_container_id, 0u);
     free(out);
     pldm_entity_association_tree_destroy(tree);
 
@@ -674,16 +674,16 @@
         tree, &entities[2], node1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node2, nullptr);
     pldm_entity_association_tree_visit(tree, &out, &num);
-    EXPECT_EQ(num, 3);
-    EXPECT_EQ(out[0].entity_type, 1);
-    EXPECT_EQ(out[0].entity_instance_num, 1);
-    EXPECT_EQ(out[0].entity_container_id, 0);
-    EXPECT_EQ(out[1].entity_type, 2);
-    EXPECT_EQ(out[1].entity_instance_num, 1);
-    EXPECT_EQ(out[1].entity_container_id, 1);
-    EXPECT_EQ(out[2].entity_type, 1);
-    EXPECT_EQ(out[2].entity_instance_num, 1);
-    EXPECT_EQ(out[2].entity_container_id, 2);
+    EXPECT_EQ(num, 3u);
+    EXPECT_EQ(out[0].entity_type, 1u);
+    EXPECT_EQ(out[0].entity_instance_num, 1u);
+    EXPECT_EQ(out[0].entity_container_id, 0u);
+    EXPECT_EQ(out[1].entity_type, 2u);
+    EXPECT_EQ(out[1].entity_instance_num, 1u);
+    EXPECT_EQ(out[1].entity_container_id, 1u);
+    EXPECT_EQ(out[2].entity_type, 1u);
+    EXPECT_EQ(out[2].entity_instance_num, 1u);
+    EXPECT_EQ(out[2].entity_container_id, 2u);
     free(out);
     pldm_entity_association_tree_destroy(tree);
 
@@ -704,19 +704,19 @@
                                              PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node2, nullptr);
     pldm_entity_association_tree_visit(tree, &out, &num);
-    EXPECT_EQ(num, 4);
-    EXPECT_EQ(out[0].entity_type, 1);
-    EXPECT_EQ(out[0].entity_instance_num, 1);
-    EXPECT_EQ(out[0].entity_container_id, 0);
-    EXPECT_EQ(out[1].entity_type, 1);
-    EXPECT_EQ(out[1].entity_instance_num, 2);
-    EXPECT_EQ(out[1].entity_container_id, 0);
-    EXPECT_EQ(out[2].entity_type, 2);
-    EXPECT_EQ(out[2].entity_instance_num, 1);
-    EXPECT_EQ(out[2].entity_container_id, 1);
-    EXPECT_EQ(out[3].entity_type, 1);
-    EXPECT_EQ(out[3].entity_instance_num, 1);
-    EXPECT_EQ(out[3].entity_container_id, 1);
+    EXPECT_EQ(num, 4u);
+    EXPECT_EQ(out[0].entity_type, 1u);
+    EXPECT_EQ(out[0].entity_instance_num, 1u);
+    EXPECT_EQ(out[0].entity_container_id, 0u);
+    EXPECT_EQ(out[1].entity_type, 1u);
+    EXPECT_EQ(out[1].entity_instance_num, 2u);
+    EXPECT_EQ(out[1].entity_container_id, 0u);
+    EXPECT_EQ(out[2].entity_type, 2u);
+    EXPECT_EQ(out[2].entity_instance_num, 1u);
+    EXPECT_EQ(out[2].entity_container_id, 1u);
+    EXPECT_EQ(out[3].entity_type, 1u);
+    EXPECT_EQ(out[3].entity_instance_num, 1u);
+    EXPECT_EQ(out[3].entity_container_id, 1u);
     free(out);
     pldm_entity_association_tree_destroy(tree);
 }
@@ -812,7 +812,7 @@
     auto repo = pldm_pdr_init();
     pldm_entity_association_pdr_add(tree, repo, false);
 
-    EXPECT_EQ(pldm_pdr_get_record_count(repo), 6);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 6u);
 
     uint32_t currRecHandle{};
     uint32_t nextRecHandle{};
@@ -828,32 +828,32 @@
                                   sizeof(pldm_entity)));
     uint8_t* start = data;
     pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-    EXPECT_EQ(le32toh(hdr->record_handle), 1);
+    EXPECT_EQ(le32toh(hdr->record_handle), 1u);
     EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION);
     EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr));
     start += sizeof(pldm_pdr_hdr);
     uint16_t* containerId = reinterpret_cast<uint16_t*>(start);
-    EXPECT_EQ(le16toh(*containerId), 1);
+    EXPECT_EQ(le16toh(*containerId), 1u);
     start += sizeof(uint16_t);
     EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_LOGICAL);
     start += sizeof(uint8_t);
     pldm_entity* entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 1);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 0);
+    EXPECT_EQ(le16toh(entity->entity_type), 1u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 0u);
     start += sizeof(pldm_entity);
     EXPECT_EQ(*start,
               pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_LOGICAL));
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 3);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 1);
+    EXPECT_EQ(le16toh(entity->entity_type), 3u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 1u);
     start += sizeof(pldm_entity);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 3);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 2);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 1);
+    EXPECT_EQ(le16toh(entity->entity_type), 3u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 2u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 1u);
     start += sizeof(pldm_entity);
 
     currRecHandle = nextRecHandle;
@@ -864,32 +864,32 @@
                                   sizeof(pldm_entity)));
     start = data;
     hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-    EXPECT_EQ(le32toh(hdr->record_handle), 2);
+    EXPECT_EQ(le32toh(hdr->record_handle), 2u);
     EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION);
     EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr));
     start += sizeof(pldm_pdr_hdr);
     containerId = reinterpret_cast<uint16_t*>(start);
-    EXPECT_EQ(le16toh(*containerId), 1);
+    EXPECT_EQ(le16toh(*containerId), 1u);
     start += sizeof(uint16_t);
     EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 1);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 0);
+    EXPECT_EQ(le16toh(entity->entity_type), 1u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 0u);
     start += sizeof(pldm_entity);
     EXPECT_EQ(*start, pldm_entity_get_num_children(
                           l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL));
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 2);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 1);
+    EXPECT_EQ(le16toh(entity->entity_type), 2u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 1u);
     start += sizeof(pldm_entity);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 2);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 2);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 1);
+    EXPECT_EQ(le16toh(entity->entity_type), 2u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 2u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 1u);
     start += sizeof(pldm_entity);
 
     currRecHandle = nextRecHandle;
@@ -900,32 +900,32 @@
                                   sizeof(pldm_entity)));
     start = data;
     hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-    EXPECT_EQ(le32toh(hdr->record_handle), 3);
+    EXPECT_EQ(le32toh(hdr->record_handle), 3u);
     EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION);
     EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr));
     start += sizeof(pldm_pdr_hdr);
     containerId = reinterpret_cast<uint16_t*>(start);
-    EXPECT_EQ(le16toh(*containerId), 2);
+    EXPECT_EQ(le16toh(*containerId), 2u);
     start += sizeof(uint16_t);
     EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_LOGICAL);
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 2);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 1);
+    EXPECT_EQ(le16toh(entity->entity_type), 2u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 1u);
     start += sizeof(pldm_entity);
     EXPECT_EQ(*start, pldm_entity_get_num_children(
                           l2a, PLDM_ENTITY_ASSOCIAION_LOGICAL));
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
     EXPECT_EQ(le16toh(entity->entity_type), 5);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 2);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 2);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 2u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 2u);
     start += sizeof(pldm_entity);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 5);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 3);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 2);
+    EXPECT_EQ(le16toh(entity->entity_type), 5u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 3u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 2u);
     start += sizeof(pldm_entity);
 
     currRecHandle = nextRecHandle;
@@ -936,32 +936,32 @@
                                   sizeof(pldm_entity)));
     start = data;
     hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-    EXPECT_EQ(le32toh(hdr->record_handle), 4);
+    EXPECT_EQ(le32toh(hdr->record_handle), 4u);
     EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION);
     EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr));
     start += sizeof(pldm_pdr_hdr);
     containerId = reinterpret_cast<uint16_t*>(start);
-    EXPECT_EQ(le16toh(*containerId), 2);
+    EXPECT_EQ(le16toh(*containerId), 2u);
     start += sizeof(uint16_t);
     EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 2);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 1);
+    EXPECT_EQ(le16toh(entity->entity_type), 2u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 1u);
     start += sizeof(pldm_entity);
     EXPECT_EQ(*start, pldm_entity_get_num_children(
                           l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL));
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 4);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 2);
+    EXPECT_EQ(le16toh(entity->entity_type), 4u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 2u);
     start += sizeof(pldm_entity);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 5);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 2);
+    EXPECT_EQ(le16toh(entity->entity_type), 5u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 2u);
     start += sizeof(pldm_entity);
 
     currRecHandle = nextRecHandle;
@@ -972,27 +972,27 @@
                                   sizeof(pldm_entity)));
     start = data;
     hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-    EXPECT_EQ(le32toh(hdr->record_handle), 5);
+    EXPECT_EQ(le32toh(hdr->record_handle), 5u);
     EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION);
     EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr));
     start += sizeof(pldm_pdr_hdr);
     containerId = reinterpret_cast<uint16_t*>(start);
-    EXPECT_EQ(le16toh(*containerId), 3);
+    EXPECT_EQ(le16toh(*containerId), 3u);
     start += sizeof(uint16_t);
     EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 4);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 2);
+    EXPECT_EQ(le16toh(entity->entity_type), 4u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 2u);
     start += sizeof(pldm_entity);
     EXPECT_EQ(*start, pldm_entity_get_num_children(
                           l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL));
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 6);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 3);
+    EXPECT_EQ(le16toh(entity->entity_type), 6u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 3u);
     start += sizeof(pldm_entity);
 
     currRecHandle = nextRecHandle;
@@ -1003,29 +1003,29 @@
                                   sizeof(pldm_entity)));
     start = data;
     hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-    EXPECT_EQ(le32toh(hdr->record_handle), 6);
+    EXPECT_EQ(le32toh(hdr->record_handle), 6u);
     EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION);
     EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr));
     start += sizeof(pldm_pdr_hdr);
     containerId = reinterpret_cast<uint16_t*>(start);
-    EXPECT_EQ(le16toh(*containerId), 4);
+    EXPECT_EQ(le16toh(*containerId), 4u);
     start += sizeof(uint16_t);
     EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_LOGICAL);
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 5);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 2);
+    EXPECT_EQ(le16toh(entity->entity_type), 5u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 2u);
     start += sizeof(pldm_entity);
     EXPECT_EQ(*start, pldm_entity_get_num_children(
                           l3b, PLDM_ENTITY_ASSOCIAION_LOGICAL));
     start += sizeof(uint8_t);
     entity = reinterpret_cast<pldm_entity*>(start);
-    EXPECT_EQ(le16toh(entity->entity_type), 7);
-    EXPECT_EQ(le16toh(entity->entity_instance_num), 1);
-    EXPECT_EQ(le16toh(entity->entity_container_id), 4);
+    EXPECT_EQ(le16toh(entity->entity_type), 7u);
+    EXPECT_EQ(le16toh(entity->entity_instance_num), 1u);
+    EXPECT_EQ(le16toh(entity->entity_container_id), 4u);
 
-    EXPECT_EQ(nextRecHandle, 0);
+    EXPECT_EQ(nextRecHandle, 0u);
 
     pldm_pdr_destroy(repo);
     pldm_entity_association_tree_destroy(tree);
@@ -1159,25 +1159,25 @@
     size_t num{};
     pldm_entity* out = nullptr;
     pldm_entity_association_pdr_extract(pdr.data(), pdr.size(), &num, &out);
-    EXPECT_EQ(num, e->num_children + 1);
-    EXPECT_EQ(out[0].entity_type, 1);
-    EXPECT_EQ(out[0].entity_instance_num, 1);
-    EXPECT_EQ(out[0].entity_container_id, 0);
-    EXPECT_EQ(out[1].entity_type, 2);
-    EXPECT_EQ(out[1].entity_instance_num, 1);
-    EXPECT_EQ(out[1].entity_container_id, 1);
-    EXPECT_EQ(out[2].entity_type, 3);
-    EXPECT_EQ(out[2].entity_instance_num, 1);
-    EXPECT_EQ(out[2].entity_container_id, 1);
-    EXPECT_EQ(out[3].entity_type, 4);
-    EXPECT_EQ(out[3].entity_instance_num, 1);
-    EXPECT_EQ(out[3].entity_container_id, 1);
-    EXPECT_EQ(out[4].entity_type, 5);
-    EXPECT_EQ(out[4].entity_instance_num, 1);
-    EXPECT_EQ(out[4].entity_container_id, 1);
-    EXPECT_EQ(out[5].entity_type, 6);
-    EXPECT_EQ(out[5].entity_instance_num, 1);
-    EXPECT_EQ(out[5].entity_container_id, 1);
+    EXPECT_EQ(num, (unsigned)e->num_children + 1);
+    EXPECT_EQ(out[0].entity_type, 1u);
+    EXPECT_EQ(out[0].entity_instance_num, 1u);
+    EXPECT_EQ(out[0].entity_container_id, 0u);
+    EXPECT_EQ(out[1].entity_type, 2u);
+    EXPECT_EQ(out[1].entity_instance_num, 1u);
+    EXPECT_EQ(out[1].entity_container_id, 1u);
+    EXPECT_EQ(out[2].entity_type, 3u);
+    EXPECT_EQ(out[2].entity_instance_num, 1u);
+    EXPECT_EQ(out[2].entity_container_id, 1u);
+    EXPECT_EQ(out[3].entity_type, 4u);
+    EXPECT_EQ(out[3].entity_instance_num, 1u);
+    EXPECT_EQ(out[3].entity_container_id, 1u);
+    EXPECT_EQ(out[4].entity_type, 5u);
+    EXPECT_EQ(out[4].entity_instance_num, 1u);
+    EXPECT_EQ(out[4].entity_container_id, 1u);
+    EXPECT_EQ(out[5].entity_type, 6u);
+    EXPECT_EQ(out[5].entity_instance_num, 1u);
+    EXPECT_EQ(out[5].entity_container_id, 1u);
 
     free(out);
 }
diff --git a/libpldm/tests/libpldm_utils_test.cpp b/libpldm/tests/libpldm_utils_test.cpp
index 990a62b..1b178d7 100644
--- a/libpldm/tests/libpldm_utils_test.cpp
+++ b/libpldm/tests/libpldm_utils_test.cpp
@@ -25,25 +25,25 @@
     const char* vstr = "3.7.10a";
     char buffer[1024];
     auto rc = ver2str(&version, buffer, sizeof(buffer));
-    EXPECT_EQ(rc, std::strlen(vstr));
+    EXPECT_EQ(rc, (signed)std::strlen(vstr));
     EXPECT_STREQ(vstr, buffer);
 
     version = {0x10, 0x01, 0xf7, 0x00};
     vstr = "10.01.7";
     rc = ver2str(&version, buffer, sizeof(buffer));
-    EXPECT_EQ(rc, std::strlen(vstr));
+    EXPECT_EQ(rc, (signed)std::strlen(vstr));
     EXPECT_STREQ(vstr, buffer);
 
     version = {0xf3, 0xf1, 0xff, 0x00};
     vstr = "3.1";
     rc = ver2str(&version, buffer, sizeof(buffer));
-    EXPECT_EQ(rc, std::strlen(vstr));
+    EXPECT_EQ(rc, (signed)std::strlen(vstr));
     EXPECT_STREQ(vstr, buffer);
 
     version = {0xf1, 0xf0, 0xff, 0x61};
     vstr = "1.0a";
     rc = ver2str(&version, buffer, sizeof(buffer));
-    EXPECT_EQ(rc, std::strlen(vstr));
+    EXPECT_EQ(rc, (signed)std::strlen(vstr));
     EXPECT_STREQ(vstr, buffer);
 
     rc = ver2str(&version, buffer, 3);
@@ -59,19 +59,19 @@
 
 TEST(BcdConversion, BcdCoversion)
 {
-    EXPECT_EQ(12, bcd2dec8(0x12));
-    EXPECT_EQ(99, bcd2dec8(0x99));
-    EXPECT_EQ(1234, bcd2dec16(0x1234));
-    EXPECT_EQ(9999, bcd2dec16(0x9999));
-    EXPECT_EQ(12345678, bcd2dec32(0x12345678));
-    EXPECT_EQ(99999999, bcd2dec32(0x99999999));
+    EXPECT_EQ(12u, bcd2dec8(0x12));
+    EXPECT_EQ(99u, bcd2dec8(0x99));
+    EXPECT_EQ(1234u, bcd2dec16(0x1234));
+    EXPECT_EQ(9999u, bcd2dec16(0x9999));
+    EXPECT_EQ(12345678u, bcd2dec32(0x12345678));
+    EXPECT_EQ(99999999u, bcd2dec32(0x99999999));
 
-    EXPECT_EQ(0x12, dec2bcd8(12));
-    EXPECT_EQ(0x99, dec2bcd8(99));
-    EXPECT_EQ(0x1234, dec2bcd16(1234));
-    EXPECT_EQ(0x9999, dec2bcd16(9999));
-    EXPECT_EQ(0x12345678, dec2bcd32(12345678));
-    EXPECT_EQ(0x99999999, dec2bcd32(99999999));
+    EXPECT_EQ(0x12u, dec2bcd8(12));
+    EXPECT_EQ(0x99u, dec2bcd8(99));
+    EXPECT_EQ(0x1234u, dec2bcd16(1234));
+    EXPECT_EQ(0x9999u, dec2bcd16(9999));
+    EXPECT_EQ(0x12345678u, dec2bcd32(12345678));
+    EXPECT_EQ(0x99999999u, dec2bcd32(99999999));
 }
 
 TEST(TimeLegal, TimeLegal)
@@ -87,4 +87,4 @@
     EXPECT_EQ(false, is_time_legal(30, 25, 25, 18, 8, 2019));  // hours illegal
     EXPECT_EQ(false, is_time_legal(30, 70, 16, 18, 8, 2019)); // minutes illegal
     EXPECT_EQ(false, is_time_legal(80, 25, 16, 18, 8, 2019)); // seconds illegal
-}
\ No newline at end of file
+}