diff --git a/tests/libpldm_base_test.cpp b/tests/libpldm_base_test.cpp
index ae4b87e..5b1fb2c 100644
--- a/tests/libpldm_base_test.cpp
+++ b/tests/libpldm_base_test.cpp
@@ -197,7 +197,7 @@
 TEST(GetPLDMCommands, testEncodeRequest)
 {
     uint8_t pldmType = 0x05;
-    ver32_t version{0xFF, 0xFF, 0xFF, 0xFF};
+    ver32_t version{0xff, 0xff, 0xff, 0xff};
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
         requestMsg{};
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
@@ -212,9 +212,9 @@
 TEST(GetPLDMCommands, testDecodeRequest)
 {
     uint8_t pldmType = 0x05;
-    ver32_t version{0xFF, 0xFF, 0xFF, 0xFF};
+    ver32_t version{0xff, 0xff, 0xff, 0xff};
     uint8_t pldmTypeOut{};
-    ver32_t versionOut{0xFF, 0xFF, 0xFF, 0xFF};
+    ver32_t versionOut{0xff, 0xff, 0xff, 0xff};
     std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
 
     memcpy(requestMsg.data() + hdrSize, &pldmType, sizeof(pldmType));
@@ -400,7 +400,7 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES>
         responseMsg{};
     auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
-    ver32_t version = {0xFF, 0xFF, 0xFF, 0xFF};
+    ver32_t version = {0xff, 0xff, 0xff, 0xff};
 
     auto rc = encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END,
                                       &version, sizeof(ver32_t), response);
@@ -454,7 +454,7 @@
     uint8_t flag = PLDM_START_AND_END;
     uint8_t retFlag = PLDM_START_AND_END;
     uint8_t completionCode = 0;
-    ver32_t version = {0xFF, 0xFF, 0xFF, 0xFF};
+    ver32_t version = {0xff, 0xff, 0xff, 0xff};
     ver32_t versionOut;
     uint8_t completion_code;
 
diff --git a/tests/libpldm_firmware_update_test.cpp b/tests/libpldm_firmware_update_test.cpp
index 9a84b3f..52e867a 100644
--- a/tests/libpldm_firmware_update_test.cpp
+++ b/tests/libpldm_firmware_update_test.cpp
@@ -22,7 +22,7 @@
     // Package header identifier for Version 1.0.x
     constexpr std::array<uint8_t, PLDM_FWUP_UUID_LENGTH> uuid{
         0xf0, 0x18, 0x87, 0x8c, 0xcb, 0x7d, 0x49, 0x43,
-        0x98, 0x00, 0xa0, 0x2F, 0x05, 0x9a, 0xca, 0x02};
+        0x98, 0x00, 0xa0, 0x2f, 0x05, 0x9a, 0xca, 0x02};
     // Package header version for DSP0267 version 1.0.x
     constexpr uint8_t pkgHeaderFormatRevision = 0x01;
     // Random PackageHeaderSize
@@ -38,7 +38,7 @@
         sizeof(pldm_package_header_information) + packageVersionStr.size();
 
     constexpr std::array<uint8_t, packagerHeaderSize> packagerHeaderInfo{
-        0xf0, 0x18, 0x87, 0x8c, 0xcb, 0x7d, 0x49, 0x43, 0x98, 0x00, 0xa0, 0x2F,
+        0xf0, 0x18, 0x87, 0x8c, 0xcb, 0x7d, 0x49, 0x43, 0x98, 0x00, 0xa0, 0x2f,
         0x05, 0x9a, 0xca, 0x02, 0x01, 0x2f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x19, 0x0c, 0xe5, 0x07, 0x00, 0x08, 0x00, 0x01, 0x0b,
         0x4f, 0x70, 0x65, 0x6e, 0x42, 0x4d, 0x43, 0x76, 0x31, 0x2e, 0x30};
@@ -81,7 +81,7 @@
     constexpr std::array<uint8_t, packagerHeaderSize>
         invalidPackagerHeaderInfo1{
             0xf0, 0x18, 0x87, 0x8c, 0xcb, 0x7d, 0x49, 0x43, 0x98, 0x00,
-            0xa0, 0x2F, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
+            0xa0, 0x2f, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x0c, 0xe5,
             0x07, 0x00, 0x08, 0x00, 0x06, 0x0b, 0x4f, 0x70, 0x65, 0x6e,
             0x42, 0x4d, 0x43, 0x76, 0x31, 0x2e, 0x30};
@@ -119,7 +119,7 @@
     constexpr std::array<uint8_t, packagerHeaderSize>
         invalidPackagerHeaderInfo2{
             0xf0, 0x18, 0x87, 0x8c, 0xcb, 0x7d, 0x49, 0x43, 0x98, 0x00,
-            0xa0, 0x2F, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
+            0xa0, 0x2f, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x0c, 0xe5,
             0x07, 0x00, 0x08, 0x00, 0x01, 0x00, 0x4f, 0x70, 0x65, 0x6e,
             0x42, 0x4d, 0x43, 0x76, 0x31, 0x2e, 0x30};
@@ -132,7 +132,7 @@
     constexpr std::array<uint8_t, packagerHeaderSize - 1>
         invalidPackagerHeaderInfo3{
             0xf0, 0x18, 0x87, 0x8c, 0xcb, 0x7d, 0x49, 0x43, 0x98, 0x00,
-            0xa0, 0x2F, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
+            0xa0, 0x2f, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x0c, 0xe5,
             0x07, 0x00, 0x08, 0x00, 0x01, 0x0b, 0x4f, 0x70, 0x65, 0x6e,
             0x42, 0x4d, 0x43, 0x76, 0x31, 0x2e};
@@ -145,7 +145,7 @@
     constexpr std::array<uint8_t, packagerHeaderSize>
         invalidPackagerHeaderInfo4{
             0xf0, 0x18, 0x87, 0x8c, 0xcb, 0x7d, 0x49, 0x43, 0x98, 0x00,
-            0xa0, 0x2F, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
+            0xa0, 0x2f, 0x05, 0x9a, 0xca, 0x02, 0x02, 0x2f, 0x01, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x0c, 0xe5,
             0x07, 0x00, 0x09, 0x00, 0x01, 0x0b, 0x4f, 0x70, 0x65, 0x6e,
             0x42, 0x4d, 0x43, 0x76, 0x31, 0x2e, 0x30};
@@ -460,7 +460,7 @@
     constexpr std::array<uint8_t, descriptorsLength> descriptors{
         0x01, 0x00, 0x04, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x02, 0x00, 0x10,
         0x00, 0x12, 0x44, 0xd2, 0x64, 0x8d, 0x7d, 0x47, 0x18, 0xa0, 0x30,
-        0xfc, 0x8a, 0x56, 0x58, 0x7d, 0x5b, 0xFF, 0xFF, 0x0B, 0x00, 0x01,
+        0xfc, 0x8a, 0x56, 0x58, 0x7d, 0x5b, 0xff, 0xff, 0x0b, 0x00, 0x01,
         0x07, 0x4f, 0x70, 0x65, 0x6e, 0x42, 0x4d, 0x43, 0x01, 0x02};
 
     size_t descriptorCount = 1;
@@ -651,7 +651,7 @@
     // Firmware
     constexpr uint16_t compClassification = 16;
     constexpr uint16_t compIdentifier = 300;
-    constexpr uint32_t compComparisonStamp = 0xFFFFFFFF;
+    constexpr uint32_t compComparisonStamp = 0xffffffff;
     // Force update
     constexpr std::bitset<16> compOptions{1};
     // System reboot[Bit position 3] & Medium-specific reset[Bit position 2]
