diff --git a/common/test/pldm_utils_test.cpp b/common/test/pldm_utils_test.cpp
index 20eedc3..cfa6fec 100644
--- a/common/test/pldm_utils_test.cpp
+++ b/common/test/pldm_utils_test.cpp
@@ -147,10 +147,9 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
 
-    auto state =
-        reinterpret_cast<state_effecter_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -181,10 +180,9 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
 
-    auto state =
-        reinterpret_cast<state_effecter_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -231,10 +229,9 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
 
-    auto state =
-        reinterpret_cast<state_effecter_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -251,11 +248,10 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_effecter_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
 
-    auto state_second = reinterpret_cast<state_effecter_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_effecter_possible_states;
 
     rec_second->hdr.type = 11;
     rec_second->hdr.record_handle = 2;
@@ -292,10 +288,9 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
 
-    auto state =
-        reinterpret_cast<state_effecter_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -312,11 +307,10 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_effecter_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
 
-    auto state_second = reinterpret_cast<state_effecter_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_effecter_possible_states;
 
     rec_second->hdr.type = 11;
     rec_second->hdr.record_handle = 2;
@@ -349,10 +343,9 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
 
-    auto state =
-        reinterpret_cast<state_effecter_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -369,11 +362,10 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_effecter_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
 
-    auto state_second = reinterpret_cast<state_effecter_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_effecter_possible_states;
 
     rec_second->hdr.type = 11;
     rec_second->hdr.record_handle = 2;
@@ -407,10 +399,9 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
 
-    auto state =
-        reinterpret_cast<state_effecter_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -427,11 +418,10 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_effecter_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
 
-    auto state_second = reinterpret_cast<state_effecter_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_effecter_possible_states;
 
     rec_second->hdr.type = 11;
     rec_second->hdr.record_handle = 2;
@@ -450,11 +440,10 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states));
 
-    auto rec_third =
-        reinterpret_cast<pldm_state_effecter_pdr*>(pdr_third.data());
+    auto rec_third = new (pdr_third.data()) pldm_state_effecter_pdr;
 
-    auto state_third = reinterpret_cast<state_effecter_possible_states*>(
-        rec_third->possible_states);
+    auto state_third = new (rec_third->possible_states)
+        state_effecter_possible_states;
 
     rec_third->hdr.type = 11;
     rec_third->hdr.record_handle = 3;
@@ -483,10 +472,10 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states) * 3);
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
     auto state_start = rec->possible_states;
 
-    auto state = reinterpret_cast<state_effecter_possible_states*>(state_start);
+    auto state = new (state_start) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -498,13 +487,13 @@
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_effecter_possible_states*>(state_start);
+    state = new (state_start) state_effecter_possible_states;
     state->state_set_id = 193;
     state->possible_states_size = 1;
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_effecter_possible_states*>(state_start);
+    state = new (state_start) state_effecter_possible_states;
     state->state_set_id = 192;
     state->possible_states_size = 1;
 
@@ -529,10 +518,10 @@
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
         sizeof(struct state_effecter_possible_states) * 3);
 
-    auto rec = reinterpret_cast<pldm_state_effecter_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_effecter_pdr;
     auto state_start = rec->possible_states;
 
-    auto state = reinterpret_cast<state_effecter_possible_states*>(state_start);
+    auto state = new (state_start) state_effecter_possible_states;
 
     rec->hdr.type = 11;
     rec->hdr.record_handle = 1;
@@ -544,13 +533,13 @@
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_effecter_possible_states*>(state_start);
+    state = new (state_start) state_effecter_possible_states;
     state->state_set_id = 193;
     state->possible_states_size = 1;
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_effecter_possible_states*>(state_start);
+    state = new (state_start) state_effecter_possible_states;
     state->state_set_id = 123;
     state->possible_states_size = 1;
 
@@ -575,10 +564,9 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
 
-    auto state =
-        reinterpret_cast<state_sensor_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -609,10 +597,9 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
 
-    auto state =
-        reinterpret_cast<state_sensor_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -659,10 +646,9 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
 
-    auto state =
-        reinterpret_cast<state_sensor_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -679,11 +665,10 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_sensor_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
 
-    auto state_second = reinterpret_cast<state_sensor_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_sensor_possible_states;
 
     rec_second->hdr.type = 4;
     rec_second->hdr.record_handle = 2;
@@ -720,10 +705,9 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
 
-    auto state =
-        reinterpret_cast<state_sensor_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -740,11 +724,10 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_sensor_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
 
-    auto state_second = reinterpret_cast<state_sensor_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_sensor_possible_states;
 
     rec_second->hdr.type = 4;
     rec_second->hdr.record_handle = 2;
@@ -777,10 +760,9 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
 
-    auto state =
-        reinterpret_cast<state_sensor_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -797,11 +779,10 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_sensor_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
 
-    auto state_second = reinterpret_cast<state_sensor_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_sensor_possible_states;
 
     rec_second->hdr.type = 4;
     rec_second->hdr.record_handle = 2;
@@ -835,10 +816,9 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
 
-    auto state =
-        reinterpret_cast<state_sensor_possible_states*>(rec->possible_states);
+    auto state = new (rec->possible_states) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -855,11 +835,10 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec_second =
-        reinterpret_cast<pldm_state_sensor_pdr*>(pdr_second.data());
+    auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
 
-    auto state_second = reinterpret_cast<state_sensor_possible_states*>(
-        rec_second->possible_states);
+    auto state_second = new (rec_second->possible_states)
+        state_sensor_possible_states;
 
     rec_second->hdr.type = 4;
     rec_second->hdr.record_handle = 2;
