diff --git a/test/libpldm_base_test.cpp b/test/libpldm_base_test.cpp
index f906f77..faa4d90 100644
--- a/test/libpldm_base_test.cpp
+++ b/test/libpldm_base_test.cpp
@@ -191,15 +191,14 @@
 {
     uint8_t pldmType = 0x05;
     ver32_t version{0xFF, 0xFF, 0xFF, 0xFF};
-    std::array<uint8_t, PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
-    pldm_msg request{};
-    request.body.payload = requestMsg.data();
-    request.body.payload_length = requestMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
+        requestMsg{};
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
-    auto rc = encode_get_commands_req(0, pldmType, version, &request);
+    auto rc = encode_get_commands_req(0, pldmType, version, request);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(0, memcmp(request.body.payload, &pldmType, sizeof(pldmType)));
-    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(pldmType), &version,
+    ASSERT_EQ(0, memcmp(request->payload, &pldmType, sizeof(pldmType)));
+    ASSERT_EQ(0, memcmp(request->payload + sizeof(pldmType), &version,
                         sizeof(version)));
 }
 
@@ -210,13 +209,11 @@
     uint8_t pldmTypeOut{};
     ver32_t versionOut{0xFF, 0xFF, 0xFF, 0xFF};
     std::array<uint8_t, PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
 
-    memcpy(request.payload, &pldmType, sizeof(pldmType));
-    memcpy(request.payload + sizeof(pldmType), &version, sizeof(version));
-    auto rc = decode_get_commands_req(&request, &pldmTypeOut, &versionOut);
+    memcpy(requestMsg.data(), &pldmType, sizeof(pldmType));
+    memcpy(requestMsg.data() + sizeof(pldmType), &version, sizeof(version));
+    auto rc = decode_get_commands_req(requestMsg.data(), requestMsg.size(),
+                                      &pldmTypeOut, &versionOut);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(pldmTypeOut, pldmType);
     ASSERT_EQ(0, memcmp(&versionOut, &version, sizeof(version)));
