diff --git a/src/transport/meson.build b/src/transport/meson.build
index 511b1c4..b0ef1ca 100644
--- a/src/transport/meson.build
+++ b/src/transport/meson.build
@@ -2,5 +2,6 @@
   'af-mctp.c',
   'mctp-demux.c',
   'socket.c',
-  'transport.c'
+  'transport.c',
+  'test.c'
 )
diff --git a/src/transport/test.c b/src/transport/test.c
new file mode 100644
index 0000000..3d92111
--- /dev/null
+++ b/src/transport/test.c
@@ -0,0 +1,184 @@
+#include "container-of.h"
+#include "transport.h"
+#include "test.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+struct pldm_transport_test {
+	struct pldm_transport transport;
+	const struct pldm_transport_test_descriptor *seq;
+	size_t count;
+	size_t cursor;
+	int timerfd;
+};
+
+#define transport_to_test(ptr)                                                 \
+	container_of(ptr, struct pldm_transport_test, transport)
+
+LIBPLDM_ABI_TESTING
+struct pldm_transport *pldm_transport_test_core(struct pldm_transport_test *ctx)
+{
+	return &ctx->transport;
+}
+
+#ifdef PLDM_HAS_POLL
+#include <poll.h>
+LIBPLDM_ABI_TESTING
+int pldm_transport_test_init_pollfd(struct pldm_transport *ctx,
+				    struct pollfd *pollfd)
+{
+	static const struct itimerspec disable = {
+		.it_value = { 0, 0 },
+		.it_interval = { 0, 0 },
+	};
+	struct pldm_transport_test *test = transport_to_test(ctx);
+	const struct pldm_transport_test_descriptor *desc;
+	int rc;
+
+	rc = timerfd_settime(test->timerfd, 0, &disable, NULL);
+	if (rc < 0) {
+		return PLDM_REQUESTER_POLL_FAIL;
+	}
+
+	if (test->cursor >= test->count) {
+		return PLDM_REQUESTER_POLL_FAIL;
+	}
+
+	desc = &test->seq[test->cursor];
+
+	if (desc->type != PLDM_TRANSPORT_TEST_ELEMENT_LATENCY) {
+		return PLDM_REQUESTER_POLL_FAIL;
+	}
+
+	rc = timerfd_settime(test->timerfd, 0, &desc->latency, NULL);
+	if (rc < 0) {
+		return PLDM_REQUESTER_POLL_FAIL;
+	}
+
+	pollfd->fd = test->timerfd;
+	pollfd->events = POLLIN;
+
+	test->cursor++;
+
+	return 0;
+}
+#endif
+
+static pldm_requester_rc_t pldm_transport_test_recv(struct pldm_transport *ctx,
+						    pldm_tid_t tid,
+						    void **pldm_resp_msg,
+						    size_t *resp_msg_len)
+{
+	struct pldm_transport_test *test = transport_to_test(ctx);
+	const struct pldm_transport_test_descriptor *desc;
+	void *msg;
+
+	(void)tid;
+
+	if (test->cursor >= test->count) {
+		return PLDM_REQUESTER_RECV_FAIL;
+	}
+
+	desc = &test->seq[test->cursor];
+
+	if (desc->type != PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV) {
+		return PLDM_REQUESTER_RECV_FAIL;
+	}
+
+	msg = malloc(desc->recv_msg.len);
+	if (!msg) {
+		return PLDM_REQUESTER_RECV_FAIL;
+	}
+
+	memcpy(msg, desc->recv_msg.msg, desc->recv_msg.len);
+	*pldm_resp_msg = msg;
+	*resp_msg_len = desc->recv_msg.len;
+
+	test->cursor++;
+
+	return PLDM_REQUESTER_SUCCESS;
+}
+
+static pldm_requester_rc_t pldm_transport_test_send(struct pldm_transport *ctx,
+						    pldm_tid_t tid,
+						    const void *pldm_req_msg,
+						    size_t req_msg_len)
+{
+	struct pldm_transport_test *test = transport_to_test(ctx);
+	const struct pldm_transport_test_descriptor *desc;
+
+	if (test->cursor > test->count) {
+		return PLDM_REQUESTER_SEND_FAIL;
+	}
+
+	desc = &test->seq[test->cursor];
+
+	if (desc->type != PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND) {
+		return PLDM_REQUESTER_SEND_FAIL;
+	}
+
+	if (desc->send_msg.dst != tid) {
+		return PLDM_REQUESTER_SEND_FAIL;
+	}
+
+	if (desc->send_msg.len != req_msg_len) {
+		return PLDM_REQUESTER_SEND_FAIL;
+	}
+
+	if (memcmp(desc->send_msg.msg, pldm_req_msg, req_msg_len) != 0) {
+		return PLDM_REQUESTER_SEND_FAIL;
+	}
+
+	test->cursor++;
+
+	return PLDM_REQUESTER_SUCCESS;
+}
+
+LIBPLDM_ABI_TESTING
+int pldm_transport_test_init(struct pldm_transport_test **ctx,
+			     const struct pldm_transport_test_descriptor *seq,
+			     size_t count)
+{
+	int rc;
+
+	if (!ctx || *ctx) {
+		return -EINVAL;
+	}
+
+	struct pldm_transport_test *test = malloc(sizeof(*test));
+	if (!test) {
+		return -ENOMEM;
+	}
+
+	test->transport.name = "TEST";
+	test->transport.version = 1;
+	test->transport.recv = pldm_transport_test_recv;
+	test->transport.send = pldm_transport_test_send;
+	test->transport.init_pollfd = pldm_transport_test_init_pollfd;
+	test->seq = seq;
+	test->count = count;
+	test->cursor = 0;
+	test->timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
+	if (test->timerfd < 0) {
+		rc = -errno;
+		goto cleanup_test;
+	}
+
+	*ctx = test;
+
+	return 0;
+
+cleanup_test:
+	free(test);
+	return rc;
+}
+
+LIBPLDM_ABI_TESTING
+void pldm_transport_test_destroy(struct pldm_transport_test *ctx)
+{
+	close(ctx->timerfd);
+	free(ctx);
+}
diff --git a/src/transport/test.h b/src/transport/test.h
new file mode 100644
index 0000000..7a01527
--- /dev/null
+++ b/src/transport/test.h
@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
+#ifndef LIBPLDM_TRANSPORT_TEST_H
+#define LIBPLDM_TRANSPORT_TEST_H
+
+#include "libpldm/base.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/timerfd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum pldm_transport_test_element {
+	PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
+	PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
+	PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
+};
+
+struct pldm_transport_test_msg_send {
+	pldm_tid_t dst;
+	const void *msg;
+	size_t len;
+};
+
+struct pldm_transport_test_msg_recv {
+	pldm_tid_t src;
+	const void *msg;
+	size_t len;
+};
+
+struct pldm_transport_test_descriptor {
+	enum pldm_transport_test_element type;
+	union {
+		struct pldm_transport_test_msg_send send_msg;
+		struct pldm_transport_test_msg_recv recv_msg;
+		struct itimerspec latency;
+	};
+};
+
+struct pldm_transport_test;
+
+int pldm_transport_test_init(struct pldm_transport_test **ctx,
+			     const struct pldm_transport_test_descriptor *seq,
+			     size_t count);
+void pldm_transport_test_destroy(struct pldm_transport_test *ctx);
+struct pldm_transport *
+pldm_transport_test_core(struct pldm_transport_test *ctx);
+
+#if PLDM_HAS_POLL
+struct pollfd;
+int pldm_transport_test_init_pollfd(struct pldm_transport *ctx,
+				    struct pollfd *pollfd);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/tests/meson.build b/tests/meson.build
index 834f19c..e9d88ec 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -24,6 +24,7 @@
   'libpldm_pdr_test',
   'libpldm_firmware_update_test',
   'msgbuf',