@@ -878,10 +857,10 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states));
 
-    auto rec_third = reinterpret_cast<pldm_state_sensor_pdr*>(pdr_third.data());
+    auto rec_third = new (pdr_third.data()) pldm_state_sensor_pdr;
 
-    auto state_third = reinterpret_cast<state_sensor_possible_states*>(
-        rec_third->possible_states);
+    auto state_third = new (rec_third->possible_states)
+        state_sensor_possible_states;
 
     rec_third->hdr.type = 4;
     rec_third->hdr.record_handle = 3;
@@ -910,10 +889,10 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states) * 3);
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
     auto state_start = rec->possible_states;
 
-    auto state = reinterpret_cast<state_sensor_possible_states*>(state_start);
+    auto state = new (state_start) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -925,14 +904,14 @@
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_sensor_possible_states*>(state_start);
+    state = new (state_start) state_sensor_possible_states;
 
     state->state_set_id = 7;
     state->possible_states_size = 1;
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_sensor_possible_states*>(state_start);
+    state = new (state_start) state_sensor_possible_states;
 
     state->state_set_id = 1;
     state->possible_states_size = 1;
@@ -958,10 +937,10 @@
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
         sizeof(struct state_sensor_possible_states) * 3);
 
-    auto rec = reinterpret_cast<pldm_state_sensor_pdr*>(pdr.data());
+    auto rec = new (pdr.data()) pldm_state_sensor_pdr;
     auto state_start = rec->possible_states;
 
-    auto state = reinterpret_cast<state_sensor_possible_states*>(state_start);
+    auto state = new (state_start) state_sensor_possible_states;
 
     rec->hdr.type = 4;
     rec->hdr.record_handle = 1;
@@ -973,13 +952,13 @@
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_sensor_possible_states*>(state_start);
+    state = new (state_start) state_sensor_possible_states;
     state->state_set_id = 19;
     state->possible_states_size = 1;
 
     state_start += state->possible_states_size + sizeof(state->state_set_id) +
                    sizeof(state->possible_states_size);
-    state = reinterpret_cast<state_sensor_possible_states*>(state_start);
+    state = new (state_start) state_sensor_possible_states;
     state->state_set_id = 39;
     state->possible_states_size = 1;
 
diff --git a/fw-update/test/device_updater_test.cpp b/fw-update/test/device_updater_test.cpp
index ace5e2d..bd1d684 100644
--- a/fw-update/test/device_updater_test.cpp
+++ b/fw-update/test/device_updater_test.cpp
@@ -47,7 +47,7 @@
 
     package.seekg(0);
     std::vector<uint8_t> packageHeader(sizeof(pldm_package_header_information));
-    package.read(reinterpret_cast<char*>(packageHeader.data()),
+    package.read(new (packageHeader.data()) char,
                  sizeof(pldm_package_header_information));
 
     auto pkgHeaderInfo =
@@ -58,16 +58,14 @@
     packageHeader.clear();
     packageHeader.resize(pkgHeaderInfoSize);
     package.seekg(0);
-    package.read(reinterpret_cast<char*>(packageHeader.data()),
-                 pkgHeaderInfoSize);
+    package.read(new (packageHeader.data()) char, pkgHeaderInfoSize);
 
     auto parser = parsePkgHeader(packageHeader);
     EXPECT_NE(parser, nullptr);
 
     package.seekg(0);
     packageHeader.resize(parser->pkgHeaderSize);
-    package.read(reinterpret_cast<char*>(packageHeader.data()),
-                 parser->pkgHeaderSize);
+    package.read(new (packageHeader.data()) char, parser->pkgHeaderSize);
 
     parser->parse(packageHeader, packageSize);
     const auto& fwDeviceIDRecords = parser->getFwDeviceIDRecords();
diff --git a/libpldmresponder/test/libpldmresponder_base_test.cpp b/libpldmresponder/test/libpldmresponder_base_test.cpp
index 539d2cf..f169dff 100644
--- a/libpldmresponder/test/libpldmresponder_base_test.cpp
+++ b/libpldmresponder/test/libpldmresponder_base_test.cpp
@@ -25,13 +25,13 @@
 TEST_F(TestBaseCommands, testPLDMTypesGoodRequest)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr)> requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto request = new (requestPayload.data()) pldm_msg;
     // payload length will be 0 in this case
     size_t requestPayloadLength = 0;
     base::Handler handler(event);
     auto response = handler.getPLDMTypes(request, requestPayloadLength);
     // Need to support OEM type.
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
     uint8_t* payload_ptr = responsePtr->payload;
     ASSERT_EQ(payload_ptr[0], 0);
     ASSERT_EQ(payload_ptr[1], 29); // 0b11101 see DSP0240 table11
@@ -43,11 +43,11 @@
     // Need to support OEM type commands.
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto request = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
     base::Handler handler(event);
     auto response = handler.getPLDMCommands(request, requestPayloadLength);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
     uint8_t* payload_ptr = responsePtr->payload;
     ASSERT_EQ(payload_ptr[0], 0);
     ASSERT_EQ(payload_ptr[1], 60); // 60 = 0b111100
@@ -58,13 +58,13 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto request = new (requestPayload.data()) pldm_msg;
 
     request->payload[0] = 0xFF;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
     base::Handler handler(event);
     auto response = handler.getPLDMCommands(request, requestPayloadLength);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
     uint8_t* payload_ptr = responsePtr->payload;
     ASSERT_EQ(payload_ptr[0], PLDM_ERROR_INVALID_PLDM_TYPE);
 }
