diff --git a/platform-mc/sensor_manager.cpp b/platform-mc/sensor_manager.cpp
index 2f9eaa5..46e0786 100644
--- a/platform-mc/sensor_manager.cpp
+++ b/platform-mc/sensor_manager.cpp
@@ -33,21 +33,11 @@
                   tid);
         return;
     }
-    // numeric sensor
-    auto terminus = termini[tid];
-    for (auto& sensor : terminus->numericSensors)
-    {
-        roundRobinSensors[tid].push(sensor);
-    }
+
+    roundRobinSensorItMap[tid] = 0;
 
     updateAvailableState(tid, true);
 
-    if (!roundRobinSensors[tid].size())
-    {
-        lg2::info("Terminus ID {TID}: no sensors to poll.", "TID", tid);
-        return;
-    }
-
     sensorPollTimers[tid] = std::make_unique<sdbusplus::Timer>(
         event.get(),
         std::bind_front(&SensorManager::doSensorPolling, this, tid));
@@ -85,6 +75,11 @@
 
     // numeric sensor
     auto terminus = termini[tid];
+    if (!terminus)
+    {
+        return;
+    }
+
     for (auto& sensor : terminus->numericSensors)
     {
         sensor->updateReading(true, false,
@@ -101,7 +96,7 @@
         sensorPollTimers.erase(tid);
     }
 
-    roundRobinSensors.erase(tid);
+    roundRobinSensorItMap.erase(tid);
 
     if (doSensorPollingTaskHandles.contains(tid))
     {
@@ -203,6 +198,13 @@
         }
 
         auto& terminus = termini[tid];
+        if (!terminus)
+        {
+            lg2::info(
+                "Terminus ID {TID} does not have a valid Terminus object {NOW}.",
+                "TID", tid, "NOW", pldm::utils::getCurrentSystemTime());
+            co_return PLDM_ERROR;
+        }
 
         if (manager && terminus->pollEvent)
         {
@@ -216,7 +218,19 @@
         }
 
         sd_event_now(event.get(), CLOCK_MONOTONIC, &t1);
-        auto toBeUpdated = roundRobinSensors[tid].size();
+
+        auto& numericSensors = terminus->numericSensors;
+        auto toBeUpdated = numericSensors.size();
+
+        if (!roundRobinSensorItMap.contains(tid))
+        {
+            lg2::info(
+                "Terminus ID {TID} does not have a round robin sensor iteration {NOW}.",
+                "TID", tid, "NOW", pldm::utils::getCurrentSystemTime());
+            co_return PLDM_ERROR;
+        }
+        auto& sensorIt = roundRobinSensorItMap[tid];
+
         while (((t1 - t0) < pollingTimeInUsec) && (toBeUpdated > 0))
         {
             if (!getAvailableState(tid))
@@ -227,7 +241,12 @@
                 co_await stdexec::just_stopped();
             }
 
-            auto sensor = roundRobinSensors[tid].front();
+            if (sensorIt >= numericSensors.size())
+            {
+                sensorIt = 0;
+            }
+
+            auto sensor = numericSensors[sensorIt];
 
             sd_event_now(event.get(), CLOCK_MONOTONIC, &t1);
             elapsed = t1 - sensor->timeStamp;
@@ -255,11 +274,8 @@
             }
 
             toBeUpdated--;
-            if (roundRobinSensors.contains(tid))
-            {
-                roundRobinSensors[tid].pop();
-                roundRobinSensors[tid].push(std::move(sensor));
-            }
+            sensorIt++;
+
             sd_event_now(event.get(), CLOCK_MONOTONIC, &t1);
         }
 