@@ -748,7 +748,7 @@
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     // Use Component Comparison Stamp is not set, but ComponentComparisonStamp
-    // is not 0xFFFFFFFF
+    // is not 0xffffffff
     constexpr std::array<uint8_t, compImageInfoSize> invalidCompImageInfo3{
         0x10, 0x00, 0x2c, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0c, 0x00,
         0x65, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x01, 0x0e, 0x56, 0x65,
@@ -819,7 +819,7 @@
     // filling descriptor data
     std::fill_n(responseMsg.data() + hdrSize +
                     sizeof(struct pldm_query_device_identifiers_resp),
-                descriptorDataLen, 0xFF);
+                descriptorDataLen, 0xff);
 
     auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     uint8_t completionCode = PLDM_SUCCESS;
@@ -871,7 +871,7 @@
     // constexpr uint16_t compClassification = 16;
     // constexpr uint16_t compIdentifier = 300;
     // constexpr uint8_t compClassificationIndex = 20;
-    // constexpr uint32_t activeCompComparisonStamp = 0xABCDEFAB;
+    // constexpr uint32_t activeCompComparisonStamp = 0xabcdefab;
     // constexpr std::array<uint8_t, 8> activeComponentReleaseData = {
     //     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
     // constexpr uint32_t pendingCompComparisonStamp = 0x12345678;
@@ -885,7 +885,7 @@
         pendingCompVersion.size();
 
     constexpr std::array<uint8_t, compParamTableSize> compParamTable{
-        0x10, 0x00, 0x2c, 0x01, 0x14, 0xAB, 0xEF, 0xCD, 0xAB, 0x01, 0x0e, 0x01,
+        0x10, 0x00, 0x2c, 0x01, 0x14, 0xab, 0xef, 0xcd, 0xab, 0x01, 0x0e, 0x01,
         0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x78, 0x56, 0x34, 0x12, 0x01,
         0x0e, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x12, 0x00, 0x02,
         0x00, 0x00, 0x00, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x74,
@@ -903,7 +903,7 @@
             0x0e, 0x01, 0x0e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53,
             0x74, 0x72, 0x69, 0x6e, 0x67, 0x31, 0x56, 0x65, 0x72, 0x73, 0x69,
             0x6f, 0x6e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x10, 0x00,
-            0x2c, 0x01, 0x14, 0xAB, 0xEF, 0xCD, 0xAB, 0x01, 0x0e, 0x01, 0x02,
+            0x2c, 0x01, 0x14, 0xab, 0xef, 0xcd, 0xab, 0x01, 0x0e, 0x01, 0x02,
             0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x78, 0x56, 0x34, 0x12, 0x01,
             0x0e, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x12, 0x00,
             0x02, 0x00, 0x00, 0x00, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
@@ -1188,15 +1188,15 @@
 TEST(GetFirmwareParameters, goodPathDecodeComponentParameterEntry)
 {
     // Random value for component classification
-    constexpr uint16_t compClassification = 0x0A0B;
+    constexpr uint16_t compClassification = 0x0a0b;
     // Random value for component classification
-    constexpr uint16_t compIdentifier = 0x0C0D;
+    constexpr uint16_t compIdentifier = 0x0c0d;
     // Random value for component classification
-    constexpr uint32_t timestamp = 0X12345678;
+    constexpr uint32_t timestamp = 0x12345678;
     // Random value for component activation methods
-    constexpr uint16_t compActivationMethods = 0xBBDD;
+    constexpr uint16_t compActivationMethods = 0xbbdd;
     // Random value for capabilities during update
-    constexpr uint32_t capabilitiesDuringUpdate = 0xBADBEEFE;
+    constexpr uint32_t capabilitiesDuringUpdate = 0xbadbeefe;
 
     // ActiveCompImageSetVerStrLen is not fixed here taking it as 8
     constexpr uint8_t activeCompVerStrLen = 8;
@@ -1212,27 +1212,27 @@
 
     inEntry->comp_classification = htole16(compClassification);
     inEntry->comp_identifier = htole16(compIdentifier);
-    inEntry->comp_classification_index = 0x0F;
+    inEntry->comp_classification_index = 0x0f;
     inEntry->active_comp_comparison_stamp = htole32(timestamp);
     inEntry->active_comp_ver_str_type = 1;
     inEntry->active_comp_ver_str_len = activeCompVerStrLen;
     std::fill_n(inEntry->active_comp_release_date,
-                sizeof(inEntry->active_comp_release_date), 0xFF);
+                sizeof(inEntry->active_comp_release_date), 0xff);
     inEntry->pending_comp_comparison_stamp = htole32(timestamp);
     inEntry->pending_comp_ver_str_type = 1;
     inEntry->pending_comp_ver_str_len = pendingCompVerStrLen;
     std::fill_n(inEntry->pending_comp_release_date,
-                sizeof(inEntry->pending_comp_release_date), 0xFF);
+                sizeof(inEntry->pending_comp_release_date), 0xff);
     inEntry->comp_activation_methods.value = htole16(compActivationMethods);
     inEntry->capabilities_during_update.value =
         htole32(capabilitiesDuringUpdate);
     constexpr auto activeCompVerStrPos =
         sizeof(struct pldm_component_parameter_entry);
-    std::fill_n(entry.data() + activeCompVerStrPos, activeCompVerStrLen, 0xAA);
+    std::fill_n(entry.data() + activeCompVerStrPos, activeCompVerStrLen, 0xaa);
     constexpr auto pendingCompVerStrPos =
         activeCompVerStrPos + activeCompVerStrLen;
     std::fill_n(entry.data() + pendingCompVerStrPos, pendingCompVerStrLen,
-                0xBB);
+                0xbb);
 
     struct pldm_component_parameter_entry outEntry;
     struct variable_field outActiveCompVerStr;
@@ -1368,7 +1368,7 @@
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
     compImgSetVerStrLen = static_cast<uint8_t>(compImgSetVerStr.size());
 
-    compImgSetVerStrInfo.length = 0xFFFF;
+    compImgSetVerStrInfo.length = 0xffff;
     rc = encode_request_update_req(
         instanceId, maxTransferSize, numOfComp, maxOutstandingTransferReq,
         pkgDataLen, PLDM_STR_TYPE_ASCII, compImgSetVerStrLen,
@@ -1507,9 +1507,9 @@
 
     std::array<uint8_t,
                hdrSize + sizeof(pldm_pass_component_table_req) + compVerStrLen>
-        outRequest{0x81, 0x05, 0x13, 0x05, 0x0A, 0x00, 0x90, 0x01, 0x28,
-                   0x78, 0x56, 0x34, 0x12, 0x01, 0x0B, 0x30, 0x70, 0x65,
-                   0x6E, 0x42, 0x6D, 0x63, 0x76, 0x31, 0x2E, 0x31};
+        outRequest{0x81, 0x05, 0x13, 0x05, 0x0a, 0x00, 0x90, 0x01, 0x28,
+                   0x78, 0x56, 0x34, 0x12, 0x01, 0x0b, 0x30, 0x70, 0x65,
+                   0x6e, 0x42, 0x6d, 0x63, 0x76, 0x31, 0x2e, 0x31};
     EXPECT_EQ(request, outRequest);
 }
 
@@ -1612,7 +1612,7 @@
 
     constexpr std::array<uint8_t,
                          hdrSize + sizeof(pldm_pass_component_table_resp)>