@@ -73,7 +73,7 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto request = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     uint8_t pldmType = PLDM_BASE;
@@ -89,7 +89,7 @@
 
     base::Handler handler(event);
     auto response = handler.getPLDMVersion(request, requestPayloadLength);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
 
     ASSERT_EQ(responsePtr->payload[0], 0);
     ASSERT_EQ(0, memcmp(responsePtr->payload + sizeof(responsePtr->payload[0]),
@@ -106,7 +106,7 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto request = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     uint8_t pldmType = 7;
@@ -120,11 +120,11 @@
 
     base::Handler handler(event);
     auto response = handler.getPLDMVersion(request, requestPayloadLength - 1);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
 
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
 
-    request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    request = new (requestPayload.data()) pldm_msg;
     requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     rc = encode_get_version_req(0, transferHandle, flag, pldmType, request);
@@ -132,7 +132,7 @@
     ASSERT_EQ(0, rc);
 
     response = handler.getPLDMVersion(request, requestPayloadLength);
-    responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    responsePtr = new (response.data()) pldm_msg;
 
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
 }
@@ -140,14 +140,14 @@
 TEST_F(TestBaseCommands, testGetTIDGoodRequest)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr)> requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto request = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = 0;
 
     base::Handler handler(event);
     handler.setOemPlatformHandler(nullptr);
     auto response = handler.getTID(request, requestPayloadLength);
 
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
     uint8_t* payload = responsePtr->payload;
 
     ASSERT_EQ(payload[0], 0);
diff --git a/libpldmresponder/test/libpldmresponder_bios_enum_attribute_test.cpp b/libpldmresponder/test/libpldmresponder_bios_enum_attribute_test.cpp
index 1521fcb..356ccc6 100644
--- a/libpldmresponder/test/libpldmresponder_bios_enum_attribute_test.cpp
+++ b/libpldmresponder/test/libpldmresponder_bios_enum_attribute_test.cpp
@@ -233,8 +233,6 @@
                 setDbusProperty(dbusMapping, PropertyValue{bool(true)}))
         .Times(1);
     enumReadWrite.setAttrValueOnDbus(
-        reinterpret_cast<pldm_bios_attr_val_table_entry*>(
-            attrValueEntry.data()),
-        reinterpret_cast<pldm_bios_attr_table_entry*>(attrEntry.data()),
-        biosStringTable);
+        new (attrValueEntry.data()) pldm_bios_attr_val_table_entry,
+        new (attrEntry.data()) pldm_bios_attr_table_entry, biosStringTable);
 }
diff --git a/libpldmresponder/test/libpldmresponder_bios_integer_attribute_test.cpp b/libpldmresponder/test/libpldmresponder_bios_integer_attribute_test.cpp
index 6d4026a..193ee82 100644
--- a/libpldmresponder/test/libpldmresponder_bios_integer_attribute_test.cpp
+++ b/libpldmresponder/test/libpldmresponder_bios_integer_attribute_test.cpp
@@ -200,8 +200,7 @@
         7, 0, 0, 0, 0, 0, 0, 0, /* current value */
     };
 
-    auto entry = reinterpret_cast<pldm_bios_attr_val_table_entry*>(
-        attrValueEntry.data());
+    auto entry = new (attrValueEntry.data()) pldm_bios_attr_val_table_entry;
     EXPECT_CALL(dbusHandler,
                 setDbusProperty(dbusMapping, PropertyValue{uint8_t(7)}))
         .Times(1);
diff --git a/libpldmresponder/test/libpldmresponder_bios_string_attribute_test.cpp b/libpldmresponder/test/libpldmresponder_bios_string_attribute_test.cpp
index 08c8ea7..2cccd95 100644
--- a/libpldmresponder/test/libpldmresponder_bios_string_attribute_test.cpp
+++ b/libpldmresponder/test/libpldmresponder_bios_string_attribute_test.cpp
@@ -193,8 +193,7 @@
         4,   0,             /* current string length */
         'a', 'b', 'c', 'd', /* default value string handle index */
     };
-    auto entry = reinterpret_cast<pldm_bios_attr_val_table_entry*>(
-        attrValueEntry.data());
+    auto entry = new (attrValueEntry.data()) pldm_bios_attr_val_table_entry;
     PropertyValue value = std::string("abcd");
     EXPECT_CALL(dbusHandler, setDbusProperty(dbusMapping, value)).Times(1);
     stringReadWrite.setAttrValueOnDbus(entry, nullptr, biosStringTable);
diff --git a/libpldmresponder/test/libpldmresponder_pdr_effecter_test.cpp b/libpldmresponder/test/libpldmresponder_pdr_effecter_test.cpp
index 87ee867..4891b9e 100644
--- a/libpldmresponder/test/libpldmresponder_pdr_effecter_test.cpp
+++ b/libpldmresponder/test/libpldmresponder_pdr_effecter_test.cpp
@@ -43,8 +43,7 @@
     pdr_utils::PdrEntry e;
     auto record2 = pdr::getRecordByHandle(outRepo, 2, e);
     ASSERT_NE(record2, nullptr);
-    pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
+    pldm_state_effecter_pdr* pdr = new (e.data) pldm_state_effecter_pdr;
 
     ASSERT_EQ(pdr->hdr.record_handle, 2);
     ASSERT_EQ(pdr->hdr.version, 1);
@@ -61,8 +60,8 @@
     ASSERT_EQ(pdr->effecter_init, PLDM_NO_INIT);
     ASSERT_EQ(pdr->has_description_pdr, false);
     ASSERT_EQ(pdr->composite_effecter_count, 2);