diff --git a/platform-mc/sensor_manager.hpp b/platform-mc/sensor_manager.hpp
index c82b336..ce61d8f 100644
--- a/platform-mc/sensor_manager.hpp
+++ b/platform-mc/sensor_manager.hpp
@@ -19,6 +19,8 @@
 namespace platform_mc
 {
 
+using namespace pldm::pdr;
+
 /**
  * @brief SensorManager
  *
@@ -117,9 +119,8 @@
     /** @brief Available state for pldm request of terminus */
     std::map<pldm_tid_t, Availability> availableState;
 
-    /** @brief round robin sensor list */
-    std::map<pldm_tid_t, std::queue<std::shared_ptr<NumericSensor>>>
-        roundRobinSensors;
+    /** @brief Round robin sensor iter of terminus */
+    std::map<pldm_tid_t, SensorID> roundRobinSensorItMap;
 
     /** @brief pointer to Manager */
     Manager* manager;
diff --git a/platform-mc/terminus.cpp b/platform-mc/terminus.cpp
index ba299be..c262842 100644
--- a/platform-mc/terminus.cpp
+++ b/platform-mc/terminus.cpp
@@ -14,10 +14,11 @@
 namespace platform_mc
 {
 
-Terminus::Terminus(pldm_tid_t tid, uint64_t supportedTypes) :
+Terminus::Terminus(pldm_tid_t tid, uint64_t supportedTypes,
+                   sdeventplus::Event& event) :
     initialized(false), maxBufferSize(PLDM_PLATFORM_EVENT_MSG_MAX_BUFFER_SIZE),
     synchronyConfigurationSupported(0), pollEvent(false), tid(tid),
-    supportedTypes(supportedTypes)
+    supportedTypes(supportedTypes), event(event)
 {}
 
 bool Terminus::doesSupportType(uint8_t type)
@@ -119,11 +120,6 @@
 
 void Terminus::parseTerminusPDRs()
 {
-    std::vector<std::shared_ptr<pldm_numeric_sensor_value_pdr>>
-        numericSensorPdrs{};
-    std::vector<std::shared_ptr<pldm_compact_numeric_sensor_pdr>>
-        compactNumericSensorPdrs{};
-
     for (auto& pdr : pdrs)
     {
         auto pdrHdr = new (pdr.data()) pldm_pdr_hdr;
@@ -228,15 +224,48 @@
                    tid, "PATH", inventoryPath);
     }
 
-    for (auto pdr : numericSensorPdrs)
+    addNextSensorFromPDRs();
+}
+
+void Terminus::addNextSensorFromPDRs()
+{
+    sensorCreationEvent.reset();
+
+    if (terminusName.empty())
     {
-        addNumericSensor(pdr);
+        lg2::error(
+            "Terminus ID {TID}: DOES NOT have name. Skip Adding sensors.",
+            "TID", tid);
+        return;
     }
 
-    for (auto pdr : compactNumericSensorPdrs)
+    auto pdrIt = sensorPdrIt;
+
+    if (pdrIt < numericSensorPdrs.size())
     {
-        addCompactNumericSensor(pdr);
+        const auto& pdr = numericSensorPdrs[pdrIt];
+        // Defer adding the next Numeric Sensor
+        sensorCreationEvent = std::make_unique<sdeventplus::source::Defer>(
+            event,
+            std::bind(std::mem_fn(&Terminus::addNumericSensor), this, pdr));
     }
+    else if (pdrIt < numericSensorPdrs.size() + compactNumericSensorPdrs.size())
+    {
+        pdrIt -= numericSensorPdrs.size();
+        const auto& pdr = compactNumericSensorPdrs[pdrIt];
+        // Defer adding the next Compact Numeric Sensor
+        sensorCreationEvent = std::make_unique<sdeventplus::source::Defer>(
+            event, std::bind(std::mem_fn(&Terminus::addCompactNumericSensor),
+                             this, pdr));
+    }
+    else
+    {
+        sensorPdrIt = 0;
+        return;
+    }
+
+    // Move the iteration to the next sensor PDR
+    sensorPdrIt++;
 }
 
 std::shared_ptr<SensorAuxiliaryNames> Terminus::getSensorAuxiliaryNames(
@@ -391,20 +420,12 @@
 void Terminus::addNumericSensor(
     const std::shared_ptr<pldm_numeric_sensor_value_pdr> pdr)
 {
-    if (terminusName.empty())
-    {
-        lg2::error(
-            "Terminus ID {TID}: DOES NOT have name. Skip Adding sensors.",
-            "TID", tid);
-        return;
-    }
-
     if (!pdr)
     {
         lg2::error(
             "Terminus ID {TID}: Skip adding Numeric Sensor - invalid pointer to PDR.",
             "TID", tid);
-        return;
+        addNextSensorFromPDRs();
     }
 
     auto sensorId = pdr->sensor_id;
@@ -415,7 +436,7 @@
         lg2::error(
             "Terminus ID {TID}: Failed to get name for Numeric Sensor {SID}",
             "TID", tid, "SID", sensorId);
-        return;
+        addNextSensorFromPDRs();
     }
 
     std::string sensorName = sensorNames.front();
@@ -433,6 +454,8 @@
             "Failed to create NumericSensor. error - {ERROR} sensorname - {NAME}",
             "ERROR", e, "NAME", sensorName);
     }