-        passCompTableResponse2{0x00, 0x00, 0x00, 0x00, 0x00, 0xD0};
+        passCompTableResponse2{0x00, 0x00, 0x00, 0x00, 0x00, 0xd0};
     auto responseMsg2 =
         reinterpret_cast<const pldm_msg*>(passCompTableResponse2.data());
     rc = decode_pass_component_table_resp(
@@ -1691,7 +1691,7 @@
 
     constexpr std::array<uint8_t,
                          hdrSize + sizeof(pldm_pass_component_table_resp)>
-        passCompTableResponse3{0x00, 0x00, 0x00, 0x00, 0x00, 0x0C};
+        passCompTableResponse3{0x00, 0x00, 0x00, 0x00, 0x00, 0x0c};
     auto responseMsg3 =
         reinterpret_cast<const pldm_msg*>(passCompTableResponse3.data());
     rc = decode_pass_component_table_resp(
@@ -1701,7 +1701,7 @@
 
     constexpr std::array<uint8_t,
                          hdrSize + sizeof(pldm_pass_component_table_resp)>
-        passCompTableResponse4{0x00, 0x00, 0x00, 0x00, 0x00, 0xF0};
+        passCompTableResponse4{0x00, 0x00, 0x00, 0x00, 0x00, 0xf0};
     auto responseMsg4 =
         reinterpret_cast<const pldm_msg*>(passCompTableResponse4.data());
     rc = decode_pass_component_table_resp(
@@ -1715,7 +1715,7 @@
     constexpr uint8_t instanceId = 2;
     constexpr uint16_t compIdentifier = 500;
     constexpr uint8_t compClassificationIndex = 50;
-    constexpr uint32_t compComparisonStamp = 0x89ABCDEF;
+    constexpr uint32_t compComparisonStamp = 0x89abcdef;
     constexpr uint32_t compImageSize = 4096;
     constexpr bitfield32_t updateOptionFlags{1};
     constexpr std::string_view compVerStr = "OpenBmcv2.2";
@@ -1738,10 +1738,10 @@
 
     std::array<uint8_t,
                hdrSize + sizeof(pldm_update_component_req) + compVerStrLen>
-        outRequest{0x82, 0x05, 0x14, 0x0A, 0x00, 0xF4, 0x01, 0x32, 0xEF,
-                   0xCD, 0xAB, 0x89, 0x00, 0x10, 0x00, 0x00, 0x01, 0x00,
-                   0x00, 0x00, 0x01, 0x0B, 0x4f, 0x70, 0x65, 0x6E, 0x42,
-                   0x6D, 0x63, 0x76, 0x32, 0x2E, 0x32};
+        outRequest{0x82, 0x05, 0x14, 0x0a, 0x00, 0xf4, 0x01, 0x32, 0xef,
+                   0xcd, 0xab, 0x89, 0x00, 0x10, 0x00, 0x00, 0x01, 0x00,
+                   0x00, 0x00, 0x01, 0x0b, 0x4f, 0x70, 0x65, 0x6e, 0x42,
+                   0x6d, 0x63, 0x76, 0x32, 0x2e, 0x32};
     EXPECT_EQ(request, outRequest);
 }
 
@@ -1750,7 +1750,7 @@
     constexpr uint8_t instanceId = 2;
     constexpr uint16_t compIdentifier = 500;
     constexpr uint8_t compClassificationIndex = 50;
-    constexpr uint32_t compComparisonStamp = 0x89ABCDEF;
+    constexpr uint32_t compComparisonStamp = 0x89abcdef;
     constexpr uint32_t compImageSize = 4096;
     constexpr bitfield32_t updateOptionFlags{1};
     constexpr std::string_view compVerStr = "OpenBmcv2.2";
@@ -1959,7 +1959,7 @@
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     constexpr std::array<uint8_t, hdrSize + sizeof(pldm_update_component_resp)>
-        updateComponentResponse3{0x00, 0x00, 0x00, 0x00, 0x00, 0x0C,
+        updateComponentResponse3{0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
                                  0x01, 0x00, 0x00, 0x00, 0x64, 0x00};
     auto responseMsg3 =
         reinterpret_cast<const pldm_msg*>(updateComponentResponse3.data());
@@ -1970,7 +1970,7 @@
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     constexpr std::array<uint8_t, hdrSize + sizeof(pldm_update_component_resp)>
-        updateComponentResponse4{0x00, 0x00, 0x00, 0x00, 0x00, 0xF0,
+        updateComponentResponse4{0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
                                  0x01, 0x00, 0x00, 0x00, 0x64, 0x00};
     auto responseMsg4 =
         reinterpret_cast<const pldm_msg*>(updateComponentResponse4.data());
@@ -1987,8 +1987,8 @@
     constexpr uint32_t length = 255;
     constexpr std::array<uint8_t,
                          hdrSize + sizeof(pldm_request_firmware_data_req)>
-        reqFWDataReq{0x00, 0x00, 0x00, 0x2C, 0x01, 0x00,
-                     0x00, 0xFF, 0x00, 0x00, 0x00};
+        reqFWDataReq{0x00, 0x00, 0x00, 0x2c, 0x01, 0x00,
+                     0x00, 0xff, 0x00, 0x00, 0x00};
     auto requestMsg = reinterpret_cast<const pldm_msg*>(reqFWDataReq.data());
 
     uint32_t outOffset = 0;
@@ -2006,8 +2006,8 @@
 {
     constexpr std::array<uint8_t,
                          hdrSize + sizeof(pldm_request_firmware_data_req)>
-        reqFWDataReq{0x00, 0x00, 0x00, 0x2C, 0x01, 0x00,
-                     0x00, 0x1F, 0x00, 0x00, 0x00};
+        reqFWDataReq{0x00, 0x00, 0x00, 0x2c, 0x01, 0x00,
+                     0x00, 0x1f, 0x00, 0x00, 0x00};
     auto requestMsg = reinterpret_cast<const pldm_msg*>(reqFWDataReq.data());
 
     uint32_t outOffset = 0;
@@ -2045,17 +2045,17 @@
     constexpr std::array<uint8_t, hdrSize + sizeof(completionCode) +
                                       PLDM_FWUP_BASELINE_TRANSFER_SIZE>
         outReqFwDataResponse1{0x03, 0x05, 0x15, 0x00, 0x01, 0x02, 0x03, 0x04,
-                              0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,
-                              0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
-                              0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C,
-                              0x1D, 0x1E, 0x1F, 0x20};
+                              0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
+                              0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
+                              0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
+                              0x1d, 0x1e, 0x1f, 0x20};
     std::array<uint8_t, hdrSize + sizeof(completionCode) +
                             PLDM_FWUP_BASELINE_TRANSFER_SIZE>
         reqFwDataResponse1{0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
-                           0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,
-                           0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
-                           0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C,
-                           0x1D, 0x1E, 0x1F, 0x20};
+                           0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
+                           0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
+                           0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
+                           0x1d, 0x1e, 0x1f, 0x20};
     auto responseMsg1 = reinterpret_cast<pldm_msg*>(reqFwDataResponse1.data());
     auto rc = encode_request_firmware_data_resp(
         instanceId, completionCode, responseMsg1,
@@ -2368,7 +2368,7 @@
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     std::array<uint8_t, hdrSize + sizeof(pldm_activate_firmware_req)>
-        outRequest{0x87, 0x05, 0x1A, 0x01};
+        outRequest{0x87, 0x05, 0x1a, 0x01};
     EXPECT_EQ(request, outRequest);
 }
 
@@ -2468,7 +2468,7 @@
                                     PLDM_GET_STATUS_REQ_BYTES);
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
-    constexpr std::array<uint8_t, hdrSize> outRequest{0x88, 0x05, 0x1B};
+    constexpr std::array<uint8_t, hdrSize> outRequest{0x88, 0x05, 0x1b};
     EXPECT_EQ(request, outRequest);
 }
 
@@ -2675,7 +2675,7 @@
 
     constexpr std::array<uint8_t, hdrSize + sizeof(pldm_get_status_resp)>
         getStatusResponse6{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                           0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+                           0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     auto responseMsg6 =
         reinterpret_cast<const pldm_msg*>(getStatusResponse6.data());
     rc = decode_get_status_resp(
@@ -2697,7 +2697,7 @@
 
     constexpr std::array<uint8_t, hdrSize + sizeof(pldm_get_status_resp)>
         getStatusResponse8{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                           0x00, 0x00, 0xC7, 0x00, 0x00, 0x00, 0x00};
+                           0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0x00};
     auto responseMsg8 =
         reinterpret_cast<const pldm_msg*>(getStatusResponse8.data());
     rc = decode_get_status_resp(
@@ -2730,7 +2730,7 @@
         instanceId, requestMsg, PLDM_CANCEL_UPDATE_COMPONENT_REQ_BYTES);
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
-    constexpr std::array<uint8_t, hdrSize> outRequest{0x89, 0x05, 0x1C};
+    constexpr std::array<uint8_t, hdrSize> outRequest{0x89, 0x05, 0x1c};
     EXPECT_EQ(request, outRequest);
 }
 
@@ -2805,7 +2805,7 @@
                                        PLDM_CANCEL_UPDATE_REQ_BYTES);
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
-    constexpr std::array<uint8_t, hdrSize> outRequest{0x8A, 0x05, 0x1D};
+    constexpr std::array<uint8_t, hdrSize> outRequest{0x8a, 0x05, 0x1d};
     EXPECT_EQ(request, outRequest);
 }
 
