diff --git a/test/async/fdio_timed.cpp b/test/async/fdio_timed.cpp
new file mode 100644
index 0000000..85c93b6
--- /dev/null
+++ b/test/async/fdio_timed.cpp
@@ -0,0 +1,179 @@
+#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);
+}