+
+    addNextSensorFromPDRs();
 }
 
 std::shared_ptr<SensorAuxiliaryNames> Terminus::parseCompactNumericSensorNames(
@@ -503,20 +526,12 @@
 void Terminus::addCompactNumericSensor(
     const std::shared_ptr<pldm_compact_numeric_sensor_pdr> pdr)
 {
-    if (terminusName.empty())
-    {
-        lg2::error(
-            "Terminus ID {TID}: DOES NOT have name. Skip Adding sensors.",
-            "TID", tid);
-        return;
-    }
-
     if (!pdr)
     {
         lg2::error(
             "Terminus ID {TID}: Skip adding Compact Numeric Sensor - invalid pointer to PDR.",
             "TID", tid);
-        return;
+        addNextSensorFromPDRs();
     }
 
     auto sensorId = pdr->sensor_id;
@@ -527,7 +542,7 @@
         lg2::error(
             "Terminus ID {TID}: Failed to get name for Compact Numeric Sensor {SID}",
             "TID", tid, "SID", sensorId);
-        return;
+        addNextSensorFromPDRs();
     }
 
     std::string sensorName = sensorNames.front();
@@ -545,6 +560,8 @@
             "Failed to create Compact NumericSensor. error - {ERROR} sensorname - {NAME}",
             "ERROR", e, "NAME", sensorName);
     }
+
+    addNextSensorFromPDRs();
 }
 
 std::shared_ptr<NumericSensor> Terminus::getSensorObject(SensorId id)
diff --git a/platform-mc/terminus.hpp b/platform-mc/terminus.hpp
index 6e3f859..c3134bd 100644
--- a/platform-mc/terminus.hpp
+++ b/platform-mc/terminus.hpp
@@ -68,7 +68,8 @@
 class Terminus
 {
   public:
-    Terminus(pldm_tid_t tid, uint64_t supportedPLDMTypes);
+    Terminus(pldm_tid_t tid, uint64_t supportedPLDMTypes,
+             sdeventplus::Event& event);
 
     /** @brief Check if the terminus supports the PLDM type message
      *
@@ -284,6 +285,11 @@
      */
     std::vector<std::string> getSensorNames(const SensorId& sensorId);
 
+    /** @brief Add the next sensor PDR to this terminus, iterated by
+     *         sensorPdrIt.
+     */
+    void addNextSensorFromPDRs();
+
     /* @brief The terminus's TID */
     pldm_tid_t tid;
 
@@ -319,6 +325,25 @@
 
     /* @brief Inventory D-Bus object path of the terminus */
     std::string inventoryPath;
+
+    /** @brief reference of main event loop of pldmd, primarily used to schedule
+     *  work
+     */
+    sdeventplus::Event& event;
+
+    /** @brief The event source to defer sensor creation tasks to event loop*/
+    std::unique_ptr<sdeventplus::source::Defer> sensorCreationEvent;
+
+    /** @brief Numeric Sensor PDR list */
+    std::vector<std::shared_ptr<pldm_numeric_sensor_value_pdr>>
+        numericSensorPdrs{};
+
+    /** @brief Compact Numeric Sensor PDR list */
+    std::vector<std::shared_ptr<pldm_compact_numeric_sensor_pdr>>
+        compactNumericSensorPdrs{};
+
+    /** @brief Iteration to loop through sensor PDRs when adding sensors */
+    SensorId sensorPdrIt = 0;
 };
 } // namespace platform_mc
 } // namespace pldm