diff --git a/tests/libpldm_fru_test.cpp b/tests/libpldm_fru_test.cpp
index 7567683..11cbc5d 100644
--- a/tests/libpldm_fru_test.cpp
+++ b/tests/libpldm_fru_test.cpp
@@ -50,13 +50,13 @@
     response->completion_code = PLDM_SUCCESS;
     response->fru_data_major_version = 0x12;
     response->fru_data_minor_version = 0x21;
-    response->fru_table_maximum_size = htole32(0x1234ABCD);
+    response->fru_table_maximum_size = htole32(0x1234abcd);
     response->fru_table_length = htole32(0x56781234);
-    response->total_record_set_identifiers = htole16(0x34EF);
-    response->total_table_records = htole16(0xEEEF);
-    response->checksum = htole32(0x6543FA71);
+    response->total_record_set_identifiers = htole16(0x34ef);
+    response->total_table_records = htole16(0xeeef);
+    response->checksum = htole32(0x6543fa71);
 
-    uint8_t completion_code = 0xFF;
+    uint8_t completion_code = 0xff;
     uint8_t fru_data_major_version = 0x00;
     uint8_t fru_data_minor_version = 0x00;
     uint32_t fru_table_maximum_size = htole32(0x00000000);
@@ -73,11 +73,11 @@
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
     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_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);
+    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;
@@ -125,13 +125,13 @@
     response->completion_code = PLDM_SUCCESS;
     response->fru_data_major_version = 0x12;
     response->fru_data_minor_version = 0x21;
-    response->fru_table_maximum_size = htole32(0x1234ABCD);
+    response->fru_table_maximum_size = htole32(0x1234abcd);
     response->fru_table_length = htole32(0x56781234);
-    response->total_record_set_identifiers = htole16(0x34EF);
-    response->total_table_records = htole16(0xEEEF);
-    response->checksum = htole32(0x6543FA71);
+    response->total_record_set_identifiers = htole16(0x34ef);
+    response->total_table_records = htole16(0xeeef);
+    response->checksum = htole32(0x6543fa71);
 
-    uint8_t completion_code = 0xFF;
+    uint8_t completion_code = 0xff;
     uint8_t fru_data_major_version = 0x00;
     uint8_t fru_data_minor_version = 0x00;
     uint32_t fru_table_maximum_size = htole32(0x00000000);
@@ -206,11 +206,11 @@
     uint8_t completion_code = PLDM_SUCCESS;
     uint8_t fru_data_major_version = 0x12;
     uint8_t fru_data_minor_version = 0x21;
-    uint32_t fru_table_maximum_size = htole32(0x1234ABCD);
+    uint32_t fru_table_maximum_size = htole32(0x1234abcd);
     uint32_t fru_table_length = htole32(0x56781234);
-    uint16_t total_record_set_identifiers = htole16(0x34EF);
-    uint16_t total_table_records = htole16(0xEEEF);
-    uint32_t checksum = htole32(0x6543FA71);
+    uint16_t total_record_set_identifiers = htole16(0x34ef);
+    uint16_t total_table_records = htole16(0xeeef);
+    uint32_t checksum = htole32(0x6543fa71);
 
     auto rc = encode_get_fru_record_table_metadata_resp(
         0, completion_code, fru_data_major_version, fru_data_minor_version,
@@ -228,11 +228,11 @@
     ASSERT_EQ(response->completion_code, PLDM_SUCCESS);
     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_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);
+    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;
@@ -273,11 +273,11 @@
     uint8_t completion_code = PLDM_SUCCESS;
     uint8_t fru_data_major_version = 0x12;
     uint8_t fru_data_minor_version = 0x21;
-    uint32_t fru_table_maximum_size = htole32(0x1234ABCD);
+    uint32_t fru_table_maximum_size = htole32(0x1234abcd);
     uint32_t fru_table_length = htole32(0x56781234);
-    uint16_t total_record_set_identifiers = htole16(0x34EF);
-    uint16_t total_table_records = htole16(0xEEEF);
-    uint32_t checksum = htole32(0x6543FA71);
+    uint16_t total_record_set_identifiers = htole16(0x34ef);
+    uint16_t total_table_records = htole16(0xeeef);
+    uint32_t checksum = htole32(0x6543fa71);
 
     auto rc = encode_get_fru_record_table_metadata_resp(
         0, completion_code, fru_data_major_version, fru_data_minor_version,
diff --git a/tests/libpldm_pdr_test.cpp b/tests/libpldm_pdr_test.cpp
index d796587..65edf32 100644
--- a/tests/libpldm_pdr_test.cpp
+++ b/tests/libpldm_pdr_test.cpp
@@ -756,31 +756,31 @@
     auto tree = pldm_entity_association_tree_init();
 
     auto l1 = pldm_entity_association_tree_add(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l1, nullptr);
     auto l2a = pldm_entity_association_tree_add(
-        tree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2a, nullptr);
     auto l2b = pldm_entity_association_tree_add(
-        tree, &entities[2], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2b, nullptr);
     auto l2c = pldm_entity_association_tree_add(
-        tree, &entities[3], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2c, nullptr);
     auto l3a = pldm_entity_association_tree_add(
-        tree, &entities[4], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[4], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3a, nullptr);
     auto l3b = pldm_entity_association_tree_add(
-        tree, &entities[5], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[5], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3b, nullptr);
     auto l3c = pldm_entity_association_tree_add(
-        tree, &entities[6], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[6], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3b, nullptr);
     auto l4a = pldm_entity_association_tree_add(
-        tree, &entities[7], 0xFFFF, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[7], 0xffff, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l4a, nullptr);
     auto l4b = pldm_entity_association_tree_add(
-        tree, &entities[8], 0xFFFF, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[8], 0xffff, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l4b, nullptr);
 
     EXPECT_EQ(pldm_entity_is_node_parent(l1), true);
@@ -958,32 +958,32 @@
     entities[8].entity_type = 32903;
     auto tree = pldm_entity_association_tree_init();
     auto l1 = pldm_entity_association_tree_add_entity(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_LOGICAL,
-        false, true, 0xFFFF);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_LOGICAL,
+        false, true, 0xffff);
     EXPECT_NE(l1, nullptr);
     auto l2 = pldm_entity_association_tree_add_entity(
-        tree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        false, 0xFFFF);
+        tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
+        false, 0xffff);
     EXPECT_NE(l2, nullptr);
     auto l3 = pldm_entity_association_tree_add_entity(
-        tree, &entities[2], 0xFFFF, l2, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        true, 0xFFFF);
+        tree, &entities[2], 0xffff, l2, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
+        true, 0xffff);
     EXPECT_NE(l3, nullptr);
     auto l4a = pldm_entity_association_tree_add_entity(
         tree, &entities[3], 0, l3, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        false, 0xFFFF);