@@ -225,108 +222,104 @@
 TEST(GetPLDMCommands, testEncodeResponse)
 {
     uint8_t completionCode = 0;
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    pldm_msg response{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_RESP_BYTES>
+        responseMsg{};
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> commands{};
     commands[0].byte = 1;
     commands[1].byte = 2;
     commands[2].byte = 3;
 
     auto rc =
-        encode_get_commands_resp(0, PLDM_SUCCESS, commands.data(), &response);
+        encode_get_commands_resp(0, PLDM_SUCCESS, commands.data(), response);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
-    ASSERT_EQ(1, response.body.payload[1]);
-    ASSERT_EQ(2, response.body.payload[2]);
-    ASSERT_EQ(3, response.body.payload[3]);
+    uint8_t* payload_ptr = response->payload;
+    ASSERT_EQ(completionCode, payload_ptr[0]);
+    ASSERT_EQ(1, payload_ptr[sizeof(completionCode)]);
+    ASSERT_EQ(2,
+              payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte)]);
+    ASSERT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte) +
+                             sizeof(commands[1].byte)]);
 }
 
 TEST(GetPLDMTypes, testEncodeResponse)
 {
     uint8_t completionCode = 0;
-    std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    pldm_msg response{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_TYPES_RESP_BYTES>
+        responseMsg{};
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     std::array<bitfield8_t, PLDM_MAX_TYPES / 8> types{};
     types[0].byte = 1;
     types[1].byte = 2;
     types[2].byte = 3;
 
-    auto rc = encode_get_types_resp(0, PLDM_SUCCESS, types.data(), &response);
+    auto rc = encode_get_types_resp(0, PLDM_SUCCESS, types.data(), response);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
-    ASSERT_EQ(1, response.body.payload[1]);
-    ASSERT_EQ(2, response.body.payload[2]);
-    ASSERT_EQ(3, response.body.payload[3]);
+    uint8_t* payload_ptr = response->payload;
+    ASSERT_EQ(completionCode, payload_ptr[0]);
+    ASSERT_EQ(1, payload_ptr[sizeof(completionCode)]);
+    ASSERT_EQ(2, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte)]);
+    ASSERT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte) +
+                             sizeof(types[1].byte)]);
 }
 
 TEST(GetPLDMTypes, testDecodeResponse)
 {
     std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-    response.payload[1] = 1;
-    response.payload[2] = 2;
-    response.payload[3] = 3;
+    responseMsg[1] = 1;
+    responseMsg[2] = 2;
+    responseMsg[3] = 3;
     std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc =
-        decode_get_types_resp(&response, &completion_code, outTypes.data());
+    auto rc = decode_get_types_resp(responseMsg.data(), responseMsg.size(),
+                                    &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(response.payload[1], outTypes[0].byte);
-    ASSERT_EQ(response.payload[2], outTypes[1].byte);
-    ASSERT_EQ(response.payload[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
 }
 
 TEST(GetPLDMCommands, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_MAX_CMDS_PER_TYPE> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-    response.payload[1] = 1;
-    response.payload[2] = 2;
-    response.payload[3] = 3;
+    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
+    responseMsg[1] = 1;
+    responseMsg[2] = 2;
+    responseMsg[3] = 3;
     std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc =
-        decode_get_commands_resp(&response, &completion_code, outTypes.data());
+    auto rc = decode_get_commands_resp(responseMsg.data(), responseMsg.size(),
+                                       &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(response.payload[1], outTypes[0].byte);
-    ASSERT_EQ(response.payload[2], outTypes[1].byte);
-    ASSERT_EQ(response.payload[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
 }
 
 TEST(GetPLDMVersion, testGoodEncodeRequest)
 {
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
-    pldm_msg request{};
-    request.body.payload = requestMsg.data();
-    request.body.payload_length = requestMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
+        requestMsg{};
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
     uint8_t pldmType = 0x03;
     uint32_t transferHandle = 0x0;
     uint8_t opFlag = 0x01;
 
     auto rc =
-        encode_get_version_req(0, transferHandle, opFlag, pldmType, &request);
+        encode_get_version_req(0, transferHandle, opFlag, pldmType, request);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(0, memcmp(request.body.payload, &transferHandle,
-                        sizeof(transferHandle)));
-    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(transferHandle), &opFlag,
+    ASSERT_EQ(
+        0, memcmp(request->payload, &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0, memcmp(request->payload + sizeof(transferHandle), &opFlag,
                         sizeof(opFlag)));
-    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(transferHandle) +
-                            sizeof(opFlag),
-                        &pldmType, sizeof(pldmType)));
+    ASSERT_EQ(0,
+              memcmp(request->payload + sizeof(transferHandle) + sizeof(opFlag),
+                     &pldmType, sizeof(pldmType)));
 }
 
 TEST(GetPLDMVersion, testBadEncodeRequest)
@@ -343,39 +336,32 @@
 
 TEST(GetPLDMVersion, testEncodeResponse)
 {
-    pldm_msg response{};
     uint8_t completionCode = 0;
     uint32_t transferHandle = 0;
     uint8_t flag = PLDM_START_AND_END;
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    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};
 
     auto rc = encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END,
-                                      &version, sizeof(ver32_t), &response);
+                                      &version, sizeof(ver32_t), response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]),
-                     &transferHandle, sizeof(transferHandle)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle),
-                     &flag, sizeof(flag)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle) + sizeof(flag),
-                     &version, sizeof(version)));
+    ASSERT_EQ(completionCode, response->payload[0]);
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+                        &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(transferHandle),
+                        &flag, sizeof(flag)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(transferHandle) + sizeof(flag),
+                        &version, sizeof(version)));
 }
 
 TEST(GetPLDMVersion, testDecodeRequest)
 {
     std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_GET_FIRSTPART;
@@ -383,13 +369,13 @@
     uint8_t pldmType = PLDM_BASE;
     uint8_t retType = PLDM_BASE;
 
-    memcpy(request.payload, &transferHandle, sizeof(transferHandle));
-    memcpy(request.payload + sizeof(transferHandle), &flag, sizeof(flag));
-    memcpy(request.payload + sizeof(transferHandle) + sizeof(flag), &pldmType,
+    memcpy(requestMsg.data(), &transferHandle, sizeof(transferHandle));
+    memcpy(requestMsg.data() + sizeof(transferHandle), &flag, sizeof(flag));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(flag), &pldmType,
            sizeof(pldmType));
 
-    auto rc = decode_get_version_req(&request, &retTransferHandle, &retFlag,
-                                     &retType);
+    auto rc = decode_get_version_req(requestMsg.data(), requestMsg.size(),
+                                     &retTransferHandle, &retFlag, &retType);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(transferHandle, retTransferHandle);
@@ -400,9 +386,6 @@
 TEST(GetPLDMVersion, testDecodeResponse)
 {
     std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_START_AND_END;
@@ -412,16 +395,17 @@
     ver32_t versionOut;
     uint8_t completion_code;
 
-    memcpy(response.payload + sizeof(completionCode), &transferHandle,
+    memcpy(responseMsg.data() + sizeof(completionCode), &transferHandle,
            sizeof(transferHandle));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(transferHandle),
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(transferHandle),
            &flag, sizeof(flag));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(transferHandle) +
-               sizeof(flag),
+    memcpy(responseMsg.data() + sizeof(completionCode) +
+               sizeof(transferHandle) + sizeof(flag),
            &version, sizeof(version));
 
-    auto rc = decode_get_version_resp(
-        &response, &completion_code, &retTransferHandle, &retFlag, &versionOut);
+    auto rc = decode_get_version_resp(responseMsg.data(), responseMsg.size(),
+                                      &completion_code, &retTransferHandle,
+                                      &retFlag, &versionOut);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(transferHandle, retTransferHandle);
     ASSERT_EQ(flag, retFlag);
diff --git a/test/libpldm_bios_test.cpp b/test/libpldm_bios_test.cpp
index b1771c9..3fde16a 100644
--- a/test/libpldm_bios_test.cpp
+++ b/test/libpldm_bios_test.cpp
@@ -10,8 +10,6 @@
 TEST(GetDateTime, testEncodeRequest)
 {
     pldm_msg request{};
-    request.body.payload = nullptr;
-    request.body.payload_length = 0;
 
     auto rc = encode_get_date_time_req(0, &request);
     ASSERT_EQ(rc, PLDM_SUCCESS);
@@ -27,49 +25,41 @@
     uint8_t month = 11;
     uint16_t year = 2019;
 
-    std::array<uint8_t, PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
-    pldm_msg response{};
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_DATE_TIME_RESP_BYTES>
+        responseMsg{};
 
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
     auto rc = encode_get_date_time_resp(0, PLDM_SUCCESS, seconds, minutes,
-                                        hours, day, month, year, &response);
+                                        hours, day, month, year, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
+    ASSERT_EQ(completionCode, response->payload[0]);
 
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]),
-                     &seconds, sizeof(seconds)));
-    ASSERT_EQ(0, memcmp(response.body.payload +
-                            sizeof(response.body.payload[0]) + sizeof(seconds),
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+                        &seconds, sizeof(seconds)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds),
                         &minutes, sizeof(minutes)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(seconds) + sizeof(minutes),
-                     &hours, sizeof(hours)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(seconds) + sizeof(minutes) + sizeof(hours),
-                     &day, sizeof(day)));
-    ASSERT_EQ(0, memcmp(response.body.payload +
-                            sizeof(response.body.payload[0]) + sizeof(seconds) +
-                            sizeof(minutes) + sizeof(hours) + sizeof(day),
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes),
+                        &hours, sizeof(hours)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes) + sizeof(hours),
+                        &day, sizeof(day)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
+                            sizeof(day),
                         &month, sizeof(month)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