diff --git a/platform-mc/terminus_manager.cpp b/platform-mc/terminus_manager.cpp
index c64c0c3..406c70a 100644
--- a/platform-mc/terminus_manager.cpp
+++ b/platform-mc/terminus_manager.cpp
@@ -354,7 +354,7 @@
 
     try
     {
-        termini[tid] = std::make_shared<Terminus>(tid, supportedTypes);
+        termini[tid] = std::make_shared<Terminus>(tid, supportedTypes, event);
     }
     catch (const sdbusplus::exception_t& e)
     {
diff --git a/platform-mc/terminus_manager.hpp b/platform-mc/terminus_manager.hpp
index f8611f7..fa6a7eb 100644
--- a/platform-mc/terminus_manager.hpp
+++ b/platform-mc/terminus_manager.hpp
@@ -52,11 +52,12 @@
     virtual ~TerminusManager() = default;
 
     explicit TerminusManager(
-        sdeventplus::Event& /* event */, RequesterHandler& handler,
+        sdeventplus::Event& event, RequesterHandler& handler,
         pldm::InstanceIdDb& instanceIdDb, TerminiMapper& termini,
         Manager* manager, mctp_eid_t localEid) :
         handler(handler), instanceIdDb(instanceIdDb), termini(termini),
-        tidPool(tidPoolSize, false), manager(manager), localEid(localEid)
+        tidPool(tidPoolSize, false), manager(manager), localEid(localEid),
+        event(event)
     {
         // DSP0240 v1.1.0 table-8, special value: 0,0xFF = reserved
         tidPool[0] = true;
@@ -287,6 +288,11 @@
 
     /** @brief MCTP Endpoint available status mapping */
     std::map<MctpInfo, Availability> mctpInfoAvailTable;
+
+    /** @brief reference of main event loop of pldmd, primarily used to schedule
+     *  work
+     */
+    sdeventplus::Event& event;
 };
 } // namespace platform_mc
 } // namespace pldm
diff --git a/platform-mc/test/event_manager_test.cpp b/platform-mc/test/event_manager_test.cpp
index f27f94e..087dff3 100644
--- a/platform-mc/test/event_manager_test.cpp
+++ b/platform-mc/test/event_manager_test.cpp
@@ -9,6 +9,7 @@
 #include "platform-mc/platform_manager.hpp"
 #include "platform-mc/terminus_manager.hpp"
 #include "test/test_instance_id.hpp"
+#include "utils_test.hpp"
 
 #include <gtest/gtest.h>
 
@@ -45,7 +46,7 @@
 #define WARNING_HIGH 45
     pldm_tid_t tid = 1;
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     std::vector<uint8_t> pdr1{
         0x1,
         0x0,
@@ -146,6 +147,9 @@
     termini[tid]->pdrs.emplace_back(pdr1);
     termini[tid]->pdrs.emplace_back(pdr2);
     termini[tid]->parseTerminusPDRs();
+    // Run event loop for a few seconds to let sensor creation
+    // defer tasks be run. May increase time when sensor num is large
+    utils::runEventLoopForSeconds(event, 1);
     EXPECT_EQ(1, termini[tid]->numericSensors.size());
 
     uint8_t platformEventStatus = 0;
@@ -170,7 +174,7 @@
     auto mappedTid = terminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
     auto tid = mappedTid.value();
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     auto terminus = termini[tid];
 
     /* Set supported command by terminus */
@@ -374,6 +378,9 @@
 
     // should finish immediately
     stdexec::sync_wait(platformManager.initTerminus());
+    // Run event loop for a few seconds to let sensor creation
+    // defer tasks be run. May increase time when sensor num is large
+    utils::runEventLoopForSeconds(event, 1);
     EXPECT_EQ(true, terminus->initialized);
     EXPECT_EQ(32, terminus->maxBufferSize);
     EXPECT_EQ(0x06, terminus->synchronyConfigurationSupported.byte);
@@ -398,7 +405,7 @@
     auto mappedTid = terminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
     auto tid = mappedTid.value();
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     auto terminus = termini[tid];
 
     // queue pollForPlatformEventMessage first part response
diff --git a/platform-mc/test/platform_manager_test.cpp b/platform-mc/test/platform_manager_test.cpp
index ef226f8..ab4921b 100644
--- a/platform-mc/test/platform_manager_test.cpp
+++ b/platform-mc/test/platform_manager_test.cpp
@@ -2,6 +2,7 @@
 #include "mock_terminus_manager.hpp"
 #include "platform-mc/platform_manager.hpp"
 #include "test/test_instance_id.hpp"
+#include "utils_test.hpp"
 
 #include <sdeventplus/event.hpp>
 
@@ -37,7 +38,7 @@
     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
     auto tid = mappedTid.value();
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     auto terminus = termini[tid];
 
     /* Set supported command by terminus */
@@ -190,6 +191,9 @@
     EXPECT_EQ(true, terminus->initialized);
     EXPECT_EQ(true, terminus->doesSupportCommand(PLDM_PLATFORM, PLDM_GET_PDR));
     EXPECT_EQ(2, terminus->pdrs.size());
+    // Run event loop for a few seconds to let sensor creation
+    // defer tasks be run. May increase time when sensor num is large
+    utils::runEventLoopForSeconds(event, 1);
     EXPECT_EQ(1, terminus->numericSensors.size());
     EXPECT_EQ("S0", terminus->getTerminusName().value());
 }
