diff --git a/test/async/fdio_timed.cpp b/test/async/fdio_timed.cpp
deleted file mode 100644
index 85c93b6..0000000
--- a/test/async/fdio_timed.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-#include <sdbusplus/async.hpp>
-
-#include <filesystem>
-#include <fstream>
-
-#include <gtest/gtest.h>
-
-using namespace std::literals;
-
-namespace fs = std::filesystem;
-
-class FdioTimedTest : public ::testing::Test
-{
-  protected:
-    enum class testWriteOperation
-    {
-        writeSync,
-        writeAsync,
-        writeSkip
-    };
-
-    const fs::path path = "/tmp/test_fdio_timed";
-
-    FdioTimedTest()
-    {
-        if (!fs::exists(path))
-        {
-            fs::create_directory(path);
-        }
-
-        fd = inotify_init1(IN_NONBLOCK);
-        EXPECT_NE(fd, -1) << "Error occurred during the inotify_init1, error: "
-                          << errno;
-
-        wd = inotify_add_watch(fd, path.c_str(), IN_CLOSE_WRITE);
-        EXPECT_NE(wd, -1)
-            << "Error occurred during the inotify_add_watch, error: " << errno;
-        fdioInstance = std::make_unique<sdbusplus::async::fdio>(
-            *ctx, fd, std::chrono::microseconds(1000));
-    }
-
-    ~FdioTimedTest() noexcept override
-    {
-        if (fd != -1)
-        {
-            if (wd != -1)
-            {
-                inotify_rm_watch(fd, wd);
-            }
-            close(fd);
-        }
-        ctx.reset();
-
-        if (fs::exists(path))
-        {
-            fs::remove_all(path);
-        }
-    }
-
-    auto writeToFile() -> sdbusplus::async::task<>
-    {
-        std::ofstream outfile((path / "test_fdio.txt").native());
-        EXPECT_TRUE(outfile.is_open())
-            << "Error occurred during file open, error: " << errno;
-        outfile << "Test fdio!" << std::endl;
-        outfile.close();
-        co_return;
-    }
-
-    auto testFdTimedEvents(bool& ran, testWriteOperation writeOperation,
-                           int testIterations) -> sdbusplus::async::task<>
-    {
-        for (int i = 0; i < testIterations; i++)
-        {
-            switch (writeOperation)
-            {
-                case testWriteOperation::writeSync:
-                    co_await writeToFile();
-                    break;
-                case testWriteOperation::writeAsync:
-                    ctx->spawn(
-                        sdbusplus::async::sleep_for(*ctx, 1s) |
-                        stdexec::then([&]() { ctx->spawn(writeToFile()); }));
-                    break;
-                case testWriteOperation::writeSkip:
-                default:
-                    break;
-            }
-
-            bool receivedTimeout = false;
-
-            try
-            {
-                co_await fdioInstance->next();
-            }
-            catch (const sdbusplus::async::fdio_timeout_exception& e)
-            {
-                receivedTimeout = true;
-            }
-
-            switch (writeOperation)
-            {
-                case testWriteOperation::writeSync:
-                    EXPECT_FALSE(receivedTimeout) << "Expected event";
-                    break;
-                case testWriteOperation::writeAsync:
-                case testWriteOperation::writeSkip:
-                default:
-                    EXPECT_TRUE(receivedTimeout) << "Expected timeout";
-                    break;
-            }
-        }
-        ran = true;
-
-        co_return;
-    }
-
-    std::unique_ptr<sdbusplus::async::fdio> fdioInstance;
-    std::optional<sdbusplus::async::context> ctx{std::in_place};
-
-  private:
-    int fd = -1;
-    int wd = -1;
-};
-
-TEST_F(FdioTimedTest, TestWriteSkipWithTimeout)
-{
-    bool ran = false;
-    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeSkip, 1));
-    ctx->spawn(
-        sdbusplus::async::sleep_for(*ctx, 2s) |
-        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
-    ctx->run();
-    EXPECT_TRUE(ran);
-}
-
-TEST_F(FdioTimedTest, TestWriteAsyncWithTimeout)
-{
-    bool ran = false;
-    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeAsync, 1));
-    ctx->spawn(
-        sdbusplus::async::sleep_for(*ctx, 2s) |
-        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
-    ctx->run();
-    EXPECT_TRUE(ran);
-}
-
-TEST_F(FdioTimedTest, TestWriteAsyncWithTimeoutIterative)
-{
-    bool ran = false;
-    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeAsync, 100));
-    ctx->spawn(
-        sdbusplus::async::sleep_for(*ctx, 2s) |
-        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
-    ctx->run();
-    EXPECT_TRUE(ran);
-}
-
-TEST_F(FdioTimedTest, TestWriteSync)
-{
-    bool ran = false;
-    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeSync, 1));
-    ctx->spawn(
-        sdbusplus::async::sleep_for(*ctx, 2s) |
-        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
-    ctx->run();
-    EXPECT_TRUE(ran);
-}
-
-TEST_F(FdioTimedTest, TestWriteSyncIterative)
-{
-    bool ran = false;
-    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeSync, 100));
-    ctx->spawn(
-        sdbusplus::async::sleep_for(*ctx, 2s) |
-        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
-    ctx->run();
-    EXPECT_TRUE(ran);
-}
diff --git a/test/async/fdio_timed/fdio_timed_write_async_with_timeout.cpp b/test/async/fdio_timed/fdio_timed_write_async_with_timeout.cpp
new file mode 100644
index 0000000..0121fde
--- /dev/null
+++ b/test/async/fdio_timed/fdio_timed_write_async_with_timeout.cpp
@@ -0,0 +1,18 @@
+#include "suite.hpp"
+
+#include <sdbusplus/async.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace std::literals;
+
+TEST_F(FdioTimedTest, TestWriteAsyncWithTimeout)
+{
+    bool ran = false;
+    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeAsync, 1));
+    ctx->spawn(
+        sdbusplus::async::sleep_for(*ctx, 2s) |
+        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
+    ctx->run();
+    EXPECT_TRUE(ran);
+}
diff --git a/test/async/fdio_timed/fdio_timed_write_async_with_timeout_iterative.cpp b/test/async/fdio_timed/fdio_timed_write_async_with_timeout_iterative.cpp
new file mode 100644
index 0000000..a26c963
--- /dev/null
+++ b/test/async/fdio_timed/fdio_timed_write_async_with_timeout_iterative.cpp
@@ -0,0 +1,18 @@
+#include "suite.hpp"
+
+#include <sdbusplus/async.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace std::literals;
+
+TEST_F(FdioTimedTest, TestWriteAsyncWithTimeoutIterative)
+{
+    bool ran = false;
+    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeAsync, 100));
+    ctx->spawn(
+        sdbusplus::async::sleep_for(*ctx, 2s) |
+        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
+    ctx->run();
+    EXPECT_TRUE(ran);
+}
diff --git a/test/async/fdio_timed/fdio_timed_write_skip_with_timeout.cpp b/test/async/fdio_timed/fdio_timed_write_skip_with_timeout.cpp
new file mode 100644
index 0000000..8fd83d1
--- /dev/null
+++ b/test/async/fdio_timed/fdio_timed_write_skip_with_timeout.cpp
@@ -0,0 +1,18 @@
+#include "suite.hpp"
+
+#include <sdbusplus/async.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace std::literals;
+
+TEST_F(FdioTimedTest, TestWriteSkipWithTimeout)
+{
+    bool ran = false;
+    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeSkip, 1));
+    ctx->spawn(
+        sdbusplus::async::sleep_for(*ctx, 2s) |
+        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
+    ctx->run();
+    EXPECT_TRUE(ran);
+}
diff --git a/test/async/fdio_timed/fdio_timed_write_sync.cpp b/test/async/fdio_timed/fdio_timed_write_sync.cpp
new file mode 100644
index 0000000..49e3d22
--- /dev/null
+++ b/test/async/fdio_timed/fdio_timed_write_sync.cpp
@@ -0,0 +1,18 @@
+#include "suite.hpp"
+
+#include <sdbusplus/async.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace std::literals;
+
+TEST_F(FdioTimedTest, TestWriteSync)
+{
+    bool ran = false;
+    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeSync, 1));
+    ctx->spawn(
+        sdbusplus::async::sleep_for(*ctx, 2s) |
+        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
+    ctx->run();
+    EXPECT_TRUE(ran);
+}
diff --git a/test/async/fdio_timed/fdio_timed_write_sync_iterative.cpp b/test/async/fdio_timed/fdio_timed_write_sync_iterative.cpp
new file mode 100644
index 0000000..4cf548c
--- /dev/null
+++ b/test/async/fdio_timed/fdio_timed_write_sync_iterative.cpp
@@ -0,0 +1,18 @@
+#include "suite.hpp"
+
+#include <sdbusplus/async.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace std::literals;
+
+TEST_F(FdioTimedTest, TestWriteSyncIterative)
+{
+    bool ran = false;
+    ctx->spawn(testFdTimedEvents(ran, testWriteOperation::writeSync, 100));
+    ctx->spawn(
+        sdbusplus::async::sleep_for(*ctx, 2s) |
+        sdbusplus::async::execution::then([&]() { ctx->request_stop(); }));
+    ctx->run();
+    EXPECT_TRUE(ran);
+}
diff --git a/test/async/fdio_timed/meson.build b/test/async/fdio_timed/meson.build
new file mode 100644
index 0000000..57588be
--- /dev/null
+++ b/test/async/fdio_timed/meson.build
@@ -0,0 +1,20 @@
+
+async_tests = [
+    'fdio_timed_write_async_with_timeout',
+    'fdio_timed_write_async_with_timeout_iterative',
+    'fdio_timed_write_skip_with_timeout',
+    'fdio_timed_write_sync',
+    'fdio_timed_write_sync_iterative',
+]
+
+foreach t : async_tests
+    test(
+        'test_' + t.underscorify(),
+        executable(
+            'test-' + t.underscorify(),
+            t + '.cpp',
+            'suite.cpp',
+            dependencies: [gtest_dep, gmock_dep, sdbusplus_dep],
+        ),
+    )
+endforeach
diff --git a/test/async/fdio_timed/suite.cpp b/test/async/fdio_timed/suite.cpp
new file mode 100644
index 0000000..16397f6
--- /dev/null
+++ b/test/async/fdio_timed/suite.cpp
@@ -0,0 +1,113 @@
+#include "suite.hpp"
+
+#include <unistd.h>
+
+#include <sdbusplus/async.hpp>
+
+#include <filesystem>
+#include <format>
+#include <fstream>
+
+#include <gtest/gtest.h>
+
+using namespace std::literals;
+
+namespace fs = std::filesystem;
+
+FdioTimedTest::FdioTimedTest()
+{
+    constexpr auto path_base = "/tmp/test_fdio_timed";
+
+    path = std::format("{}{}", path_base, getpid());
+
+    if (!fs::exists(path))
+    {
+        fs::create_directory(path);
+    }
+
+    fd = inotify_init1(IN_NONBLOCK);
+    EXPECT_NE(fd, -1) << "Error occurred during the inotify_init1, error: "
+                      << errno;
+
+    wd = inotify_add_watch(fd, path.c_str(), IN_CLOSE_WRITE);
+    EXPECT_NE(wd, -1) << "Error occurred during the inotify_add_watch, error: "
+                      << errno;
+    fdioInstance = std::make_unique<sdbusplus::async::fdio>(
+        *ctx, fd, std::chrono::microseconds(1000));
+}
+
+FdioTimedTest::~FdioTimedTest() noexcept
+{
+    if (fd != -1)
+    {
+        if (wd != -1)
+        {
+            inotify_rm_watch(fd, wd);
+        }
+        close(fd);
+    }
+    ctx.reset();
+
+    if (fs::exists(path))
+    {
+        fs::remove_all(path);
+    }
+}
+
+auto FdioTimedTest::writeToFile() -> sdbusplus::async::task<>
+{
+    std::ofstream outfile((path / "test_fdio.txt").native());
+    EXPECT_TRUE(outfile.is_open())
+        << "Error occurred during file open, error: " << errno;
+    outfile << "Test fdio!" << std::endl;
+    outfile.close();
+    co_return;
+}
+
+auto FdioTimedTest::testFdTimedEvents(
+    bool& ran, testWriteOperation writeOperation, int testIterations)
+    -> sdbusplus::async::task<>
+{
+    for (int i = 0; i < testIterations; i++)
+    {
+        switch (writeOperation)
+        {
+            case testWriteOperation::writeSync:
+                co_await writeToFile();
+                break;
+            case testWriteOperation::writeAsync:
+                ctx->spawn(sdbusplus::async::sleep_for(*ctx, 1s) |
+                           stdexec::then([&]() { ctx->spawn(writeToFile()); }));
+                break;
+            case testWriteOperation::writeSkip:
+            default:
+                break;
+        }
+
+        bool receivedTimeout = false;
+
+        try
+        {
+            co_await fdioInstance->next();
+        }
+        catch (const sdbusplus::async::fdio_timeout_exception& e)
+        {
+            receivedTimeout = true;
+        }
+
+        switch (writeOperation)
+        {
+            case testWriteOperation::writeSync:
+                EXPECT_FALSE(receivedTimeout) << "Expected event";
+                break;
+            case testWriteOperation::writeAsync:
+            case testWriteOperation::writeSkip:
+            default:
+                EXPECT_TRUE(receivedTimeout) << "Expected timeout";
+                break;
+        }
+    }
+    ran = true;
+
+    co_return;
+}
diff --git a/test/async/fdio_timed/suite.hpp b/test/async/fdio_timed/suite.hpp
new file mode 100644
index 0000000..a6282e2
--- /dev/null
+++ b/test/async/fdio_timed/suite.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <unistd.h>
+
+#include <sdbusplus/async.hpp>
+
+#include <filesystem>
+
+#include <gtest/gtest.h>
+
+using namespace std::literals;
+
+namespace fs = std::filesystem;
+
+class FdioTimedTest : public ::testing::Test
+{
+  protected:
+    enum class testWriteOperation
+    {
+        writeSync,
+        writeAsync,
+        writeSkip
+    };
+
+    fs::path path;
+
+    FdioTimedTest();
+
+    ~FdioTimedTest() noexcept override;
+
+    auto writeToFile() -> sdbusplus::async::task<>;
+
+    auto testFdTimedEvents(bool& ran, testWriteOperation writeOperation,
+                           int testIterations) -> sdbusplus::async::task<>;
+
+    std::unique_ptr<sdbusplus::async::fdio> fdioInstance;
+    std::optional<sdbusplus::async::context> ctx{std::in_place};
+
+  private:
+    int fd = -1;
+    int wd = -1;
+};
diff --git a/test/async/meson.build b/test/async/meson.build
new file mode 100644
index 0000000..d3edd65
--- /dev/null
+++ b/test/async/meson.build
@@ -0,0 +1,15 @@
+
+async_tests = ['context', 'fdio', 'mutex', 'task', 'timer', 'watchdog']
+
+foreach t : async_tests
+    test(
+        'test_' + t.underscorify(),
+        executable(
+            'test-' + t.underscorify(),
+            t + '.cpp',
+            dependencies: [gtest_dep, gmock_dep, sdbusplus_dep],
+        ),
+    )
+endforeach
+
+subdir('fdio_timed')
diff --git a/test/meson.build b/test/meson.build
index 5af90c0..2e9a21d 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -19,14 +19,10 @@
     endif
 endif
 
