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;