@@ -200,7 +204,7 @@
     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
     auto tid = mappedTid.value();
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     auto terminus = termini[tid];
 
     /* Set supported command by terminus */
@@ -361,7 +365,7 @@
     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
     auto tid = mappedTid.value();
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     auto terminus = termini[tid];
 
     /* Set supported command by terminus */
@@ -478,11 +482,14 @@
     // terminus doesn't Type2 support
     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
     auto tid = mappedTid.value();
-    termini[tid] =
-        std::make_shared<pldm::platform_mc::Terminus>(tid, 1 << PLDM_BASE);
+    termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
+        tid, 1 << PLDM_BASE, event);
     auto terminus = termini[tid];
 
     stdexec::sync_wait(platformManager.initTerminus());
+    // Run event loop for a few seconds to let sensor creation
+    // defer tasks be run. May increase time when sensor num is large
+    utils::runEventLoopForSeconds(event, 1);
     EXPECT_EQ(true, terminus->initialized);
     EXPECT_EQ(0, terminus->pdrs.size());
     EXPECT_EQ(0, terminus->numericSensors.size());
@@ -494,7 +501,7 @@
     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
     auto tid = mappedTid.value();
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     auto terminus = termini[tid];
 
     // queue getPDRRepositoryInfo response cc=PLDM_ERROR
@@ -515,6 +522,9 @@
     EXPECT_EQ(rc, PLDM_SUCCESS);
 
     stdexec::sync_wait(platformManager.initTerminus());
+    // Run event loop for a few seconds to let sensor creation
+    // defer tasks be run. May increase time when sensor num is large
+    utils::runEventLoopForSeconds(event, 1);
     EXPECT_EQ(true, terminus->initialized);
     EXPECT_EQ(0, terminus->pdrs.size());
     EXPECT_EQ(0, terminus->numericSensors.size());
diff --git a/platform-mc/test/sensor_manager_test.cpp b/platform-mc/test/sensor_manager_test.cpp
index 4ec9f5b..3bf185e 100644
--- a/platform-mc/test/sensor_manager_test.cpp
+++ b/platform-mc/test/sensor_manager_test.cpp
@@ -3,6 +3,7 @@
 #include "mock_sensor_manager.hpp"
 #include "platform-mc/terminus_manager.hpp"
 #include "test/test_instance_id.hpp"
+#include "utils_test.hpp"
 
 #include <sdeventplus/event.hpp>
 
@@ -22,24 +23,6 @@
         sensorManager(event, terminusManager, termini, nullptr)
     {}
 
-    void runEventLoopForSeconds(uint64_t sec)
-    {
-        uint64_t t0 = 0;
-        uint64_t t1 = 0;
-        uint64_t usec = sec * 1000000;
-        uint64_t elapsed = 0;
-        sd_event_now(event.get(), CLOCK_MONOTONIC, &t0);
-        do
-        {
-            if (!sd_event_run(event.get(), usec - elapsed))
-            {
-                break;
-            }
-            sd_event_now(event.get(), CLOCK_MONOTONIC, &t1);
-            elapsed = t1 - t0;
-        } while (elapsed < usec);
-    }
-
     PldmTransport* pldmTransport = nullptr;
     sdbusplus::bus_t& bus;
     sdeventplus::Event event;
@@ -151,9 +134,8 @@
 TEST_F(SensorManagerTest, sensorPollingTest)
 {
     uint64_t seconds = 10;
-
     pldm_tid_t tid = 1;
-    termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(tid, 0);
+    termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(tid, 0, event);
     termini[tid]->pdrs.push_back(pdr1);
     termini[tid]->pdrs.push_back(pdr2);
     termini[tid]->parseTerminusPDRs();
@@ -172,7 +154,7 @@
 
     sensorManager.startPolling(tid);
 
-    runEventLoopForSeconds(seconds);
+    utils::runEventLoopForSeconds(event, seconds);
 
     sensorManager.stopPolling(tid);
 }
diff --git a/platform-mc/test/terminus_manager_test.cpp b/platform-mc/test/terminus_manager_test.cpp
index 80d2699..f4f0ec1 100644
--- a/platform-mc/test/terminus_manager_test.cpp
+++ b/platform-mc/test/terminus_manager_test.cpp
@@ -553,7 +553,7 @@
     auto mappedTid = mockTerminusManager.mapTid(mctpInfo);
     auto tid = mappedTid.value();
     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