-                         sizeof(day) + sizeof(month),
-                     &year, sizeof(year)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
+                            sizeof(day) + sizeof(month),
+                        &year, sizeof(year)));
 }
 
 TEST(GetDateTime, testDecodeResponse)
 {
     std::array<uint8_t, PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
 
     uint8_t completionCode = 0;
 
@@ -87,26 +77,26 @@
     uint8_t retMonth = 0;
     uint16_t retYear = 0;
 
-    memcpy(response.payload + sizeof(completionCode), &seconds,
+    memcpy(responseMsg.data() + sizeof(completionCode), &seconds,
            sizeof(seconds));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds),
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds),
            &minutes, sizeof(minutes));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes),
            &hours, sizeof(hours));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes) + sizeof(hours),
            &day, sizeof(day));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes) + sizeof(hours) + sizeof(day),
            &month, sizeof(month));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes) + sizeof(hours) + sizeof(day) + sizeof(month),
            &year, sizeof(year));
 
-    auto rc = decode_get_date_time_resp(&response, &completionCode, &retSeconds,
-                                        &retMinutes, &retHours, &retDay,
-                                        &retMonth, &retYear);
+    auto rc = decode_get_date_time_resp(
+        responseMsg.data(), responseMsg.size(), &completionCode, &retSeconds,
+        &retMinutes, &retHours, &retDay, &retMonth, &retYear);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(seconds, retSeconds);
diff --git a/test/libpldm_platform_test.cpp b/test/libpldm_platform_test.cpp
index 1e14b25..b046e3f 100644
--- a/test/libpldm_platform_test.cpp
+++ b/test/libpldm_platform_test.cpp
@@ -9,57 +9,49 @@
 
 TEST(SetStateEffecterStates, testEncodeResponse)
 {
-    pldm_msg response{};
+    std::array<uint8_t,
+               sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
+        responseMsg{};
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     uint8_t completionCode = 0;
 
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
-        responseMsg{};
-
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-
-    auto rc = encode_set_state_effecter_states_resp(0, PLDM_SUCCESS, &response);
+    auto rc = encode_set_state_effecter_states_resp(0, PLDM_SUCCESS, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
+    ASSERT_EQ(completionCode, response->payload[0]);
 }
 
 TEST(SetStateEffecterStates, testEncodeRequest)
 {
-    pldm_msg request{};
+    std::array<uint8_t,
+               sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
+        requestMsg{};
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     uint16_t effecterId = 0x0A;
     uint8_t compEffecterCnt = 0x2;
     std::array<set_effecter_state_field, 8> stateField{};
     stateField[0] = {PLDM_REQUEST_SET, 2};
     stateField[1] = {PLDM_REQUEST_SET, 3};
 
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
-
-    request.body.payload = requestMsg.data();
-    request.body.payload_length = requestMsg.size();
-
     auto rc = encode_set_state_effecter_states_req(
-        0, effecterId, compEffecterCnt, stateField.data(), &request);
+        0, effecterId, compEffecterCnt, stateField.data(), request);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(effecterId, request.body.payload[0]);
-    ASSERT_EQ(compEffecterCnt, request.body.payload[sizeof(effecterId)]);
-    ASSERT_EQ(
-        stateField[0].set_request,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt)]);
-    ASSERT_EQ(
-        stateField[0].effecter_state,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
-                             sizeof(stateField[0].set_request)]);
-    ASSERT_EQ(
-        stateField[1].set_request,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
-                             sizeof(stateField[0])]);
-    ASSERT_EQ(
-        stateField[1].effecter_state,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
-                             sizeof(stateField[0]) +
-                             sizeof(stateField[1].set_request)]);
+    ASSERT_EQ(effecterId, request->payload[0]);
+    ASSERT_EQ(compEffecterCnt, request->payload[sizeof(effecterId)]);
+    ASSERT_EQ(stateField[0].set_request,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt)]);
+    ASSERT_EQ(stateField[0].effecter_state,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
+                               sizeof(stateField[0].set_request)]);
+    ASSERT_EQ(stateField[1].set_request,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
+                               sizeof(stateField[0])]);
+    ASSERT_EQ(stateField[1].effecter_state,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
+                               sizeof(stateField[0]) +
+                               sizeof(stateField[1].set_request)]);
 }
 
 TEST(SetStateEffecterStates, testGoodDecodeResponse)
