diff --git a/libpldm/tests/libpldm_bios_test.cpp b/libpldm/tests/libpldm_bios_test.cpp
index ad07877..7b2ac2a 100644
--- a/libpldm/tests/libpldm_bios_test.cpp
+++ b/libpldm/tests/libpldm_bios_test.cpp
@@ -263,7 +263,7 @@
     uint8_t hours = 0x10;
     uint8_t day = 0x11;
     uint8_t month = 0x11;
-    uint16_t year = 0x2019;
+    uint16_t year = htole16(0x2019);
 
     auto request = reinterpret_cast<struct pldm_msg*>(requestMsg.data());
     struct pldm_set_date_time_req* req =
@@ -302,7 +302,7 @@
     uint8_t hours = 0x10;
     uint8_t day = 0x11;
     uint8_t month = 0x11;
-    uint16_t year = 0x2019;
+    uint16_t year = htole16(0x2019);
 
     std::array<uint8_t, hdrSize + sizeof(struct pldm_set_date_time_req)>
         requestMsg{};
diff --git a/libpldm/tests/libpldm_fru_test.cpp b/libpldm/tests/libpldm_fru_test.cpp
index 7331771..6be4d78 100644
--- a/libpldm/tests/libpldm_fru_test.cpp
+++ b/libpldm/tests/libpldm_fru_test.cpp
@@ -42,20 +42,20 @@
     response->completion_code = PLDM_SUCCESS;
     response->fru_data_major_version = 0x12;
     response->fru_data_minor_version = 0x21;
-    response->fru_table_maximum_size = 0x1234ABCD;
-    response->fru_table_length = 0x56781234;
-    response->total_record_set_identifiers = 0x34EF;
-    response->total_table_records = 0xEEEF;
-    response->checksum = 0x6543FA71;
+    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);
 
     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 = 0x00000000;