+        false, 0xffff);
     EXPECT_NE(l4a, nullptr);
     auto l4b = pldm_entity_association_tree_add_entity(
         tree, &entities[4], 1, l3, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true,
-        0xFFFF);
+        0xffff);
     EXPECT_NE(l4b, nullptr);
     auto l5a = pldm_entity_association_tree_add_entity(
         tree, &entities[5], 0, l4a, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        false, 0xFFFF);
+        false, 0xffff);
     EXPECT_NE(l5a, nullptr);
     auto l5b = pldm_entity_association_tree_add_entity(
         tree, &entities[6], 0, l4b, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        false, 0xFFFF);
+        false, 0xffff);
     EXPECT_NE(l5b, nullptr);
     pldm_entity entity{};
     entity.entity_type = 135;
@@ -994,7 +994,7 @@
     EXPECT_EQ(entities[5].entity_container_id, 2);
     auto l6a = pldm_entity_association_tree_add_entity(
         tree, &entities[7], 0, result1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        false, 0xFFFF);
+        false, 0xffff);
     EXPECT_NE(l6a, nullptr);
     entity.entity_type = 135;
     entity.entity_instance_num = 0;
@@ -1004,7 +1004,7 @@
     EXPECT_EQ(entities[6].entity_container_id, 3);
     auto l7a = pldm_entity_association_tree_add_entity(
         tree, &entities[8], 0, result2, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        false, 0xFFFF);
+        false, 0xffff);
     EXPECT_EQ(l7a, nullptr);
     pldm_entity_association_tree_destroy(tree);
 }