+subdir('async')
+subdir('timer')
+
 tests = [
-    'async/context',
-    'async/fdio',
-    'async/fdio_timed',
-    'async/mutex',
-    'async/task',
-    'async/timer',
-    'async/watchdog',
     'bus/exception',
     'bus/list_names',
     'bus/match',
@@ -37,7 +33,6 @@
     'message/native_types',
     'message/read',
     'message/types',
-    'timer',
     'unpack_properties',
     'utility/make_dbus_args_tuple',
     'utility/tuple_to_array',
diff --git a/test/timer.cpp b/test/timer.cpp
deleted file mode 100644
index 58ff2a1..0000000
--- a/test/timer.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-#include <sdbusplus/timer.hpp>
-
-#include <chrono>
-#include <iostream>
-
-#include <gtest/gtest.h>
-
-using sdbusplus::Timer;
-
-class TimerTest : public ::testing::Test
-{
-  public:
-    // systemd event handler
-    sd_event* events = nullptr;
-
-    // Need this so that events can be initialized.
-    int rc;
-
-    // Source of event
-    sd_event_source* eventSource = nullptr;
-
-    // Add a Timer Object
-    Timer timer;
-
-    // Gets called as part of each TEST_F construction
-    TimerTest() : rc(sd_event_default(&events)), timer(events)
-    {
-        // Check for successful creation of
-        // event handler and timer object.
-        EXPECT_GE(rc, 0);
-    }
-
-    // Gets called as part of each TEST_F destruction
-    ~TimerTest() override
-    {
-        events = sd_event_unref(events);
-    }
-};
-
-class TimerTestCallBack : public ::testing::Test
-{
-  public:
-    // systemd event handler
-    sd_event* events;
-
-    // Need this so that events can be initialized.
-    int rc;
-
-    // Source of event
-    sd_event_source* eventSource = nullptr;
-
-    // Add a Timer Object
-    std::unique_ptr<Timer> timer = nullptr;
-
-    // Indicates optional call back fun was called
-    bool callBackDone = false;
-
-    void callBack()
-    {
-        callBackDone = true;
-    }
-
-    // Gets called as part of each TEST_F construction
-    TimerTestCallBack() : rc(sd_event_default(&events))
-
-    {
-        // Check for successful creation of
-        // event handler and timer object.
-        EXPECT_GE(rc, 0);
-
-        std::function<void()> func(
-            std::bind(&TimerTestCallBack::callBack, this));
-        timer = std::make_unique<Timer>(events, func);
-    }
-
-    // Gets called as part of each TEST_F destruction
-    ~TimerTestCallBack() override
-    {
-        events = sd_event_unref(events);
-    }
-};
-
-/** @brief Makes sure that timer is expired and the
- *  callback handler gets invoked post 2 seconds
- */
-TEST_F(TimerTest, timerExpiresAfter2seconds)
-{
-    using namespace std::chrono;
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    EXPECT_GE(timer.start(time), 0);
-
-    // Waiting 2 seconds is enough here since we have
-    // already spent some usec now
-    int count = 0;
-    while (count < 2 && !timer.isExpired())
-    {
-        // Returns -0- on timeout and positive number on dispatch
-        auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if (!sd_event_run(events, sleepTime.count()))
-        {
-            count++;
-        }
-    }
-    EXPECT_EQ(true, timer.isExpired());
-    EXPECT_EQ(1, count);
-}
-
-/** @brief Makes sure that timer is not expired
- */
-TEST_F(TimerTest, timerNotExpiredAfter2Seconds)
-{
-    using namespace std::chrono;
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    EXPECT_GE(timer.start(time), 0);
-
-    // Now turn off the timer post a 1 second sleep
-    sleep(1);
-    EXPECT_GE(timer.stop(), 0);
-
-    // Wait 2 seconds and see that timer is not expired
-    int count = 0;
-    while (count < 2)
-    {
-        // Returns -0- on timeout
-        auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if (!sd_event_run(events, sleepTime.count()))
-        {
-            count++;
-        }
-    }
-    EXPECT_EQ(false, timer.isExpired());
-
-    // 2 because of one more count that happens prior to exiting
-    EXPECT_EQ(2, count);
-}
-
-/** @brief Makes sure that timer value is changed in between
- *  and that the new timer expires
- */
-TEST_F(TimerTest, updateTimerAndExpectExpire)
-{
-    using namespace std::chrono;
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    EXPECT_GE(timer.start(time), 0);
-
-    // Now sleep for a second and then set the new timeout value
-    sleep(1);
-
-    // New timeout is 3 seconds from THIS point.
-    time = duration_cast<microseconds>(seconds(3));
-    EXPECT_GE(timer.start(time), 0);
-
-    // Wait 3 seconds and see that timer is expired
-    int count = 0;
-    while (count < 3 && !timer.isExpired())
-    {
-        // Returns -0- on timeout
-        auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if (!sd_event_run(events, sleepTime.count()))
-        {
-            count++;
-        }
-    }
-    EXPECT_EQ(true, timer.isExpired());
-    EXPECT_EQ(2, count);
-}
-
-/** @brief Makes sure that timer value is changed in between
- *  and turn off and make sure that timer does not expire
- */
-TEST_F(TimerTest, updateTimerAndNeverExpire)
-{
-    using namespace std::chrono;
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    EXPECT_GE(timer.start(time), 0);
-
-    // Now sleep for a second and then set the new timeout value
-    sleep(1);
-
-    // New timeout is 2 seconds from THIS point.
-    time = duration_cast<microseconds>(seconds(2));
-    EXPECT_GE(timer.start(time), 0);
-
-    // Now turn off the timer post a 1 second sleep
-    sleep(1);
-    EXPECT_GE(timer.stop(), 0);
-
-    // Wait 2 seconds and see that timer is expired
-    int count = 0;
-    while (count < 2)
-    {
-        // Returns -0- on timeout
-        auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if (!sd_event_run(events, sleepTime.count()))
-        {
-            count++;
-        }
-    }
-    EXPECT_EQ(false, timer.isExpired());
-
-    // 2 because of one more count that happens prior to exiting
-    EXPECT_EQ(2, count);
-}
-
-/** @brief Makes sure that optional callback is called */
-TEST_F(TimerTestCallBack, optionalFuncCallBackDone)
-{
-    using namespace std::chrono;
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    EXPECT_GE(timer->start(time), 0);
-
-    // Waiting 2 seconds is enough here since we have
-    // already spent some usec now
-    int count = 0;
-    while (count < 2 && !timer->isExpired())
-    {
-        // Returns -0- on timeout and positive number on dispatch
-        auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if (!sd_event_run(events, sleepTime.count()))
-        {
-            count++;
-        }
-    }
-    EXPECT_EQ(true, timer->isExpired());
-    EXPECT_EQ(true, callBackDone);
-    EXPECT_EQ(1, count);
-}
-
-/** @brief Makes sure that timer is not expired
- */
-TEST_F(TimerTestCallBack, timerNotExpiredAfter2SecondsNoOptionalCallBack)
-{
-    using namespace std::chrono;
-
-    auto time = duration_cast<microseconds>(seconds(2));
-    EXPECT_GE(timer->start(time), 0);
-
-    // Now turn off the timer post a 1 second sleep
-    sleep(1);
-    EXPECT_GE(timer->stop(), 0);
-
-    // Wait 2 seconds and see that timer is not expired
-    int count = 0;
-    while (count < 2)
-    {
-        // Returns -0- on timeout
-        auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if (!sd_event_run(events, sleepTime.count()))
-        {
-            count++;
-        }
-    }
-    EXPECT_EQ(false, timer->isExpired());
-    EXPECT_EQ(false, callBackDone);
-
-    // 2 because of one more count that happens prior to exiting
-    EXPECT_EQ(2, count);
-}
diff --git a/test/timer/meson.build b/test/timer/meson.build
new file mode 100644
index 0000000..be9432a
--- /dev/null
+++ b/test/timer/meson.build
@@ -0,0 +1,19 @@
+timer_tests = [
+    'timer_callback_done',
+    'timer_callback_not_done',
+    'timer_expire',
+    'timer_not_expire',
+    'timer_update_expire',
+    'timer_update_not_expire',
+]
+
+foreach t : timer_tests
+    test(
+        'test_' + t.underscorify(),
+        executable(
+            'test-' + t.underscorify(),
+            t + '.cpp',
+            dependencies: [gtest_dep, gmock_dep, sdbusplus_dep],
+        ),
+    )
+endforeach
diff --git a/test/timer/suite.hpp b/test/timer/suite.hpp
new file mode 100644
index 0000000..868c5e5
--- /dev/null
+++ b/test/timer/suite.hpp
@@ -0,0 +1,80 @@
+#pragma once
+
+#include <sdbusplus/timer.hpp>
+
+#include <gtest/gtest.h>
+
+using sdbusplus::Timer;
+
+class TimerTest : public ::testing::Test
+{
+  public:
+    // systemd event handler
+    sd_event* events = nullptr;
+
+    // Need this so that events can be initialized.
+    int rc;
+
+    // Source of event
+    sd_event_source* eventSource = nullptr;
+
+    // Add a Timer Object
+    Timer timer;
+
+    // Gets called as part of each TEST_F construction
+    TimerTest() : rc(sd_event_default(&events)), timer(events)
+    {
+        // Check for successful creation of
+        // event handler and timer object.
+        EXPECT_GE(rc, 0);
+    }
+
+    // Gets called as part of each TEST_F destruction
+    ~TimerTest() override
+    {
+        events = sd_event_unref(events);
+    }
+};
+
+class TimerTestCallBack : public ::testing::Test
+{
+  public:
+    // systemd event handler
+    sd_event* events;
+
+    // Need this so that events can be initialized.
+    int rc;
+
+    // Source of event
+    sd_event_source* eventSource = nullptr;
+
+    // Add a Timer Object
+    std::unique_ptr<Timer> timer = nullptr;
+
+    // Indicates optional call back fun was called
+    bool callBackDone = false;
+
+    void callBack()
+    {
+        callBackDone = true;
+    }
+
+    // Gets called as part of each TEST_F construction
+    TimerTestCallBack() : rc(sd_event_default(&events))
+
+    {
+        // Check for successful creation of
+        // event handler and timer object.
+        EXPECT_GE(rc, 0);
+
+        std::function<void()> func(
+            std::bind(&TimerTestCallBack::callBack, this));
+        timer = std::make_unique<Timer>(events, func);
+    }
+
+    // Gets called as part of each TEST_F destruction
+    ~TimerTestCallBack() override
+    {
+        events = sd_event_unref(events);
+    }
+};
diff --git a/test/timer/timer_callback_done.cpp b/test/timer/timer_callback_done.cpp
new file mode 100644
index 0000000..29ab72b
--- /dev/null
+++ b/test/timer/timer_callback_done.cpp
@@ -0,0 +1,32 @@
+#include "suite.hpp"
+
+#include <sdbusplus/timer.hpp>
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+/** @brief Makes sure that optional callback is called */
+TEST_F(TimerTestCallBack, optionalFuncCallBackDone)
+{
+    using namespace std::chrono;
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    EXPECT_GE(timer->start(time), 0);
+
+    // Waiting 2 seconds is enough here since we have
+    // already spent some usec now
+    int count = 0;
+    while (count < 2 && !timer->isExpired())
+    {
+        // Returns -0- on timeout and positive number on dispatch
+        auto sleepTime = duration_cast<microseconds>(seconds(1));
+        if (!sd_event_run(events, sleepTime.count()))
+        {
+            count++;
+        }
+    }
+    EXPECT_EQ(true, timer->isExpired());
+    EXPECT_EQ(true, callBackDone);
+    EXPECT_EQ(1, count);
+}
diff --git a/test/timer/timer_callback_not_done.cpp b/test/timer/timer_callback_not_done.cpp
new file mode 100644
index 0000000..a74f600
--- /dev/null
+++ b/test/timer/timer_callback_not_done.cpp
@@ -0,0 +1,38 @@
+#include "suite.hpp"
+
+#include <sdbusplus/timer.hpp>
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+/** @brief Makes sure that timer is not expired
+ */
+TEST_F(TimerTestCallBack, timerNotExpiredAfter2SecondsNoOptionalCallBack)
+{
+    using namespace std::chrono;
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    EXPECT_GE(timer->start(time), 0);
+
+    // Now turn off the timer post a 1 second sleep
+    sleep(1);
+    EXPECT_GE(timer->stop(), 0);
+
+    // Wait 2 seconds and see that timer is not expired
+    int count = 0;
+    while (count < 2)
+    {
+        // Returns -0- on timeout
+        auto sleepTime = duration_cast<microseconds>(seconds(1));
+        if (!sd_event_run(events, sleepTime.count()))
+        {
+            count++;
+        }
+    }
+    EXPECT_EQ(false, timer->isExpired());
+    EXPECT_EQ(false, callBackDone);
+
+    // 2 because of one more count that happens prior to exiting
+    EXPECT_EQ(2, count);
+}
diff --git a/test/timer/timer_expire.cpp b/test/timer/timer_expire.cpp
new file mode 100644
index 0000000..f84b4ed
--- /dev/null
+++ b/test/timer/timer_expire.cpp
@@ -0,0 +1,33 @@
+#include "suite.hpp"
+
+#include <sdbusplus/timer.hpp>
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+/** @brief Makes sure that timer is expired and the
+ *  callback handler gets invoked post 2 seconds
+ */
+TEST_F(TimerTest, timerExpiresAfter2seconds)
+{
+    using namespace std::chrono;
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    EXPECT_GE(timer.start(time), 0);
+
+    // Waiting 2 seconds is enough here since we have
+    // already spent some usec now
+    int count = 0;
+    while (count < 2 && !timer.isExpired())
+    {
+        // Returns -0- on timeout and positive number on dispatch
+        auto sleepTime = duration_cast<microseconds>(seconds(1));
+        if (!sd_event_run(events, sleepTime.count()))
+        {
+            count++;
+        }
+    }
+    EXPECT_EQ(true, timer.isExpired());
+    EXPECT_EQ(1, count);
+}
diff --git a/test/timer/timer_not_expire.cpp b/test/timer/timer_not_expire.cpp
new file mode 100644
index 0000000..5503d0a
--- /dev/null
+++ b/test/timer/timer_not_expire.cpp
@@ -0,0 +1,37 @@
+#include "suite.hpp"
+
+#include <sdbusplus/timer.hpp>
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+/** @brief Makes sure that timer is not expired
+ */
+TEST_F(TimerTest, timerNotExpiredAfter2Seconds)
+{
+    using namespace std::chrono;
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    EXPECT_GE(timer.start(time), 0);
+
+    // Now turn off the timer post a 1 second sleep
+    sleep(1);
+    EXPECT_GE(timer.stop(), 0);
+
+    // Wait 2 seconds and see that timer is not expired
+    int count = 0;
+    while (count < 2)
+    {
+        // Returns -0- on timeout
+        auto sleepTime = duration_cast<microseconds>(seconds(1));
+        if (!sd_event_run(events, sleepTime.count()))
+        {
+            count++;
+        }
+    }
+    EXPECT_EQ(false, timer.isExpired());
+
+    // 2 because of one more count that happens prior to exiting
+    EXPECT_EQ(2, count);
+}
diff --git a/test/timer/timer_update_expire.cpp b/test/timer/timer_update_expire.cpp
new file mode 100644
index 0000000..47a4fa6
--- /dev/null
+++ b/test/timer/timer_update_expire.cpp
@@ -0,0 +1,39 @@
+#include "suite.hpp"
+
+#include <sdbusplus/timer.hpp>
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+/** @brief Makes sure that timer value is changed in between
+ *  and that the new timer expires
+ */
+TEST_F(TimerTest, updateTimerAndExpectExpire)
+{
+    using namespace std::chrono;
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    EXPECT_GE(timer.start(time), 0);
+
+    // Now sleep for a second and then set the new timeout value
+    sleep(1);
+
+    // New timeout is 3 seconds from THIS point.
+    time = duration_cast<microseconds>(seconds(3));
+    EXPECT_GE(timer.start(time), 0);
+
+    // Wait 3 seconds and see that timer is expired
+    int count = 0;
+    while (count < 3 && !timer.isExpired())
+    {
+        // Returns -0- on timeout
+        auto sleepTime = duration_cast<microseconds>(seconds(1));
+        if (!sd_event_run(events, sleepTime.count()))
+        {
+            count++;
+        }
+    }
+    EXPECT_EQ(true, timer.isExpired());
+    EXPECT_EQ(2, count);
+}
diff --git a/test/timer/timer_update_not_expire.cpp b/test/timer/timer_update_not_expire.cpp
new file mode 100644
index 0000000..b6e9fc2
--- /dev/null
+++ b/test/timer/timer_update_not_expire.cpp
@@ -0,0 +1,45 @@
+#include "suite.hpp"
+
+#include <sdbusplus/timer.hpp>
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+/** @brief Makes sure that timer value is changed in between
+ *  and turn off and make sure that timer does not expire
+ */
+TEST_F(TimerTest, updateTimerAndNeverExpire)
+{
+    using namespace std::chrono;
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    EXPECT_GE(timer.start(time), 0);
+
+    // Now sleep for a second and then set the new timeout value
+    sleep(1);
+
+    // New timeout is 2 seconds from THIS point.
+    time = duration_cast<microseconds>(seconds(2));
+    EXPECT_GE(timer.start(time), 0);
+
+    // Now turn off the timer post a 1 second sleep
+    sleep(1);
+    EXPECT_GE(timer.stop(), 0);
+
+    // Wait 2 seconds and see that timer is expired
+    int count = 0;
+    while (count < 2)
+    {
+        // Returns -0- on timeout
+        auto sleepTime = duration_cast<microseconds>(seconds(1));
+        if (!sd_event_run(events, sleepTime.count()))
+        {
+            count++;
+        }
+    }
+    EXPECT_EQ(false, timer.isExpired());
+
+    // 2 because of one more count that happens prior to exiting
+    EXPECT_EQ(2, count);
+}