@@ -67,18 +59,14 @@
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-
     uint8_t completion_code = 0xA0;
 
     uint8_t retcompletion_code = 0;
 
-    memcpy(response.payload, &completion_code, sizeof(completion_code));
+    memcpy(responseMsg.data(), &completion_code, sizeof(completion_code));
 
-    auto rc =
-        decode_set_state_effecter_states_resp(&response, &retcompletion_code);
+    auto rc = decode_set_state_effecter_states_resp(
+        responseMsg.data(), responseMsg.size(), &retcompletion_code);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, retcompletion_code);
@@ -88,10 +76,6 @@
 {
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
 
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
-
     uint16_t effecterId = 0x32;
     uint8_t compEffecterCnt = 0x2;
 
@@ -104,14 +88,15 @@
 
     std::array<set_effecter_state_field, 8> retStateField{};
 
-    memcpy(request.payload, &effecterId, sizeof(effecterId));
-    memcpy(request.payload + sizeof(effecterId), &compEffecterCnt,
+    memcpy(requestMsg.data(), &effecterId, sizeof(effecterId));
+    memcpy(requestMsg.data() + sizeof(effecterId), &compEffecterCnt,
            sizeof(compEffecterCnt));
-    memcpy(request.payload + sizeof(effecterId) + sizeof(compEffecterCnt),
+    memcpy(requestMsg.data() + sizeof(effecterId) + sizeof(compEffecterCnt),
            &stateField, sizeof(stateField));
 
     auto rc = decode_set_state_effecter_states_req(
-        &request, &retEffecterId, &retCompEffecterCnt, retStateField.data());
+        requestMsg.data(), requestMsg.size(), &retEffecterId,
+        &retCompEffecterCnt, retStateField.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(effecterId, retEffecterId);
@@ -124,13 +109,10 @@
 
 TEST(SetStateEffecterStates, testBadDecodeRequest)
 {
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
+    const uint8_t* msg = NULL;
 
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
-
-    auto rc = decode_set_state_effecter_states_req(&request, NULL, NULL, NULL);
+    auto rc = decode_set_state_effecter_states_req(msg, sizeof(*msg), NULL,
+                                                   NULL, NULL);
 
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 }
@@ -140,11 +122,8 @@
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-
-    auto rc = decode_set_state_effecter_states_resp(&response, NULL);
+    auto rc = decode_set_state_effecter_states_resp(responseMsg.data(),
+                                                    responseMsg.size(), NULL);
 
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 }
diff --git a/test/libpldmresponder_base_test.cpp b/test/libpldmresponder_base_test.cpp
index cdd22e6..8990d22 100644
--- a/test/libpldmresponder_base_test.cpp
+++ b/test/libpldmresponder_base_test.cpp
@@ -12,62 +12,54 @@
 
 TEST(GetPLDMTypes, testGoodRequest)
 {
-    pldm_msg_payload request{};
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    getPLDMTypes(&request, &response);
+    std::array<uint8_t, sizeof(pldm_msg_hdr)> requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    // payload length will be 0 in this case
+    size_t requestPayloadLength = 0;
+    auto response = getPLDMTypes(request, requestPayloadLength);
     // Only base type supported at the moment
-    ASSERT_EQ(response.body.payload[0], 0);
-    ASSERT_EQ(response.body.payload[1], 1);
-    ASSERT_EQ(response.body.payload[2], 0);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    uint8_t* payload_ptr = responsePtr->payload;
+    ASSERT_EQ(payload_ptr[0], 0);
+    ASSERT_EQ(payload_ptr[1], 1);
+    ASSERT_EQ(payload_ptr[2], 0);
 }
 
 TEST(GetPLDMCommands, testGoodRequest)
 {
     // Only base type supported at the moment, and commands -
     // GetPLDMTypes, GetPLDMCommands
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg_payload request{};
-    std::array<uint8_t, 5> requestPayload{};
-    request.payload = requestPayload.data();
-    request.payload_length = requestPayload.size();
-    getPLDMCommands(&request, &response);
-    ASSERT_EQ(response.body.payload[0], 0);
-    ASSERT_EQ(response.body.payload[1], 48); // 48 = 0b110000
-    ASSERT_EQ(response.body.payload[2], 0);
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
+    auto response = getPLDMCommands(request, requestPayloadLength);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    uint8_t* payload_ptr = responsePtr->payload;
+    ASSERT_EQ(payload_ptr[0], 0);
+    ASSERT_EQ(payload_ptr[1], 48); // 48 = 0b110000
+    ASSERT_EQ(payload_ptr[2], 0);
 }
 
 TEST(GetPLDMCommands, testBadRequest)
 {
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg_payload request{};
-    std::array<uint8_t, 5> requestPayload{};
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
 
-    request.payload = requestPayload.data();
-    request.payload[0] = 0xFF;
-    request.payload_length = requestPayload.size();
-    getPLDMCommands(&request, &response);
-    ASSERT_EQ(response.body.payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
+    request->payload[0] = 0xFF;
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
+    auto response = getPLDMCommands(request, requestPayloadLength);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    uint8_t* payload_ptr = responsePtr->payload;
+    ASSERT_EQ(payload_ptr[0], PLDM_ERROR_INVALID_PLDM_TYPE);
 }
-
 TEST(GetPLDMVersion, testGoodRequest)
 {
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg request{};
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestPayload{};
-    request.body.payload = requestPayload.data();
-    request.body.payload_length = requestPayload.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     uint8_t pldmType = PLDM_BASE;
     uint32_t transferHandle = 0x0;
@@ -76,61 +68,53 @@
     ver32_t version = {0xF1, 0xF0, 0xF0, 0x00};
 
     auto rc =
-        encode_get_version_req(0, transferHandle, flag, pldmType, &request);
+        encode_get_version_req(0, transferHandle, flag, pldmType, request);
 
     ASSERT_EQ(0, rc);
 
-    getPLDMVersion(&(request.body), &response);
+    auto response = getPLDMVersion(request, requestPayloadLength);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(response.body.payload[0], 0);
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]),
-                     &transferHandle, sizeof(transferHandle)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle),
-                     &retFlag, sizeof(flag)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle) + sizeof(flag),
-                     &version, sizeof(version)));
+    ASSERT_EQ(responsePtr->payload[0], 0);
+    ASSERT_EQ(0, memcmp(responsePtr->payload + sizeof(responsePtr->payload[0]),
+                        &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0, memcmp(responsePtr->payload + sizeof(responsePtr->payload[0]) +
+                            sizeof(transferHandle),
+                        &retFlag, sizeof(flag)));
+    ASSERT_EQ(0, memcmp(responsePtr->payload + sizeof(responsePtr->payload[0]) +
+                            sizeof(transferHandle) + sizeof(flag),
+                        &version, sizeof(version)));
 }