@@ -1021,7 +1021,7 @@
     // A
     auto tree = pldm_entity_association_tree_init();
     auto node = pldm_entity_association_tree_add(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
     size_t num{};
     pldm_entity* out = nullptr;
@@ -1035,13 +1035,13 @@
 
     // A-A-A
     tree = pldm_entity_association_tree_init();
-    node = pldm_entity_association_tree_add(tree, &entities[0], 0xFFFF, nullptr,
+    node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr,
                                             PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
-    node = pldm_entity_association_tree_add(tree, &entities[1], 0xFFFF, nullptr,
+    node = pldm_entity_association_tree_add(tree, &entities[1], 0xffff, nullptr,
                                             PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
-    node = pldm_entity_association_tree_add(tree, &entities[2], 0xFFFF, nullptr,
+    node = pldm_entity_association_tree_add(tree, &entities[2], 0xffff, nullptr,
                                             PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
     pldm_entity_association_tree_visit(tree, &out, &num);
@@ -1064,14 +1064,14 @@
     // |
     // A
     tree = pldm_entity_association_tree_init();
-    node = pldm_entity_association_tree_add(tree, &entities[0], 0xFFFF, nullptr,
+    node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr,
                                             PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
     auto node1 = pldm_entity_association_tree_add(
-        tree, &entities[1], 0xFFFF, node, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[1], 0xffff, node, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node1, nullptr);
     auto node2 = pldm_entity_association_tree_add(
-        tree, &entities[2], 0xFFFF, node1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[2], 0xffff, node1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node2, nullptr);
     pldm_entity_association_tree_visit(tree, &out, &num);
     EXPECT_EQ(num, 3u);
@@ -1091,16 +1091,16 @@
     //   |
     //   A-A
     tree = pldm_entity_association_tree_init();
-    node = pldm_entity_association_tree_add(tree, &entities[0], 0xFFFF, nullptr,
+    node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr,
                                             PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
-    node = pldm_entity_association_tree_add(tree, &entities[0], 0xFFFF, nullptr,
+    node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr,
                                             PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
-    node1 = pldm_entity_association_tree_add(tree, &entities[1], 0xFFFF, node,
+    node1 = pldm_entity_association_tree_add(tree, &entities[1], 0xffff, node,
                                              PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node1, nullptr);
-    node2 = pldm_entity_association_tree_add(tree, &entities[2], 0xFFFF, node,
+    node2 = pldm_entity_association_tree_add(tree, &entities[2], 0xffff, node,
                                              PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node2, nullptr);
     pldm_entity_association_tree_visit(tree, &out, &num);
@@ -1159,43 +1159,43 @@
     auto tree = pldm_entity_association_tree_init();
 
     auto l1 = pldm_entity_association_tree_add(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l1, nullptr);
     auto l1a = pldm_entity_association_tree_add(
-        tree, &entities[1], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[1], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l1a, nullptr);
 
     auto l2a = pldm_entity_association_tree_add(
-        tree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2a, nullptr);
-    auto l2b = pldm_entity_association_tree_add(tree, &entities[2], 0xFFFF, l1,
+    auto l2b = pldm_entity_association_tree_add(tree, &entities[2], 0xffff, l1,
                                                 PLDM_ENTITY_ASSOCIAION_LOGICAL);
     EXPECT_NE(l2b, nullptr);
     auto l2c = pldm_entity_association_tree_add(
-        tree, &entities[3], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2c, nullptr);
-    auto l2d = pldm_entity_association_tree_add(tree, &entities[4], 0xFFFF, l1,
+    auto l2d = pldm_entity_association_tree_add(tree, &entities[4], 0xffff, l1,
                                                 PLDM_ENTITY_ASSOCIAION_LOGICAL);
     EXPECT_NE(l2d, nullptr);
 
     auto l3a = pldm_entity_association_tree_add(
-        tree, &entities[5], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[5], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3a, nullptr);
     auto l3b = pldm_entity_association_tree_add(
-        tree, &entities[6], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[6], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3b, nullptr);
-    auto l3c = pldm_entity_association_tree_add(tree, &entities[7], 0xFFFF, l2a,
+    auto l3c = pldm_entity_association_tree_add(tree, &entities[7], 0xffff, l2a,
                                                 PLDM_ENTITY_ASSOCIAION_LOGICAL);
     EXPECT_NE(l3c, nullptr);
-    auto l3d = pldm_entity_association_tree_add(tree, &entities[8], 0xFFFF, l2a,
+    auto l3d = pldm_entity_association_tree_add(tree, &entities[8], 0xffff, l2a,
                                                 PLDM_ENTITY_ASSOCIAION_LOGICAL);
     EXPECT_NE(l3d, nullptr);
 
     auto l4a = pldm_entity_association_tree_add(
-        tree, &entities[9], 0xFFFF, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[9], 0xffff, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l4a, nullptr);
     auto l4b = pldm_entity_association_tree_add(
-        tree, &entities[10], 0xFFFF, l3b, PLDM_ENTITY_ASSOCIAION_LOGICAL);
+        tree, &entities[10], 0xffff, l3b, PLDM_ENTITY_ASSOCIAION_LOGICAL);
     EXPECT_NE(l4b, nullptr);
 
     EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL),
@@ -1452,31 +1452,31 @@
     auto tree = pldm_entity_association_tree_init();
 
     auto l1 = pldm_entity_association_tree_add(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l1, nullptr);
     auto l2a = pldm_entity_association_tree_add(
-        tree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2a, nullptr);
     auto l2b = pldm_entity_association_tree_add(
-        tree, &entities[2], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2b, nullptr);
     auto l2c = pldm_entity_association_tree_add(
-        tree, &entities[3], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2c, nullptr);
     auto l3a = pldm_entity_association_tree_add(
-        tree, &entities[4], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[4], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3a, nullptr);
     auto l3b = pldm_entity_association_tree_add(
-        tree, &entities[5], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[5], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3b, nullptr);
     auto l3c = pldm_entity_association_tree_add(
-        tree, &entities[6], 0xFFFF, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[6], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l3c, nullptr);
     auto l4a = pldm_entity_association_tree_add(
-        tree, &entities[7], 0xFFFF, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[7], 0xffff, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l4a, nullptr);
     auto l4b = pldm_entity_association_tree_add(
-        tree, &entities[8], 0xFFFF, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[8], 0xffff, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l4b, nullptr);
 
     pldm_entity entity{};
@@ -1523,17 +1523,17 @@
     auto orgTree = pldm_entity_association_tree_init();
     auto newTree = pldm_entity_association_tree_init();
     auto l1 =
-        pldm_entity_association_tree_add(orgTree, &entities[0], 0xFFFF, nullptr,
+        pldm_entity_association_tree_add(orgTree, &entities[0], 0xffff, nullptr,
                                          PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l1, nullptr);
     auto l2a = pldm_entity_association_tree_add(
-        orgTree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        orgTree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2a, nullptr);
     auto l2b = pldm_entity_association_tree_add(
-        orgTree, &entities[2], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        orgTree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2b, nullptr);
     auto l2c = pldm_entity_association_tree_add(
-        orgTree, &entities[3], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        orgTree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2c, nullptr);
     size_t orgNum{};
     pldm_entity* orgOut = nullptr;
@@ -1630,16 +1630,16 @@
 
     auto tree = pldm_entity_association_tree_init();
     auto l1 = pldm_entity_association_tree_add(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l1, nullptr);
     auto l2a = pldm_entity_association_tree_add(
-        tree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2a, nullptr);
     auto l2b = pldm_entity_association_tree_add(
-        tree, &entities[2], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2b, nullptr);
     auto l2c = pldm_entity_association_tree_add(
-        tree, &entities[3], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2c, nullptr);
 
     pldm_entity et1;
@@ -1683,7 +1683,7 @@
     uint16_t containerId{};
 
     auto node = pldm_entity_association_tree_add(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(node, nullptr);
 
     auto l1 = pldm_entity_association_tree_add(tree, &entities[1], 63, node,
@@ -1754,7 +1754,7 @@
     EXPECT_EQ(entityType, 2);
     EXPECT_EQ(entityInstanceNum, 89);
 
-    auto l5 = pldm_entity_association_tree_add(tree, &entities[5], 0xFFFF, node,
+    auto l5 = pldm_entity_association_tree_add(tree, &entities[5], 0xffff, node,
                                                PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     uint32_t fifth = 5;
     EXPECT_EQ(pldm_pdr_add_fru_record_set_check(
@@ -1825,17 +1825,17 @@
 
     auto tree = pldm_entity_association_tree_init();
     auto l1 = pldm_entity_association_tree_add_entity(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_LOGICAL,
-        false, true, 0xFFFF);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_LOGICAL,
+        false, true, 0xffff);
 
     EXPECT_NE(l1, nullptr);
     auto l2 = pldm_entity_association_tree_add_entity(
-        tree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        false, 0xFFFF);
+        tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
+        false, 0xffff);
     EXPECT_NE(l2, nullptr);
     auto l3 = pldm_entity_association_tree_add_entity(
-        tree, &entities[2], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
-        true, 0xFFFF);
+        tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false,
+        true, 0xffff);
     EXPECT_NE(l3, nullptr);
 
     EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL),
@@ -1849,12 +1849,12 @@
 
     uint16_t container_id{};
     pldm_pdr_find_child_container_id_index_range_exclude(
-        repo, 1, 1, 0, 0x01000000, 0x01FFFFFF, &container_id);
+        repo, 1, 1, 0, 0x01000000, 0x01ffffff, &container_id);
     EXPECT_EQ(container_id, 2);
 
     uint16_t container_id1{};
     pldm_pdr_find_child_container_id_index_range_exclude(
-        repo, 1, 1, 0, 0x00000001, 0x00FFFFFF, &container_id1);
+        repo, 1, 1, 0, 0x00000001, 0x00ffffff, &container_id1);
     EXPECT_EQ(container_id1, 0);
 
     pldm_pdr_destroy(repo);
@@ -1874,16 +1874,16 @@
     auto tree = pldm_entity_association_tree_init();
 
     auto l1 = pldm_entity_association_tree_add(
-        tree, &entities[0], 0xFFFF, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l1, nullptr);
     auto l2a = pldm_entity_association_tree_add(
-        tree, &entities[1], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2a, nullptr);
     auto l2b = pldm_entity_association_tree_add(
-        tree, &entities[2], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2b, nullptr);
     auto l2c = pldm_entity_association_tree_add(
-        tree, &entities[3], 0xFFFF, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
+        tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
     EXPECT_NE(l2c, nullptr);
 
     auto repo = pldm_pdr_init();
diff --git a/tests/libpldm_platform_test.cpp b/tests/libpldm_platform_test.cpp
index a3ce592..f3ec7e7 100644
--- a/tests/libpldm_platform_test.cpp
+++ b/tests/libpldm_platform_test.cpp
@@ -36,7 +36,7 @@
         requestMsg{};
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
-    uint16_t effecterId = 0x0A;
+    uint16_t effecterId = 0x0a;
     uint8_t compEffecterCnt = 0x2;
     std::array<set_effecter_state_field, 8> stateField{};
     stateField[0] = {PLDM_REQUEST_SET, 2};
@@ -665,7 +665,7 @@
     std::array<uint8_t, hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES>
         responseMsg{};
 
-    uint8_t completion_code = 0xA0;
+    uint8_t completion_code = 0xa0;
 
     uint8_t retcompletion_code;
 
@@ -854,7 +854,7 @@
     std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
         requestMsg{};
 
-    uint16_t sensorId = 0xAB;
+    uint16_t sensorId = 0xab;
     bitfield8_t sensorRearm;
     sensorRearm.byte = 0x03;
 
@@ -887,7 +887,7 @@
     std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
         requestMsg{};
 
-    uint16_t sensorId = 0xCD;
+    uint16_t sensorId = 0xcd;
     bitfield8_t sensorRearm;
     sensorRearm.byte = 0x10;
 
@@ -2463,7 +2463,7 @@
     std::vector<uint8_t> requestMsg(hdrSize +
                                     PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES);
 
-    uint16_t effecter_id = 0xAB01;
+    uint16_t effecter_id = 0xab01;
 
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
@@ -2496,7 +2496,7 @@
         reinterpret_cast<struct pldm_get_numeric_effecter_value_req*>(
             request->payload);
 
-    uint16_t effecter_id = 0x12AB;
+    uint16_t effecter_id = 0x12ab;
     req->effecter_id = htole16(effecter_id);
 
     uint16_t reteffecter_id;
@@ -2523,7 +2523,7 @@
         reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
             request->payload);
 
-    uint16_t effecter_id = 0x1A;
+    uint16_t effecter_id = 0x1a;
     req->effecter_id = htole16(effecter_id);
     uint16_t reteffecter_id;
 
@@ -2539,7 +2539,7 @@
     uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT32;
     uint8_t effecter_operState = EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING;
     uint32_t pendingValue = 0x12345678;
-    uint32_t presentValue = 0xABCDEF11;
+    uint32_t presentValue = 0xabcdef11;
     uint32_t val_pending;
     uint32_t val_present;
 
@@ -2614,7 +2614,7 @@
     uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT16;
     uint8_t effecter_operState = EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING;
     uint16_t pendingValue = 0x4321;
-    uint16_t presentValue = 0xDCBA;
+    uint16_t presentValue = 0xdcba;
 
     uint8_t retcompletionCode;
     uint8_t reteffecter_dataSize;
@@ -2667,7 +2667,7 @@
     uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_SINT16;
     uint8_t effecter_operState = EFFECTER_OPER_STATE_DISABLED;
     uint16_t pendingValue = 0x5678;
-    uint16_t presentValue = 0xCDEF;
+    uint16_t presentValue = 0xcdef;
 
     uint8_t retcompletionCode;
     uint8_t reteffecter_dataSize;
@@ -2848,8 +2848,8 @@
     std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_REQ_BYTES>
         requestMsg{};
 
-    uint16_t sensorId = 0xABCD;
-    bool8_t rearmEventState = 0xA;
+    uint16_t sensorId = 0xabcd;
+    bool8_t rearmEventState = 0xa;
 
     uint16_t retsensorId;
     bool8_t retrearmEventState;
@@ -2880,8 +2880,8 @@
         nullptr, requestMsg.size() - hdrSize, nullptr, nullptr);
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
-    uint16_t sensorId = 0xABCD;
-    bool8_t rearmEventState = 0xA;
+    uint16_t sensorId = 0xabcd;
+    bool8_t rearmEventState = 0xa;
 
     uint16_t retsensorId;
     bool8_t retrearmEventState;
@@ -2979,7 +2979,7 @@
     uint8_t presentState = PLDM_SENSOR_CRITICAL;
     uint8_t previousState = PLDM_SENSOR_UPPERCRITICAL;
     uint8_t eventState = PLDM_SENSOR_WARNING;
-    uint32_t presentReading = 0xABCDEF11;
+    uint32_t presentReading = 0xabcdef11;
 
     uint8_t retcompletionCode;
     uint8_t retsensor_dataSize = PLDM_SENSOR_DATA_SIZE_UINT32;
@@ -3043,7 +3043,7 @@
     uint8_t presentState = PLDM_SENSOR_FATAL;
     uint8_t previousState = PLDM_SENSOR_UPPERFATAL;
     uint8_t eventState = PLDM_SENSOR_WARNING;
-    uint8_t presentReading = 0xA;
+    uint8_t presentReading = 0xa;
 
     uint8_t retcompletionCode;
     uint8_t retsensor_dataSize = PLDM_SENSOR_DATA_SIZE_SINT16;
diff --git a/tests/oem/ibm/libpldm_fileio_test.cpp b/tests/oem/ibm/libpldm_fileio_test.cpp
index 1c92e58..1e57f2d 100644
--- a/tests/oem/ibm/libpldm_fileio_test.cpp
+++ b/tests/oem/ibm/libpldm_fileio_test.cpp
@@ -19,7 +19,7 @@
     uint32_t fileHandle = 0x12345678;
     uint32_t offset = 0x87654321;
     uint32_t length = 0x13245768;
-    uint64_t address = 0x124356879ACBDE0F;
+    uint64_t address = 0x124356879acbde0f;
     uint32_t fileHandleLe = htole32(fileHandle);
     uint32_t offsetLe = htole32(offset);
     uint32_t lengthLe = htole32(length);
@@ -85,7 +85,7 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES>
         responseMsg{};
-    uint32_t length = 0xFF00EE11;
+    uint32_t length = 0xff00ee11;
     uint32_t lengthLe = htole32(length);
     pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
@@ -150,7 +150,7 @@
 {
     std::array<uint8_t, PLDM_RW_FILE_MEM_RESP_BYTES + hdrSize> responseMsg{};
     // Random value for length
-    uint32_t length = 0xFF00EE12;
+    uint32_t length = 0xff00ee12;
     uint32_t lengthLe = htole32(length);
     uint8_t completionCode = 0;
 
@@ -198,7 +198,7 @@
     uint32_t fileHandle = 0x12345678;
     uint32_t offset = 0x87654321;
     uint32_t length = 0x13245768;
-    uint64_t address = 0x124356879ACBDE0F;
+    uint64_t address = 0x124356879acbde0f;
     uint32_t fileHandleLe = htole32(fileHandle);
     uint32_t offsetLe = htole32(offset);
     uint32_t lengthLe = htole32(length);
@@ -834,7 +834,7 @@
     uint32_t fileHandle = 0x12345678;
     uint32_t offset = 0x87654321;
     uint32_t length = 0x13245768;
-    uint64_t address = 0x124356879ACBD456;
+    uint64_t address = 0x124356879acbd456;
 
     request->file_type = htole16(fileType);
     request->file_handle = htole32(fileHandle);
@@ -959,7 +959,7 @@
     uint32_t fileHandle = 0x12345678;
     uint32_t offset = 0x87654321;
     uint32_t length = 0x13245768;
-    uint64_t address = 0x124356879ACBDE0F;
+    uint64_t address = 0x124356879acbde0f;
     uint16_t fileTypeLe = htole16(fileType);
     uint32_t fileHandleLe = htole32(fileHandle);
     uint32_t offsetLe = htole32(offset);
@@ -1074,7 +1074,7 @@
     auto request = reinterpret_cast<pldm_new_file_req*>(requestPtr->payload);
 
     // Random value for fileHandle and length
-    uint16_t fileType = 0xFF;
+    uint16_t fileType = 0xff;
     uint32_t fileHandle = 0x12345678;
     uint64_t length = 0x13245768;
 
@@ -1082,7 +1082,7 @@
     request->file_handle = htole32(fileHandle);
     request->length = htole64(length);
 
-    uint16_t retFileType = 0xFF;
+    uint16_t retFileType = 0xff;
     uint32_t retFileHandle = 0;
     uint64_t retLength = 0;
 
@@ -1164,7 +1164,7 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_NEW_FILE_REQ_BYTES>
         requestMsg{};
 
-    uint16_t fileType = 0xFF;
+    uint16_t fileType = 0xff;
     uint32_t fileHandle = 0x12345678;
     uint32_t length = 0x13245768;
     uint16_t fileTypeLe = htole16(fileType);
@@ -1232,7 +1232,7 @@
 
 TEST(NewFile, testBadEncodeRequest)
 {
-    uint8_t fileType = 0xFF;
+    uint8_t fileType = 0xff;
     uint32_t fileHandle = 0;
     uint32_t length = 0;
 
@@ -1466,15 +1466,15 @@
     auto request = reinterpret_cast<pldm_file_ack_req*>(requestPtr->payload);
 
     // Random value for fileHandle
-    uint16_t fileType = 0xFFFF;
+    uint16_t fileType = 0xffff;
     uint32_t fileHandle = 0x12345678;
-    uint8_t fileStatus = 0xFF;
+    uint8_t fileStatus = 0xff;
 
     request->file_type = htole16(fileType);
     request->file_handle = htole32(fileHandle);
     request->file_status = fileStatus;
 
-    uint16_t retFileType = 0xFF;
+    uint16_t retFileType = 0xff;
     uint32_t retFileHandle = 0;
     uint8_t retFileStatus = 0;
 
@@ -1557,9 +1557,9 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_REQ_BYTES>
         requestMsg{};
 
-    uint16_t fileType = 0xFFFF;
+    uint16_t fileType = 0xffff;
     uint32_t fileHandle = 0x12345678;
-    uint8_t fileStatus = 0xFF;
+    uint8_t fileStatus = 0xff;
     uint16_t fileTypeLe = htole16(fileType);
     uint32_t fileHandleLe = htole32(fileHandle);
 
@@ -1621,7 +1621,7 @@
 
 TEST(FileAck, testBadEncodeRequest)
 {
-    uint8_t fileType = 0xFF;
+    uint8_t fileType = 0xff;
     uint32_t fileHandle = 0;
     uint8_t fileStatus = 0;
 
@@ -1726,13 +1726,13 @@
                sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_WITH_META_DATA_REQ_BYTES>
         requestMsg{};
 
-    uint16_t fileType = 0xFFFF;
+    uint16_t fileType = 0xffff;
     uint32_t fileHandle = 0x12345678;
-    uint8_t fileStatus = 0xFF;
-    uint32_t fileMetaData1 = 0xFFFFFFFF;
-    uint32_t fileMetaData2 = 0xFFFFFFFF;
-    uint32_t fileMetaData3 = 0xFFFFFFFF;
-    uint32_t fileMetaData4 = 0xFFFFFFFF;
+    uint8_t fileStatus = 0xff;
+    uint32_t fileMetaData1 = 0xffffffff;
+    uint32_t fileMetaData2 = 0xffffffff;
+    uint32_t fileMetaData3 = 0xffffffff;
+    uint32_t fileMetaData4 = 0xffffffff;
 
     uint16_t fileTypeLe = htole16(fileType);
     uint32_t fileHandleLe = htole32(fileHandle);
@@ -1780,7 +1780,7 @@
 
 TEST(FileAckWithMetadata, testBadEncodeRequest)
 {
-    uint8_t fileType = 0xFF;
+    uint8_t fileType = 0xff;
     uint32_t fileHandle = 0;
     uint8_t fileStatus = 0;
     uint32_t fileMetaData1 = 0;
@@ -1807,9 +1807,9 @@
     auto request = reinterpret_cast<pldm_file_ack_with_meta_data_req*>(
         requestPtr->payload);
 
-    uint16_t fileType = 0xFFFF;
+    uint16_t fileType = 0xffff;
     uint32_t fileHandle = 0x12345678;
-    uint8_t fileStatus = 0xFF;
+    uint8_t fileStatus = 0xff;
     uint32_t fileMetaData1 = 0x12345678;
     uint32_t fileMetaData2 = 0x87654321;
     uint32_t fileMetaData3 = 0x22121117;
@@ -1823,7 +1823,7 @@
     request->file_meta_data_3 = htole32(fileMetaData3);
     request->file_meta_data_4 = htole32(fileMetaData4);
 
-    uint16_t retFileType = 0xFFFF;
+    uint16_t retFileType = 0xffff;
     uint32_t retFileHandle = 0;
     uint8_t retFileStatus = 0;
     uint32_t retFileMetaData1 = 0;
@@ -1970,13 +1970,13 @@
                             PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_REQ_BYTES>
         requestMsg{};
 
-    uint16_t fileType = 0xFFFF;
+    uint16_t fileType = 0xffff;
     uint32_t fileHandle = 0x12345678;
     uint32_t length = 0x13245768;
-    uint64_t fileMetaData1 = 0xFFFFFFFF;
-    uint32_t fileMetaData2 = 0xFFFFFFFF;
-    uint32_t fileMetaData3 = 0xFFFFFFFF;
-    uint32_t fileMetaData4 = 0xFFFFFFFF;
+    uint64_t fileMetaData1 = 0xffffffff;
+    uint32_t fileMetaData2 = 0xffffffff;
+    uint32_t fileMetaData3 = 0xffffffff;
+    uint32_t fileMetaData4 = 0xffffffff;
 
     uint16_t fileTypeLe = htole16(fileType);
     uint32_t fileHandleLe = htole32(fileHandle);
@@ -2027,7 +2027,7 @@
 
 TEST(NewFileAvailableWithMetaData, testBadEncodeRequest)
 {
-    uint8_t fileType = 0xFF;
+    uint8_t fileType = 0xff;
     uint32_t fileHandle = 0;
     uint32_t length = 0;
     uint32_t fileMetaData1 = 0;
@@ -2055,7 +2055,7 @@
         reinterpret_cast<pldm_new_file_with_metadata_req*>(requestPtr->payload);
 
     // Random value for fileHandle and length
-    uint16_t fileType = 0xFFFF;
+    uint16_t fileType = 0xffff;
     uint32_t fileHandle = 0x12345678;
     uint64_t length = 0x13245768;
     uint32_t fileMetaData1 = 0x12345678;
@@ -2071,7 +2071,7 @@
     request->file_meta_data_3 = htole32(fileMetaData3);
     request->file_meta_data_4 = htole32(fileMetaData4);
 
-    uint16_t retFileType = 0xFFFF;
+    uint16_t retFileType = 0xffff;
     uint32_t retFileHandle = 0;
     uint64_t retLength = 0;
     uint32_t retFileMetaData1 = 0;
diff --git a/tests/oem/ibm/libpldm_host_test.cpp b/tests/oem/ibm/libpldm_host_test.cpp
index 973f1c3..86c9577 100644
--- a/tests/oem/ibm/libpldm_host_test.cpp
+++ b/tests/oem/ibm/libpldm_host_test.cpp
@@ -37,7 +37,7 @@
 TEST(GetAlertStatus, testGoodDecodeResponse)
 {
     uint8_t completionCode = PLDM_SUCCESS;
-    uint32_t rack_entry = 0xFF000030;
+    uint32_t rack_entry = 0xff000030;
     uint32_t pri_cec_node = 0x00008030;
     std::array<uint8_t, hdrSize + PLDM_GET_ALERT_STATUS_RESP_BYTES>
         responseMsg{};
@@ -68,7 +68,7 @@
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     uint8_t completionCode = PLDM_SUCCESS;
-    uint32_t rack_entry = 0xFF000030;
+    uint32_t rack_entry = 0xff000030;
     uint32_t pri_cec_node = 0x00008030;
     std::array<uint8_t, hdrSize + PLDM_GET_ALERT_STATUS_RESP_BYTES>
         responseMsg{};
@@ -93,7 +93,7 @@
 TEST(GetAlertStatus, testGoodEncodeResponse)
 {
     uint8_t completionCode = 0;
-    uint32_t rack_entry = 0xFF000030;
+    uint32_t rack_entry = 0xff000030;
     uint32_t pri_cec_node = 0x00008030;
 
     std::vector<uint8_t> responseMsg(hdrSize +
@@ -115,7 +115,7 @@
 
 TEST(GetAlertStatus, testBadEncodeResponse)
 {
-    uint32_t rack_entry = 0xFF000030;
+    uint32_t rack_entry = 0xff000030;
     uint32_t pri_cec_node = 0x00008030;
 
     std::vector<uint8_t> responseMsg(hdrSize +
diff --git a/tests/oem/meta/libpldm_fileio_test.cpp b/tests/oem/meta/libpldm_fileio_test.cpp
index 663ed65..de4ba81 100644
--- a/tests/oem/meta/libpldm_fileio_test.cpp
+++ b/tests/oem/meta/libpldm_fileio_test.cpp
@@ -16,7 +16,7 @@
     struct pldm_msgbuf* ctx = &_ctx;
     uint8_t fileHandle = 0x00;
     int32_t dataLengthLE = 0x04;
-    uint8_t postCode[4] = {0x93, 0xE0, 0x00, 0xEA};
+    uint8_t postCode[4] = {0x93, 0xe0, 0x00, 0xea};
 
     constexpr auto hdrSize = sizeof(pldm_msg_hdr);