diff --git a/test/libpldm_base_test.cpp b/test/libpldm_base_test.cpp
index faa4d90..f17bccb 100644
--- a/test/libpldm_base_test.cpp
+++ b/test/libpldm_base_test.cpp
@@ -6,6 +6,8 @@
 
 #include <gtest/gtest.h>
 
+constexpr auto hdrSize = sizeof(pldm_msg_hdr);
+
 TEST(PackPLDMMessage, BadPathTest)
 {
     struct pldm_header_info hdr;
@@ -208,12 +210,16 @@
     ver32_t version{0xFF, 0xFF, 0xFF, 0xFF};
     uint8_t pldmTypeOut{};
     ver32_t versionOut{0xFF, 0xFF, 0xFF, 0xFF};
-    std::array<uint8_t, PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
 
-    memcpy(requestMsg.data(), &pldmType, sizeof(pldmType));
-    memcpy(requestMsg.data() + sizeof(pldmType), &version, sizeof(version));
-    auto rc = decode_get_commands_req(requestMsg.data(), requestMsg.size(),
+    memcpy(requestMsg.data() + hdrSize, &pldmType, sizeof(pldmType));
+    memcpy(requestMsg.data() + sizeof(pldmType) + hdrSize, &version,
+           sizeof(version));
+
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+    auto rc = decode_get_commands_req(request, requestMsg.size() - hdrSize,
                                       &pldmTypeOut, &versionOut);
+
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(pldmTypeOut, pldmType);
     ASSERT_EQ(0, memcmp(&versionOut, &version, sizeof(version)));
@@ -265,40 +271,44 @@
 
 TEST(GetPLDMTypes, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    responseMsg[1] = 1;
-    responseMsg[2] = 2;
-    responseMsg[3] = 3;
+    std::array<uint8_t, hdrSize + PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
+    responseMsg[1 + hdrSize] = 1;
+    responseMsg[2 + hdrSize] = 2;
+    responseMsg[3 + hdrSize] = 3;
     std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc = decode_get_types_resp(responseMsg.data(), responseMsg.size(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_get_types_resp(response, responseMsg.size() - hdrSize,
                                     &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
-    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
-    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
 }
 
 TEST(GetPLDMCommands, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    responseMsg[1] = 1;
-    responseMsg[2] = 2;
-    responseMsg[3] = 3;
+    std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
+    responseMsg[1 + hdrSize] = 1;
+    responseMsg[2 + hdrSize] = 2;
+    responseMsg[3 + hdrSize] = 3;
     std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc = decode_get_commands_resp(responseMsg.data(), responseMsg.size(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_get_commands_resp(response, responseMsg.size() - hdrSize,
                                        &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
-    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
-    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
 }
 
 TEST(GetPLDMVersion, testGoodEncodeRequest)
@@ -361,7 +371,7 @@
 
 TEST(GetPLDMVersion, testDecodeRequest)
 {
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, hdrSize + PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_GET_FIRSTPART;
@@ -369,12 +379,16 @@
     uint8_t pldmType = PLDM_BASE;
     uint8_t retType = PLDM_BASE;
 
-    memcpy(requestMsg.data(), &transferHandle, sizeof(transferHandle));
-    memcpy(requestMsg.data() + sizeof(transferHandle), &flag, sizeof(flag));
-    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(flag), &pldmType,
-           sizeof(pldmType));
+    memcpy(requestMsg.data() + hdrSize, &transferHandle,
+           sizeof(transferHandle));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + hdrSize, &flag,
+           sizeof(flag));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(flag) + hdrSize,
+           &pldmType, sizeof(pldmType));
 
-    auto rc = decode_get_version_req(requestMsg.data(), requestMsg.size(),
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+    auto rc = decode_get_version_req(request, requestMsg.size() - hdrSize,
                                      &retTransferHandle, &retFlag, &retType);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
@@ -385,7 +399,8 @@
 
 TEST(GetPLDMVersion, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES>
+        responseMsg{};
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_START_AND_END;
@@ -395,15 +410,18 @@
     ver32_t versionOut;
     uint8_t completion_code;
 
-    memcpy(responseMsg.data() + sizeof(completionCode), &transferHandle,
-           sizeof(transferHandle));
-    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(transferHandle),
+    memcpy(responseMsg.data() + sizeof(completionCode) + hdrSize,
+           &transferHandle, sizeof(transferHandle));
+    memcpy(responseMsg.data() + sizeof(completionCode) +
+               sizeof(transferHandle) + hdrSize,
            &flag, sizeof(flag));
     memcpy(responseMsg.data() + sizeof(completionCode) +
-               sizeof(transferHandle) + sizeof(flag),
+               sizeof(transferHandle) + sizeof(flag) + hdrSize,
            &version, sizeof(version));
 
-    auto rc = decode_get_version_resp(responseMsg.data(), responseMsg.size(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_get_version_resp(response, responseMsg.size() - hdrSize,
                                       &completion_code, &retTransferHandle,
                                       &retFlag, &versionOut);
     ASSERT_EQ(rc, PLDM_SUCCESS);
diff --git a/test/libpldm_bios_test.cpp b/test/libpldm_bios_test.cpp
index 3fde16a..495a0d2 100644
--- a/test/libpldm_bios_test.cpp
+++ b/test/libpldm_bios_test.cpp
@@ -7,6 +7,8 @@
 
 #include <gtest/gtest.h>
 
+constexpr auto hdrSize = sizeof(pldm_msg_hdr);
+
 TEST(GetDateTime, testEncodeRequest)
 {
     pldm_msg request{};
@@ -59,7 +61,7 @@
 
 TEST(GetDateTime, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
+    std::array<uint8_t, hdrSize + PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
 
     uint8_t completionCode = 0;
 
@@ -77,25 +79,29 @@
     uint8_t retMonth = 0;
     uint16_t retYear = 0;
 
-    memcpy(responseMsg.data() + sizeof(completionCode), &seconds,
+    memcpy(responseMsg.data() + sizeof(completionCode) + hdrSize, &seconds,
            sizeof(seconds));
-    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds),
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
+               hdrSize,
            &minutes, sizeof(minutes));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes),
+               sizeof(minutes) + hdrSize,
            &hours, sizeof(hours));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes) + sizeof(hours),
+               sizeof(minutes) + sizeof(hours) + hdrSize,
            &day, sizeof(day));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes) + sizeof(hours) + sizeof(day),
+               sizeof(minutes) + sizeof(hours) + sizeof(day) + hdrSize,
            &month, sizeof(month));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes) + sizeof(hours) + sizeof(day) + sizeof(month),
+               sizeof(minutes) + sizeof(hours) + sizeof(day) + sizeof(month) +
+               hdrSize,
            &year, sizeof(year));
 
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
     auto rc = decode_get_date_time_resp(
-        responseMsg.data(), responseMsg.size(), &completionCode, &retSeconds,
+        response, responseMsg.size() - hdrSize, &completionCode, &retSeconds,
         &retMinutes, &retHours, &retDay, &retMonth, &retYear);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
diff --git a/test/libpldm_platform_test.cpp b/test/libpldm_platform_test.cpp
index b046e3f..1010bd8 100644
--- a/test/libpldm_platform_test.cpp
+++ b/test/libpldm_platform_test.cpp
@@ -7,6 +7,8 @@
 
 #include <gtest/gtest.h>
 
+constexpr auto hdrSize = sizeof(pldm_msg_hdr);
+
 TEST(SetStateEffecterStates, testEncodeResponse)
 {
     std::array<uint8_t,
@@ -56,17 +58,20 @@
 
 TEST(SetStateEffecterStates, testGoodDecodeResponse)
 {
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
+    std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
     uint8_t completion_code = 0xA0;
 
     uint8_t retcompletion_code = 0;
 
-    memcpy(responseMsg.data(), &completion_code, sizeof(completion_code));
+    memcpy(responseMsg.data() + hdrSize, &completion_code,
+           sizeof(completion_code));
+
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
     auto rc = decode_set_state_effecter_states_resp(
-        responseMsg.data(), responseMsg.size(), &retcompletion_code);
+        response, responseMsg.size() - hdrSize, &retcompletion_code);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, retcompletion_code);
@@ -74,7 +79,8 @@
 
 TEST(SetStateEffecterStates, testGoodDecodeRequest)
 {
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
+        requestMsg{};
 
     uint16_t effecterId = 0x32;
     uint8_t compEffecterCnt = 0x2;
@@ -88,14 +94,17 @@
 
     std::array<set_effecter_state_field, 8> retStateField{};
 
-    memcpy(requestMsg.data(), &effecterId, sizeof(effecterId));
-    memcpy(requestMsg.data() + sizeof(effecterId), &compEffecterCnt,
+    memcpy(requestMsg.data() + hdrSize, &effecterId, sizeof(effecterId));
+    memcpy(requestMsg.data() + sizeof(effecterId) + hdrSize, &compEffecterCnt,
            sizeof(compEffecterCnt));
-    memcpy(requestMsg.data() + sizeof(effecterId) + sizeof(compEffecterCnt),
+    memcpy(requestMsg.data() + sizeof(effecterId) + sizeof(compEffecterCnt) +
+               hdrSize,
            &stateField, sizeof(stateField));
 
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     auto rc = decode_set_state_effecter_states_req(
-        requestMsg.data(), requestMsg.size(), &retEffecterId,
+        request, requestMsg.size() - hdrSize, &retEffecterId,
         &retCompEffecterCnt, retStateField.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
@@ -109,7 +118,7 @@
 
 TEST(SetStateEffecterStates, testBadDecodeRequest)
 {
-    const uint8_t* msg = NULL;
+    const struct pldm_msg* msg = NULL;
 
     auto rc = decode_set_state_effecter_states_req(msg, sizeof(*msg), NULL,
                                                    NULL, NULL);
@@ -122,7 +131,9 @@
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
-    auto rc = decode_set_state_effecter_states_resp(responseMsg.data(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_set_state_effecter_states_resp(response,
                                                     responseMsg.size(), NULL);
 
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);