-    state_effecter_possible_states* states =
-        reinterpret_cast<state_effecter_possible_states*>(pdr->possible_states);
+    state_effecter_possible_states* states = new (pdr->possible_states)
+        state_effecter_possible_states;
     ASSERT_EQ(states->state_set_id, 196);
     ASSERT_EQ(states->possible_states_size, 1);
     bitfield8_t bf1{};
@@ -76,7 +75,7 @@
     // Check second PDR
     auto record3 = pdr::getRecordByHandle(outRepo, 3, e);
     ASSERT_NE(record3, nullptr);
-    pdr = reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
+    pdr = new (e.data) pldm_state_effecter_pdr;
 
     ASSERT_EQ(pdr->hdr.record_handle, 3);
     ASSERT_EQ(pdr->hdr.version, 1);
@@ -93,14 +92,13 @@
     ASSERT_EQ(pdr->effecter_init, PLDM_NO_INIT);
     ASSERT_EQ(pdr->has_description_pdr, false);
     ASSERT_EQ(pdr->composite_effecter_count, 2);
-    states =
-        reinterpret_cast<state_effecter_possible_states*>(pdr->possible_states);
+    states = new (pdr->possible_states) state_effecter_possible_states;
     ASSERT_EQ(states->state_set_id, 197);
     ASSERT_EQ(states->possible_states_size, 1);
     bf1.byte = 2;
     ASSERT_EQ(states->states[0].byte, bf1.byte);
-    states = reinterpret_cast<state_effecter_possible_states*>(
-        pdr->possible_states + sizeof(state_effecter_possible_states));
+    states = new (pdr->possible_states + sizeof(state_effecter_possible_states))
+        state_effecter_possible_states;
     ASSERT_EQ(states->state_set_id, 198);
     ASSERT_EQ(states->possible_states_size, 2);
     bitfield8_t bf2[2];
@@ -145,8 +143,8 @@
     auto record = pdr::getRecordByHandle(outRepo, 4, e);
     ASSERT_NE(record, nullptr);
 
-    pldm_numeric_effecter_value_pdr* pdr =
-        reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
+    pldm_numeric_effecter_value_pdr* pdr = new (e.data)
+        pldm_numeric_effecter_value_pdr;
     EXPECT_EQ(pdr->hdr.record_handle, 4);
     EXPECT_EQ(pdr->hdr.version, 1);
     EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
diff --git a/libpldmresponder/test/libpldmresponder_pdr_sensor_test.cpp b/libpldmresponder/test/libpldmresponder_pdr_sensor_test.cpp
index ae1ed3a..f8e0a05 100644
--- a/libpldmresponder/test/libpldmresponder_pdr_sensor_test.cpp
+++ b/libpldmresponder/test/libpldmresponder_pdr_sensor_test.cpp
@@ -22,7 +22,7 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     MockdBusHandler mockedUtils;
@@ -49,8 +49,7 @@
     auto record = pdr::getRecordByHandle(outRepo, 2, e);
     ASSERT_NE(record, nullptr);
 
-    pldm_state_sensor_pdr* pdr =
-        reinterpret_cast<pldm_state_sensor_pdr*>(e.data);
+    pldm_state_sensor_pdr* pdr = new (e.data) pldm_state_sensor_pdr;
     EXPECT_EQ(pdr->hdr.record_handle, 2);
     EXPECT_EQ(pdr->hdr.version, 1);
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR);
@@ -74,7 +73,7 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     MockdBusHandler mockedUtils;
diff --git a/libpldmresponder/test/libpldmresponder_platform_test.cpp b/libpldmresponder/test/libpldmresponder_platform_test.cpp
index 4fbd81b..28859e0 100644
--- a/libpldmresponder/test/libpldmresponder_platform_test.cpp
+++ b/libpldmresponder/test/libpldmresponder_platform_test.cpp
@@ -28,11 +28,10 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    struct pldm_get_pdr_req* request =
-        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    struct pldm_get_pdr_req* request = new (req->payload) pldm_get_pdr_req;
     request->request_count = 100;
 
     MockdBusHandler mockedUtils;
@@ -48,15 +47,15 @@
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
 
-    struct pldm_get_pdr_resp* resp =
-        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    struct pldm_get_pdr_resp* resp = new (responsePtr->payload)
+        pldm_get_pdr_resp;
     ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
     ASSERT_EQ(2, resp->next_record_handle);
     ASSERT_EQ(true, resp->response_count != 0);
 
-    pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data);
+    pldm_pdr_hdr* hdr = new (resp->record_data) pldm_pdr_hdr;
     ASSERT_EQ(hdr->record_handle, 1);
     ASSERT_EQ(hdr->version, 1);
 
@@ -67,11 +66,10 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    struct pldm_get_pdr_req* request =
-        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    struct pldm_get_pdr_req* request = new (req->payload) pldm_get_pdr_req;
     request->request_count = 1;
 
     MockdBusHandler mockedUtils;
@@ -87,9 +85,9 @@
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
-    struct pldm_get_pdr_resp* resp =
-        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    auto responsePtr = new (response.data()) pldm_msg;
+    struct pldm_get_pdr_resp* resp = new (responsePtr->payload)
+        pldm_get_pdr_resp;
     ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
     ASSERT_EQ(1, resp->response_count);
     pldm_pdr_destroy(pdrRepo);
@@ -99,11 +97,10 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    struct pldm_get_pdr_req* request =
-        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    struct pldm_get_pdr_req* request = new (req->payload) pldm_get_pdr_req;
     request->record_handle = 100000;
     request->request_count = 1;
 
