diff --git a/test/libpldmresponder_platform_test.cpp b/test/libpldmresponder_platform_test.cpp
index 208edc3..8252920 100644
--- a/test/libpldmresponder_platform_test.cpp
+++ b/test/libpldmresponder_platform_test.cpp
@@ -1,5 +1,6 @@
 #include "libpldmresponder/effecters.hpp"
 #include "libpldmresponder/pdr.hpp"
+#include "libpldmresponder/pdr_utils.hpp"
 #include "libpldmresponder/platform.hpp"
 
 #include <iostream>
@@ -9,87 +10,76 @@
 #include <gtest/gtest.h>
 
 using namespace pldm::responder;
-using namespace pldm::responder::pdr;
 
 TEST(getPDR, testGoodPath)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    *reqCount = 100;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->request_count = 100;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-    start = responsePtr->payload;
-    start += sizeof(uint8_t);
-    uint32_t* nextRecordHandle = reinterpret_cast<uint32_t*>(start);
-    ASSERT_EQ(*nextRecordHandle, 2);
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* recordCount = reinterpret_cast<uint16_t*>(start);
-    ASSERT_EQ(*recordCount != 0, true);
-    start += sizeof(uint16_t);
-    // Check a bit of the PDR common header
-    pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(start);
-    ASSERT_EQ(pdr->hdr.record_handle, 1);
-    ASSERT_EQ(pdr->hdr.version, 1);
+    struct pldm_get_pdr_resp* resp =
+        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    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);
+    ASSERT_EQ(hdr->record_handle, 1);
+    ASSERT_EQ(hdr->version, 1);
 }
 
 TEST(getPDR, testShortRead)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    // Read 1 byte of PDR
-    *reqCount = 1;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->request_count = 1;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
-
-    ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-    start = responsePtr->payload;
-    start +=
-        sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* recordCount = reinterpret_cast<uint16_t*>(start);
-    ASSERT_EQ(*recordCount, 1);
+    struct pldm_get_pdr_resp* resp =
+        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
+    ASSERT_EQ(1, resp->response_count);
 }
 
 TEST(getPDR, testBadRecordHandle)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    uint32_t* recordHandle = reinterpret_cast<uint32_t*>(start);
-    *recordHandle = 100000;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    *reqCount = 1;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->record_handle = 100000;
+    request->request_count = 1;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
     ASSERT_EQ(responsePtr->payload[0], PLDM_PLATFORM_INVALID_RECORD_HANDLE);
@@ -99,73 +89,66 @@
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    uint32_t* recordHandle = reinterpret_cast<uint32_t*>(start);
-    *recordHandle = 3;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->record_handle = 1;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
-
-    ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-    start = responsePtr->payload;
-    start += sizeof(uint8_t);
-    uint32_t* nextRecordHandle = reinterpret_cast<uint32_t*>(start);
-    ASSERT_EQ(*nextRecordHandle, 0);
+    struct pldm_get_pdr_resp* resp =
+        reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
+    ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
+    ASSERT_EQ(2, resp->next_record_handle);
 }
 
 TEST(getPDR, testFindPDR)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
         requestPayload{};
-    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    uint8_t* start = request->payload;
-    start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
-    uint16_t* reqCount = reinterpret_cast<uint16_t*>(start);
-    *reqCount = 100;
-    using namespace pdr;
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
+    struct pldm_get_pdr_req* request =
+        reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
+    request->request_count = 100;
+
+    pdr_utils::RepoInterface& pdrRepo =
+        pdr::getRepo("./pdr_jsons/state_effecter/good");
     ASSERT_EQ(pdrRepo.empty(), false);
     platform::Handler handler;
-    auto response = handler.getPDR(request, requestPayloadLength);
+    auto response = handler.getPDR(req, requestPayloadLength);
 
     // Let's try to find a PDR of type stateEffecter (= 11) and entity type =
     // 100
     bool found = false;
     uint32_t handle = 0; // start asking for PDRs from recordHandle 0
-    uint32_t* recordHandle = nullptr;
     while (!found)
     {
-        start = request->payload;
-        recordHandle = reinterpret_cast<uint32_t*>(start);
-        *recordHandle = handle;
+        request->record_handle = handle;
         platform::Handler handler;
-        auto response = handler.getPDR(request, requestPayloadLength);
+        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);
+        ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
 
-        ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
-        start = responsePtr->payload;
-        start += sizeof(uint8_t);
-        uint32_t* nextRecordHandle = reinterpret_cast<uint32_t*>(start);
-        handle = *nextRecordHandle; // point to the next pdr in case current is
-                                    // not what we want
-        start += sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t) +
-                 sizeof(uint16_t);
-        pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(start);
-        uint32_t intType = hdr->type;
+        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);
         std::cerr << "PDR next record handle " << handle << "\n";
-        std::cerr << "PDR type " << intType << "\n";
+        std::cerr << "PDR type " << hdr->type << "\n";
         if (hdr->type == PLDM_STATE_EFFECTER_PDR)
         {
             pldm_state_effecter_pdr* pdr =
-                reinterpret_cast<pldm_state_effecter_pdr*>(start);
+                reinterpret_cast<pldm_state_effecter_pdr*>(resp->record_data);
             std::cerr << "PDR entity type " << pdr->entity_type << "\n";
             if (pdr->entity_type == 100)
             {
@@ -174,7 +157,7 @@
                 break;
             }
         }
-        if (!*nextRecordHandle) // no more records
+        if (!resp->next_record_handle) // no more records
         {
             break;
         }
@@ -204,10 +187,13 @@
 
 TEST(setStateEffecterStatesHandler, testGoodRequest)
 {
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
-    pdr::Entry e = pdrRepo.at(1);
+    pdr_utils::Repo pdrRepo = pdr::getRepoByType(
+        "./pdr_jsons/state_effecter/good", PLDM_STATE_EFFECTER_PDR);
+    pdr_utils::PdrEntry e;
+    auto record1 = pdr::getRecordByHandle(pdrRepo, 1, e);
+    ASSERT_NE(record1, nullptr);
     pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data());
+        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
 
     std::vector<set_effecter_state_field> stateField;
@@ -232,10 +218,13 @@
 
 TEST(setStateEffecterStatesHandler, testBadRequest)
 {
-    Repo& pdrRepo = get("./pdr_jsons/state_effecter/good");
-    pdr::Entry e = pdrRepo.at(1);
+    pdr_utils::Repo pdrRepo = pdr::getRepoByType(
+        "./pdr_jsons/state_effecter/good", PLDM_STATE_EFFECTER_PDR);
+    pdr_utils::PdrEntry e;
+    auto record1 = pdr::getRecordByHandle(pdrRepo, 1, e);
+    ASSERT_NE(record1, nullptr);
     pldm_state_effecter_pdr* pdr =
-        reinterpret_cast<pldm_state_effecter_pdr*>(e.data());
+        reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
 
     std::vector<set_effecter_state_field> stateField;