+  'transport',
 ]
 
 if get_option('oem-ibm').allowed()
diff --git a/tests/transport.cpp b/tests/transport.cpp
new file mode 100644
index 0000000..79b09e8
--- /dev/null
+++ b/tests/transport.cpp
@@ -0,0 +1,163 @@
+#include "libpldm/transport.h"
+
+#include "array.h"
+#include "transport/test.h"
+
+#include <gtest/gtest.h>
+
+#ifdef LIBPLDM_API_TESTING
+TEST(Transport, create)
+{
+    struct pldm_transport_test* test = NULL;
+
+    EXPECT_EQ(pldm_transport_test_init(&test, NULL, 0), 0);
+    EXPECT_NE(pldm_transport_test_core(test), nullptr);
+    pldm_transport_test_destroy(test);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(Transport, send_one)
+{
+    const uint8_t msg[] = {0x81, 0x00, 0x01, 0x01};
+    const struct pldm_transport_test_descriptor seq[] = {
+        {
+            .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
+            .send_msg =
+                {
+                    .dst = 1,
+                    .msg = msg,
+                    .len = sizeof(msg),
+                },
+        },
+    };
+    struct pldm_transport_test* test = NULL;
+    struct pldm_transport* ctx;
+    int rc;
+
+    EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
+    ctx = pldm_transport_test_core(test);
+    rc = pldm_transport_send_msg(ctx, 1, msg, sizeof(msg));
+    EXPECT_EQ(rc, PLDM_REQUESTER_SUCCESS);
+    pldm_transport_test_destroy(test);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(Transport, recv_one)
+{
+    uint8_t msg[] = {0x01, 0x00, 0x01, 0x00};
+    const struct pldm_transport_test_descriptor seq[] = {
+        {
+            .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
+            .recv_msg =
+                {
+                    .src = 1,
+                    .msg = msg,
+                    .len = sizeof(msg),
+                },
+        },
+    };
+    struct pldm_transport_test* test = NULL;
+    struct pldm_transport* ctx;
+    void* recvd;
+    size_t len;
+    int rc;
+
+    EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
+    ctx = pldm_transport_test_core(test);
+    rc = pldm_transport_recv_msg(ctx, 1, &recvd, &len);
+    EXPECT_EQ(rc, PLDM_REQUESTER_SUCCESS);
+    EXPECT_EQ(len, sizeof(msg));
+    EXPECT_EQ(memcmp(recvd, msg, len), 0);
+    free(recvd);
+    pldm_transport_test_destroy(test);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(Transport, send_recv_one)
+{
+    uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
+    uint8_t resp[] = {0x01, 0x00, 0x01, 0x00};
+    const struct pldm_transport_test_descriptor seq[] = {
+        {
+            .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
+            .send_msg =
+                {
+                    .dst = 1,
+                    .msg = req,
+                    .len = sizeof(req),
+                },
+        },
+        {
+            .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
+            .latency =
+                {
+                    .it_interval = {0, 0},
+                    .it_value = {1, 0},
+                },
+        },
+        {
+            .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
+            .recv_msg =
+                {
+                    .src = 1,
+                    .msg = resp,
+                    .len = sizeof(resp),
+                },
+        },
+    };
+    struct pldm_transport_test* test = NULL;
+    struct pldm_transport* ctx;
+    size_t len;
+    void* msg;
+    int rc;
+
+    EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
+    ctx = pldm_transport_test_core(test);
+    rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
+    EXPECT_EQ(rc, PLDM_REQUESTER_SUCCESS);
+    EXPECT_EQ(len, sizeof(resp));
+    EXPECT_EQ(memcmp(msg, resp, len), 0);
+    free(msg);
+    pldm_transport_test_destroy(test);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(Transport, send_recv_timeout)
+{
+    uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
+    const struct pldm_transport_test_descriptor seq[] = {
+        {
+            .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
+            .send_msg =
+                {
+                    .dst = 1,
+                    .msg = req,
+                    .len = sizeof(req),
+                },
+        },
+        {
+            .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
+            .latency =
+                {
+                    .it_interval = {0, 0},
+                    .it_value = {5, 0},
+                },
+        },
+    };
+    struct pldm_transport_test* test = NULL;
+    struct pldm_transport* ctx;
+    size_t len;
+    void* msg;
+    int rc;
+
+    EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
+    ctx = pldm_transport_test_core(test);
+    rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
+    EXPECT_EQ(rc, PLDM_REQUESTER_RECV_FAIL);
+    pldm_transport_test_destroy(test);
+}
+#endif