@@ -120,7 +117,7 @@
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
 
     ASSERT_EQ(responsePtr->payload[0], PLDM_PLATFORM_INVALID_RECORD_HANDLE);
 
@@ -131,11 +128,10 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    struct pldm_get_pdr_req* request =
-        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    struct pldm_get_pdr_req* request = new (req->payload) pldm_get_pdr_req;
     request->record_handle = 1;
 
     MockdBusHandler mockedUtils;
@@ -151,9 +147,9 @@
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
-    struct pldm_get_pdr_resp* resp =
-        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    auto responsePtr = new (response.data()) pldm_msg;
+    struct pldm_get_pdr_resp* resp = new (responsePtr->payload)
+        pldm_get_pdr_resp;
     ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
     ASSERT_EQ(2, resp->next_record_handle);
 
@@ -164,11 +160,10 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    struct pldm_get_pdr_req* request =
-        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    struct pldm_get_pdr_req* request = new (req->payload) pldm_get_pdr_req;
     request->request_count = 100;
 
     MockdBusHandler mockedUtils;
@@ -193,19 +188,19 @@
     {
         request->record_handle = handle;
         auto response = handler.getPDR(req, requestPayloadLength);
-        auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
-        struct pldm_get_pdr_resp* resp =
-            reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+        auto responsePtr = new (response.data()) pldm_msg;
+        struct pldm_get_pdr_resp* resp = new (responsePtr->payload)
+            pldm_get_pdr_resp;
         ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
 
         handle = resp->next_record_handle; // point to the next pdr in case
                                            // current is not what we want
 
-        pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data);
+        pldm_pdr_hdr* hdr = new (resp->record_data) pldm_pdr_hdr;
         if (hdr->type == PLDM_STATE_EFFECTER_PDR)
         {
-            pldm_state_effecter_pdr* pdr =
-                reinterpret_cast<pldm_state_effecter_pdr*>(resp->record_data);
+            pldm_state_effecter_pdr* pdr = new (resp->record_data)
+                pldm_state_effecter_pdr;
             if (pdr->entity_type == 100)
             {
                 found = true;
@@ -227,7 +222,7 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     MockdBusHandler mockedUtils;
@@ -248,8 +243,7 @@
     pdr_utils::PdrEntry e;
     auto record1 = pdr::getRecordByHandle(outRepo, 2, e);
     ASSERT_NE(record1, nullptr);
-    pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
+    pldm_state_effecter_pdr* pdr = new (e.data) pldm_state_effecter_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
 
     std::vector<set_effecter_state_field> stateField;
@@ -275,7 +269,7 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = new (requestPayload.data()) pldm_msg;
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     MockdBusHandler mockedUtils;
@@ -296,8 +290,7 @@
     pdr_utils::PdrEntry e;
     auto record1 = pdr::getRecordByHandle(outRepo, 2, e);
     ASSERT_NE(record1, nullptr);
-    pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
+    pldm_state_effecter_pdr* pdr = new (e.data) pldm_state_effecter_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
 
     std::vector<set_effecter_state_field> stateField;
@@ -342,8 +335,8 @@
     auto record4 = pdr::getRecordByHandle(numericEffecterPDRs, 4, e);
     ASSERT_NE(record4, nullptr);
 
-    pldm_numeric_effecter_value_pdr* pdr =
-        reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
+    pldm_numeric_effecter_value_pdr* pdr = new (e.data)
+        pldm_numeric_effecter_value_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
 
     uint16_t effecterId = 3;
@@ -386,8 +379,8 @@
     auto record4 = pdr::getRecordByHandle(numericEffecterPDRs, 4, e);
     ASSERT_NE(record4, nullptr);
 
-    pldm_numeric_effecter_value_pdr* pdr =
-        reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
+    pldm_numeric_effecter_value_pdr* pdr = new (e.data)
+        pldm_numeric_effecter_value_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
 
     uint16_t effecterId = 3;
@@ -423,8 +416,8 @@
     auto record4 = pdr::getRecordByHandle(numericEffecterPDRs, 4, e);
     ASSERT_NE(record4, nullptr);
 
-    pldm_numeric_effecter_value_pdr* pdr =
-        reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
+    pldm_numeric_effecter_value_pdr* pdr = new (e.data)
+        pldm_numeric_effecter_value_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
 
     uint16_t effecterId = 3;
@@ -456,7 +449,7 @@
         getEffecterDataSize(effecterDataSize);
 
     Response response(responsePayloadLength + sizeof(pldm_msg_hdr));
-    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    auto responsePtr = new (response.data()) pldm_msg;
 
     rc = platform_numeric_effecter::getNumericEffecterValueHandler(
         propertyType, dbusValue, effecterDataSize, responsePtr,
@@ -465,8 +458,7 @@
     ASSERT_EQ(rc, 0);
 
     struct pldm_get_numeric_effecter_value_resp* resp =
-        reinterpret_cast<struct pldm_get_numeric_effecter_value_resp*>(
-            responsePtr->payload);
+        new (responsePtr->payload) pldm_get_numeric_effecter_value_resp;
     ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
     uint32_t valPresent;
     memcpy(&valPresent, &resp->pending_and_present_values[4],
@@ -499,8 +491,8 @@
     auto record4 = pdr::getRecordByHandle(numericEffecterPDRs, 4, e);
     ASSERT_NE(record4, nullptr);
 
-    pldm_numeric_effecter_value_pdr* pdr =
-        reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
+    pldm_numeric_effecter_value_pdr* pdr = new (e.data)
+        pldm_numeric_effecter_value_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
 
     uint16_t effecterId = 4;
@@ -799,8 +791,7 @@
     pdr_utils::PdrEntry e;
     auto record = pdr::getRecordByHandle(outRepo, 2, e);
     ASSERT_NE(record, nullptr);
-    pldm_state_sensor_pdr* pdr =
-        reinterpret_cast<pldm_state_sensor_pdr*>(e.data);
+    pldm_state_sensor_pdr* pdr = new (e.data) pldm_state_sensor_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR);
 
     std::vector<get_sensor_state_field> stateField;
@@ -849,8 +840,7 @@
     pdr_utils::PdrEntry e;
     auto record = pdr::getRecordByHandle(outRepo, 2, e);
     ASSERT_NE(record, nullptr);
-    pldm_state_sensor_pdr* pdr =
-        reinterpret_cast<pldm_state_sensor_pdr*>(e.data);
+    pldm_state_sensor_pdr* pdr = new (e.data) pldm_state_sensor_pdr;
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR);
 
     std::vector<get_sensor_state_field> stateField;
diff --git a/platform-mc/test/event_manager_test.cpp b/platform-mc/test/event_manager_test.cpp
index 4550b40..bb4706f 100644
--- a/platform-mc/test/event_manager_test.cpp
+++ b/platform-mc/test/event_manager_test.cpp
@@ -226,7 +226,7 @@
             0x0 // dataTransferHandleTimeout
         };
     auto rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
+        new (getPDRRepositoryInfoResp.data()) pldm_msg,
         sizeof(getPDRRepositoryInfoResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -300,8 +300,8 @@
         0,                             // fatalHigh
         0                              // fatalLow
     };
-    rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
+    rc = terminusManager.enqueueResponse(new (getPdrResp.data()) pldm_msg,
+                                         sizeof(getPdrResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     const size_t getPdrAuxNameRespLen = 39;
@@ -336,8 +336,7 @@
             0x00  // Entity Name "S0"
         };
     rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrAuxNameResp.data()),
-        sizeof(getPdrAuxNameResp));
+        new (getPdrAuxNameResp.data()) pldm_msg, sizeof(getPdrAuxNameResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     // queue eventMessageBufferSize response(bufferSize=32)
@@ -345,7 +344,7 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + eventMessageBufferSizeRespLen>
         eventMessageBufferSizeResp{0x0, 0x02, 0x0d, PLDM_SUCCESS, 32, 0};
     rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(eventMessageBufferSizeResp.data()),
+        new (eventMessageBufferSizeResp.data()) pldm_msg,
         sizeof(eventMessageBufferSizeResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -359,7 +358,7 @@
                                   3,    // numberEventClassReturned
                                   0x0,  0x5,  0xfa};
     rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(eventMessageSupportedResp.data()),
+        new (eventMessageSupportedResp.data()) pldm_msg,
         sizeof(eventMessageSupportedResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -372,7 +371,7 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + SetEventReceiverLen>
         SetEventReceiverResp{0x0, 0x02, 0x04, PLDM_SUCCESS};
     rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(SetEventReceiverResp.data()),
+        new (SetEventReceiverResp.data()) pldm_msg,
         sizeof(SetEventReceiverResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -439,7 +438,7 @@
             4 // eventData first part
         };
     auto rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(pollForPlatformEventMessage1Resp.data()),
+        new (pollForPlatformEventMessage1Resp.data()) pldm_msg,
         sizeof(pollForPlatformEventMessage1Resp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -476,7 +475,7 @@
             0x5d // crc32
         };
     rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(pollForPlatformEventMessage2Resp.data()),
+        new (pollForPlatformEventMessage2Resp.data()) pldm_msg,
         sizeof(pollForPlatformEventMessage2Resp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -489,7 +488,7 @@
             0x0, 0x0 // eventID
         };
     rc = terminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(pollForPlatformEventMessage3Resp.data()),
+        new (pollForPlatformEventMessage3Resp.data()) pldm_msg,
         sizeof(pollForPlatformEventMessage3Resp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
diff --git a/platform-mc/test/platform_manager_test.cpp b/platform-mc/test/platform_manager_test.cpp
index ab4921b..5f0fe35 100644
--- a/platform-mc/test/platform_manager_test.cpp
+++ b/platform-mc/test/platform_manager_test.cpp
@@ -70,7 +70,7 @@
             0x0 // dataTransferHandleTimeout
         };
     auto rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
+        new (getPDRRepositoryInfoResp.data()) pldm_msg,
         sizeof(getPDRRepositoryInfoResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -144,8 +144,8 @@
         0,                             // fatalHigh
         0                              // fatalLow
     };
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
+    rc = mockTerminusManager.enqueueResponse(new (getPdrResp.data()) pldm_msg,
+                                             sizeof(getPdrResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     const size_t getPdrAuxNameRespLen = 39;
@@ -180,8 +180,7 @@
             0x00  // Entity Name "S0"
         };
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrAuxNameResp.data()),
-        sizeof(getPdrAuxNameResp));
+        new (getPdrAuxNameResp.data()) pldm_msg, sizeof(getPdrAuxNameResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     mockTerminusManager.updateMctpEndpointAvailability(
@@ -236,7 +235,7 @@
             0x0 // dataTransferHandleTimeout
         };
     auto rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
+        new (getPDRRepositoryInfoResp.data()) pldm_msg,
         sizeof(getPDRRepositoryInfoResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -310,8 +309,8 @@
         0,                             // fatalHigh
         0                              // fatalLow
     };
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
+    rc = mockTerminusManager.enqueueResponse(new (getPdrResp.data()) pldm_msg,
+                                             sizeof(getPdrResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     const size_t getPdrAuxNameRespLen = 39;
@@ -346,8 +345,7 @@
             0x00  // Entity Name "S0"
         };
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrAuxNameResp.data()),
-        sizeof(getPdrAuxNameResp));
+        new (getPdrAuxNameResp.data()) pldm_msg, sizeof(getPdrAuxNameResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     mockTerminusManager.updateMctpEndpointAvailability(
@@ -394,7 +392,7 @@
             0x0 // dataTransferHandleTimeout
         };
     auto rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
+        new (getPDRRepositoryInfoResp.data()) pldm_msg,
         sizeof(getPDRRepositoryInfoResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -468,8 +466,8 @@
         0,                             // fatalHigh
         0                              // fatalLow
     };
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
+    rc = mockTerminusManager.enqueueResponse(new (getPdrResp.data()) pldm_msg,
+                                             sizeof(getPdrResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     stdexec::sync_wait(platformManager.initTerminus());
@@ -509,7 +507,7 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
         getPDRRepositoryInfoResp{0x0, 0x02, 0x50, PLDM_ERROR};
     auto rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
+        new (getPDRRepositoryInfoResp.data()) pldm_msg,
         sizeof(getPDRRepositoryInfoResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -517,8 +515,8 @@
     const size_t getPdrRespLen = 1;
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
         0x0, 0x02, 0x51, PLDM_ERROR};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
+    rc = mockTerminusManager.enqueueResponse(new (getPdrResp.data()) pldm_msg,
+                                             sizeof(getPdrResp));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     stdexec::sync_wait(platformManager.initTerminus());
diff --git a/platform-mc/test/terminus_manager_test.cpp b/platform-mc/test/terminus_manager_test.cpp
index 6eb2439..52abfc8 100644
--- a/platform-mc/test/terminus_manager_test.cpp
+++ b/platform-mc/test/terminus_manager_test.cpp
@@ -142,20 +142,19 @@
 
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
         0x00, 0x02, 0x02, 0x00, 0x00};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
+    rc = mockTerminusManager.enqueueResponse(new (getTidResp0.data()) pldm_msg,
+                                             sizeof(getTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
     std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp0{
         0x00, 0x02, 0x01, 0x00};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
+    rc = mockTerminusManager.enqueueResponse(new (setTidResp0.data()) pldm_msg,
+                                             sizeof(setTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmTypesRespLen>
         getPldmTypesResp0{0x00, 0x02, 0x04, 0x00, 0x01, 0x00,
                           0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
-        sizeof(getPldmTypesResp0));
+        new (getPldmTypesResp0.data()) pldm_msg, sizeof(getPldmTypesResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     pldm::MctpInfos mctpInfos{};
@@ -169,15 +168,14 @@
 
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp1{
         0x00, 0x02, 0x02, 0x00, 0x01};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getTidResp1.data()), sizeof(getTidResp1));
+    rc = mockTerminusManager.enqueueResponse(new (getTidResp1.data()) pldm_msg,
+                                             sizeof(getTidResp1));
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+    rc = mockTerminusManager.enqueueResponse(new (setTidResp0.data()) pldm_msg,
+                                             sizeof(setTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
-    EXPECT_EQ(rc, PLDM_SUCCESS);
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
-        sizeof(getPldmTypesResp0));
+        new (getPldmTypesResp0.data()) pldm_msg, sizeof(getPldmTypesResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     mockTerminusManager.discoverMctpTerminus(mctpInfos);
@@ -201,7 +199,7 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
         0x00, 0x02, 0x02, 0x00, PLDM_TID_RESERVED};
     auto rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
+        new (getTidResp0.data()) pldm_msg, sizeof(getTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     pldm::MctpInfos mctpInfos{};
@@ -215,11 +213,11 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp1{
         0x00, 0x02, 0x01, PLDM_ERROR};
 
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getTidResp1.data()), sizeof(getTidResp1));
+    rc = mockTerminusManager.enqueueResponse(new (getTidResp1.data()) pldm_msg,
+                                             sizeof(getTidResp1));
     EXPECT_EQ(rc, PLDM_SUCCESS);
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(setTidResp1.data()), sizeof(setTidResp1));
+    rc = mockTerminusManager.enqueueResponse(new (setTidResp1.data()) pldm_msg,
+                                             sizeof(setTidResp1));
     EXPECT_EQ(rc, PLDM_SUCCESS);
     mockTerminusManager.removeMctpTerminus(mctpInfos);
     EXPECT_EQ(0, termini.size());
@@ -233,16 +231,15 @@
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmTypesRespLen>
         getPldmTypesResp2{0x00, 0x02, 0x04, PLDM_ERROR, 0x01, 0x00,
                           0x00, 0x00, 0x00, 0x00,       0x00, 0x00};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getTidResp2.data()), sizeof(getTidResp2));
+    rc = mockTerminusManager.enqueueResponse(new (getTidResp2.data()) pldm_msg,
+                                             sizeof(getTidResp2));
     EXPECT_EQ(rc, PLDM_SUCCESS);
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(setTidResp2.data()), sizeof(setTidResp2));
+    rc = mockTerminusManager.enqueueResponse(new (setTidResp2.data()) pldm_msg,
+                                             sizeof(setTidResp2));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmTypesResp2.data()),
-        sizeof(getPldmTypesResp2));
+        new (getPldmTypesResp2.data()) pldm_msg, sizeof(getPldmTypesResp2));
     EXPECT_EQ(rc, PLDM_SUCCESS);
     mockTerminusManager.removeMctpTerminus(mctpInfos);
     EXPECT_EQ(0, termini.size());