-
 TEST(GetPLDMVersion, testBadRequest)
 {
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg request{};
-
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestPayload{};
-
-    std::array<uint8_t, (PLDM_GET_VERSION_REQ_BYTES - 3)> requestPayloadSmall{};
-    request.body.payload = requestPayloadSmall.data();
-    request.body.payload_length = requestPayloadSmall.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     uint8_t pldmType = 7;
     uint32_t transferHandle = 0x0;
     uint8_t flag = PLDM_GET_FIRSTPART;
 
     auto rc =
-        encode_get_version_req(0, transferHandle, flag, pldmType, &request);
+        encode_get_version_req(0, transferHandle, flag, pldmType, request);
 
     ASSERT_EQ(0, rc);
 
-    getPLDMVersion(&(request.body), &response);
+    auto response = getPLDMVersion(request, requestPayloadLength - 1);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(response.body.payload[0], PLDM_ERROR_INVALID_LENGTH);
+    ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
 
-    request.body.payload = requestPayload.data();
-    request.body.payload_length = requestPayload.size();
+    request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    rc = encode_get_version_req(0, transferHandle, flag, pldmType, &request);
+    rc = encode_get_version_req(0, transferHandle, flag, pldmType, request);
 
     ASSERT_EQ(0, rc);
 
-    getPLDMVersion(&(request.body), &response);
+    response = getPLDMVersion(request, requestPayloadLength);
+    responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(response.body.payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
+    ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
 }