-        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     auto terminus = termini[tid];
 
     auto mappedTid1 = terminusManager.mapTid(mctpInfo);
diff --git a/platform-mc/test/terminus_test.cpp b/platform-mc/test/terminus_test.cpp
index a8dcbc1..77ae931 100644
--- a/platform-mc/test/terminus_test.cpp
+++ b/platform-mc/test/terminus_test.cpp
@@ -7,9 +7,10 @@
 
 TEST(TerminusTest, supportedTypeTest)
 {
-    auto t1 = pldm::platform_mc::Terminus(1, 1 << PLDM_BASE);
-    auto t2 =
-        pldm::platform_mc::Terminus(2, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+    auto event = sdeventplus::Event::get_default();
+    auto t1 = pldm::platform_mc::Terminus(1, 1 << PLDM_BASE, event);
+    auto t2 = pldm::platform_mc::Terminus(
+        2, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
 
     EXPECT_EQ(true, t1.doesSupportType(PLDM_BASE));
     EXPECT_EQ(false, t1.doesSupportType(PLDM_PLATFORM));
@@ -19,16 +20,18 @@
 
 TEST(TerminusTest, getTidTest)
 {
+    auto event = sdeventplus::Event::get_default();
     const pldm_tid_t tid = 1;
-    auto t1 = pldm::platform_mc::Terminus(tid, 1 << PLDM_BASE);
+    auto t1 = pldm::platform_mc::Terminus(tid, 1 << PLDM_BASE, event);
 
     EXPECT_EQ(tid, t1.getTid());
 }
 
 TEST(TerminusTest, parseSensorAuxiliaryNamesPDRTest)
 {
-    auto t1 =
-        pldm::platform_mc::Terminus(1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+    auto event = sdeventplus::Event::get_default();
+    auto t1 = pldm::platform_mc::Terminus(
+        1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     std::vector<uint8_t> pdr1{
         0x0,
         0x0,
@@ -110,8 +113,9 @@
 
 TEST(TerminusTest, parseSensorAuxiliaryMultiNamesPDRTest)
 {
-    auto t1 =
-        pldm::platform_mc::Terminus(1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+    auto event = sdeventplus::Event::get_default();
+    auto t1 = pldm::platform_mc::Terminus(
+        1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     std::vector<uint8_t> pdr1{
         0x0,
         0x0,
@@ -229,8 +233,9 @@
 
 TEST(TerminusTest, parseSensorAuxiliaryNamesMultiSensorsPDRTest)
 {
-    auto t1 =
-        pldm::platform_mc::Terminus(1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+    auto event = sdeventplus::Event::get_default();
+    auto t1 = pldm::platform_mc::Terminus(
+        1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     std::vector<uint8_t> pdr1{
         0x0,
         0x0,
@@ -350,8 +355,9 @@
 
 TEST(TerminusTest, parsePDRTestNoSensorPDR)
 {
-    auto t1 =
-        pldm::platform_mc::Terminus(1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+    auto event = sdeventplus::Event::get_default();
+    auto t1 = pldm::platform_mc::Terminus(
+        1, 1 << PLDM_BASE | 1 << PLDM_PLATFORM, event);
     std::vector<uint8_t> pdr1{
         0x1, 0x0, 0x0,
         0x0,                             // record handle
diff --git a/platform-mc/test/utils_test.hpp b/platform-mc/test/utils_test.hpp
new file mode 100644
index 0000000..ca78082
--- /dev/null
+++ b/platform-mc/test/utils_test.hpp
@@ -0,0 +1,24 @@
+#include <systemd/sd-event.h>
+
+#include <sdeventplus/event.hpp>
+
+namespace utils
+{
+void runEventLoopForSeconds(sdeventplus::Event& event, uint64_t sec)
+{
+    uint64_t t0 = 0;
+    uint64_t t1 = 0;
+    uint64_t usec = sec * 1000000;
+    uint64_t elapsed = 0;
+    sd_event_now(event.get(), CLOCK_MONOTONIC, &t0);
+    do
+    {
+        if (!sd_event_run(event.get(), usec - elapsed))
+        {
+            break;
+        }
+        sd_event_now(event.get(), CLOCK_MONOTONIC, &t1);
+        elapsed = t1 - t0;
+    } while (elapsed < usec);
+}
+} // namespace utils