@@ -260,14 +257,14 @@
 
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
         0x00, 0x02, 0x02, 0x00, 0x00};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
+    rc = mockTerminusManager.enqueueResponse(new (getTidResp0.data()) pldm_msg,
+                                             sizeof(getTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp0{
         0x00, 0x02, 0x01, 0x00};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
+    rc = mockTerminusManager.enqueueResponse(new (setTidResp0.data()) pldm_msg,
+                                             sizeof(setTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     uint8_t supportedType1Byte =
@@ -278,8 +275,7 @@
                           0x00, 0x00, 0x00, 0x00, 0x00,
                           0x00, 0x00};
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
-        sizeof(getPldmTypesResp0));
+        new (getPldmTypesResp0.data()) pldm_msg, sizeof(getPldmTypesResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     pldm::MctpInfos mctpInfos{};
@@ -315,14 +311,14 @@
 
     std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
         0x00, 0x02, 0x02, 0x00, 0x00};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
+    rc = mockTerminusManager.enqueueResponse(new (getTidResp0.data()) pldm_msg,
+                                             sizeof(getTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp0{
         0x00, 0x02, 0x01, 0x00};
-    rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
+    rc = mockTerminusManager.enqueueResponse(new (setTidResp0.data()) pldm_msg,
+                                             sizeof(setTidResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     uint8_t byte0 = (1 << (PLDM_BASE % 8)) + (1 << (PLDM_PLATFORM % 8)) +
@@ -331,8 +327,7 @@
         getPldmTypesResp0{0x00, 0x02, 0x04, 0x00, byte0, 0x00,
                           0x00, 0x00, 0x00, 0x00, 0x00,  0x00};
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
-        sizeof(getPldmTypesResp0));
+        new (getPldmTypesResp0.data()) pldm_msg, sizeof(getPldmTypesResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     /* Response GetPLDMVersion BASE, CC=0 */
@@ -358,7 +353,7 @@
             0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00};
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmCommandBaseResp0.data()),
+        new (getPldmCommandBaseResp0.data()) pldm_msg,
         sizeof(getPldmCommandBaseResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -406,7 +401,7 @@
             0x00, 0x00,  0x00,  0x00, 0x00,  0x00,   0x00,  0x00, 0x00,
             0x00, 0x00,  0x00,  0x00, 0x00,  0x00,   0x00,  0x00, 0x00};
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmCommandPlatResp0.data()),
+        new (getPldmCommandPlatResp0.data()) pldm_msg,
         sizeof(getPldmCommandPlatResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -435,7 +430,7 @@
             0x00, 0x00, 0x00, 0x00, 0x00,  0x00,  0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00,  0x00,  0x00, 0x00};
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmCommandBiosResp0.data()),
+        new (getPldmCommandBiosResp0.data()) pldm_msg,
         sizeof(getPldmCommandBiosResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
@@ -465,7 +460,7 @@
             0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00};
     rc = mockTerminusManager.enqueueResponse(
-        reinterpret_cast<pldm_msg*>(getPldmCommandFruResp0.data()),
+        new (getPldmCommandFruResp0.data()) pldm_msg,
         sizeof(getPldmCommandFruResp0));
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
diff --git a/requester/test/handler_test.cpp b/requester/test/handler_test.cpp
index 86e2717..17560c5 100644
--- a/requester/test/handler_test.cpp
+++ b/requester/test/handler_test.cpp
@@ -170,7 +170,7 @@
             size_t responseLen;
             int rc = PLDM_SUCCESS;
 
-            auto requestPtr = reinterpret_cast<pldm_msg*>(request.data());
+            auto requestPtr = new (request.data()) pldm_msg;
             requestPtr->hdr.instance_id = instanceId;
 
             try
@@ -216,7 +216,7 @@
             pldm::Request request(sizeof(pldm_msg_hdr) + sizeof(uint8_t), 0);
             pldm::Response response;
 
-            auto requestPtr = reinterpret_cast<pldm_msg*>(request.data());
+            auto requestPtr = new (request.data()) pldm_msg;
             requestPtr->hdr.instance_id = instanceId;
 
             co_await reqHandler.sendRecvMsg(eid, std::move(request));
@@ -241,7 +241,7 @@
                                               uint8_t instanceId, uint8_t& tid)
         {
             pldm::Request request(sizeof(pldm_msg_hdr), 0);
-            auto requestMsg = reinterpret_cast<pldm_msg*>(request.data());
+            auto requestMsg = new (request.data()) pldm_msg;
             const pldm_msg* responseMsg;
             size_t responseLen;
 
@@ -281,7 +281,7 @@
 
     pldm::Response mockResponse(sizeof(pldm_msg_hdr) + PLDM_GET_TID_RESP_BYTES,
                                 0);
-    auto mockResponseMsg = reinterpret_cast<pldm_msg*>(mockResponse.data());
+    auto mockResponseMsg = new (mockResponse.data()) pldm_msg;
 
     // Compose response message of getTID command
     encode_get_tid_resp(instanceId, PLDM_SUCCESS, expectedTid, mockResponseMsg);
diff --git a/test/pldmd_registration_test.cpp b/test/pldmd_registration_test.cpp
index 4293357..dbdad5a 100644
--- a/test/pldmd_registration_test.cpp
+++ b/test/pldmd_registration_test.cpp
@@ -33,7 +33,7 @@
 TEST(CcOnlyResponse, testEncode)
 {
     std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr));
-    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+    auto request = new (requestMsg.data()) pldm_msg;
     encode_get_types_req(0, request);
 
     auto responseMsg = CmdHandler::ccOnlyResponse(request, PLDM_ERROR);