-    uint32_t fru_table_length = 0x00000000;
-    uint16_t total_record_set_identifiers = 0x0000;
-    uint16_t total_table_records = 0x0000;
-    uint32_t checksum = 0x00000000;
+    uint32_t fru_table_maximum_size = htole32(0x00000000);
+    uint32_t fru_table_length = htole32(0x00000000);
+    uint16_t total_record_set_identifiers = htole16(0x0000);
+    uint16_t total_table_records = htole16(0x0000);
+    uint32_t checksum = htole32(0x00000000);
 
     auto rc = decode_get_fru_record_table_metadata_resp(
         responsePtr, payload_length, &completion_code, &fru_data_major_version,
@@ -73,18 +73,18 @@
 
     response->fru_data_major_version = 0x00;
     response->fru_data_minor_version = 0x00;
-    response->fru_table_maximum_size = 0x00000000;
-    response->fru_table_length = 0x00000000;
-    response->total_record_set_identifiers = 0x0000;
-    response->total_table_records = 0x0000;
-    response->checksum = 0x00000000;
+    response->fru_table_maximum_size = htole32(0x00000000);
+    response->fru_table_length = htole32(0x00000000);
+    response->total_record_set_identifiers = htole16(0x0000);
+    response->total_table_records = htole16(0x0000);
+    response->checksum = htole32(0x00000000);
     fru_data_major_version = 0x00;
     fru_data_minor_version = 0x00;
-    fru_table_maximum_size = 0x00000000;
-    fru_table_length = 0x00000000;
-    total_record_set_identifiers = 0x0000;
-    total_table_records = 0x0000;
-    checksum = 0x00000000;
+    fru_table_maximum_size = htole32(0x00000000);
+    fru_table_length = htole32(0x00000000);
+    total_record_set_identifiers = htole16(0x0000);
+    total_table_records = htole16(0x0000);
+    checksum = htole32(0x00000000);
     response->completion_code = PLDM_ERROR_INVALID_LENGTH;
     rc = decode_get_fru_record_table_metadata_resp(
         responsePtr, payload_length, &completion_code, &fru_data_major_version,
@@ -117,20 +117,20 @@
     response->completion_code = PLDM_SUCCESS;
     response->fru_data_major_version = 0x12;
     response->fru_data_minor_version = 0x21;
-    response->fru_table_maximum_size = 0x1234ABCD;
-    response->fru_table_length = 0x56781234;
-    response->total_record_set_identifiers = 0x34EF;
-    response->total_table_records = 0xEEEF;
-    response->checksum = 0x6543FA71;
+    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);
 
     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 = 0x00000000;
-    uint32_t fru_table_length = 0x00000000;
-    uint16_t total_record_set_identifiers = 0x0000;
-    uint16_t total_table_records = 0x0000;
-    uint32_t checksum = 0x00000000;
+    uint32_t fru_table_maximum_size = htole32(0x00000000);
+    uint32_t fru_table_length = htole32(0x00000000);
+    uint16_t total_record_set_identifiers = htole16(0x0000);
+    uint16_t total_table_records = htole16(0x0000);
+    uint32_t checksum = htole32(0x00000000);
 
     auto rc = decode_get_fru_record_table_metadata_resp(
         responsePtr, PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES + 2,
@@ -198,11 +198,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 = 0x1234ABCD;
-    uint32_t fru_table_length = 0x56781234;
-    uint16_t total_record_set_identifiers = 0x34EF;
-    uint16_t total_table_records = 0xEEEF;
-    uint32_t checksum = 0x6543FA71;
+    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);
 
     auto rc = encode_get_fru_record_table_metadata_resp(
         0, completion_code, fru_data_major_version, fru_data_minor_version,
@@ -229,11 +229,11 @@
     response->fru_data_major_version = 0;
     response->fru_data_major_version = 0x00;
     response->fru_data_minor_version = 0x00;
-    response->fru_table_maximum_size = 0x00000000;
-    response->fru_table_length = 0x00000000;
-    response->total_record_set_identifiers = 0x0000;
-    response->total_table_records = 0x0000;
-    response->checksum = 0x00000000;
+    response->fru_table_maximum_size = htole32(0x00000000);
+    response->fru_table_length = htole32(0x00000000);
+    response->total_record_set_identifiers = htole16(0x0000);
+    response->total_table_records = htole16(0x0000);
+    response->checksum = htole32(0x00000000);
     completion_code = PLDM_ERROR_INVALID_DATA;
     rc = encode_get_fru_record_table_metadata_resp(
         0, completion_code, fru_data_major_version, fru_data_minor_version,
@@ -265,11 +265,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 = 0x1234ABCD;
-    uint32_t fru_table_length = 0x56781234;
-    uint16_t total_record_set_identifiers = 0x34EF;
-    uint16_t total_table_records = 0xEEEF;
-    uint32_t checksum = 0x6543FA71;
+    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);
 
     auto rc = encode_get_fru_record_table_metadata_resp(
         0, completion_code, fru_data_major_version, fru_data_minor_version,
diff --git a/libpldm/tests/libpldm_pdr_test.cpp b/libpldm/tests/libpldm_pdr_test.cpp
index c1caf20..2969f2e 100644
--- a/libpldm/tests/libpldm_pdr_test.cpp
+++ b/libpldm/tests/libpldm_pdr_test.cpp
@@ -27,7 +27,7 @@
     EXPECT_EQ(handle, 2);
     handle = pldm_pdr_add(repo, data.data(), data.size(), 0);
     EXPECT_EQ(handle, 3);
-    handle = pldm_pdr_add(repo, data.data(), data.size(), 0xdeeddeed);
+    handle = pldm_pdr_add(repo, data.data(), data.size(), htole32(0xdeeddeed));
     EXPECT_EQ(handle, 0xdeeddeed);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size() * 4);
@@ -61,7 +61,8 @@
     EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0);
     outData = nullptr;
 
-    hdl = pldm_pdr_find_record(repo, 0xdeaddead, &outData, &size, &nextRecHdl);
+    hdl = pldm_pdr_find_record(repo, htole32(0xdeaddead), &outData, &size,
+                               &nextRecHdl);
     EXPECT_EQ(hdl, nullptr);
     EXPECT_EQ(size, 0);
     EXPECT_EQ(nextRecHdl, 0);
diff --git a/libpldm/tests/libpldm_platform_test.cpp b/libpldm/tests/libpldm_platform_test.cpp
index 11252d6..fb67790 100644
--- a/libpldm/tests/libpldm_platform_test.cpp
+++ b/libpldm/tests/libpldm_platform_test.cpp
@@ -79,7 +79,7 @@
     std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
         requestMsg{};
 
-    uint16_t effecterId = 0x32;
+    uint16_t effecterId = htole16(0x0032);
     uint8_t compEffecterCnt = 0x2;
 
     std::array<set_effecter_state_field, 8> stateField{};
