diff --git a/libpldm/base.h b/libpldm/base.h
index d30a300..0738046 100644
--- a/libpldm/base.h
+++ b/libpldm/base.h
@@ -17,6 +17,7 @@
 	PLDM_BASE = 0x00,
 	PLDM_PLATFORM = 0x02,
 	PLDM_BIOS = 0x03,
+	PLDM_FRU = 0x04,
 	PLDM_OEM = 0x3F,
 };
 
diff --git a/libpldm/fru.c b/libpldm/fru.c
new file mode 100644
index 0000000..79fd9f7
--- /dev/null
+++ b/libpldm/fru.c
@@ -0,0 +1,101 @@
+#include <endian.h>
+#include <string.h>
+
+#include "fru.h"
+
+int encode_get_fru_record_table_metadata_req(uint8_t instance_id,
+					     struct pldm_msg *msg)
+{
+	if (msg == NULL) {
+		return PLDM_ERROR_INVALID_DATA;
+	}
+
+	struct pldm_header_info header = {0};
+	header.instance = instance_id;
+	header.msg_type = PLDM_REQUEST;
+	header.pldm_type = PLDM_FRU;
+	header.command = PLDM_GET_FRU_RECORD_TABLE_METADATA;
+	int rc = pack_pldm_header(&header, &(msg->hdr));
+	if (PLDM_SUCCESS != rc) {
+		return rc;
+	}
+	return PLDM_SUCCESS;
+}
+
+int decode_get_fru_record_table_metadata_resp(
+    const struct pldm_msg *msg, size_t payload_length, uint8_t *completion_code,
+    uint8_t *fru_data_major_version, uint8_t *fru_data_minor_version,
+    uint32_t *fru_table_maximum_size, uint32_t *fru_table_length,
+    uint16_t *total_record_set_identifiers, uint16_t *total_table_records,
+    uint32_t *checksum)
+{
+	if (msg == NULL || completion_code == NULL ||
+	    fru_data_major_version == NULL || fru_data_minor_version == NULL ||
+	    fru_table_maximum_size == NULL || fru_table_length == NULL ||
+	    total_record_set_identifiers == NULL ||
+	    total_table_records == NULL || checksum == NULL) {
+		return PLDM_ERROR_INVALID_DATA;
+	}
+
+	if (payload_length != PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	struct pldm_get_fru_record_table_metadata_resp *response =
+	    (struct pldm_get_fru_record_table_metadata_resp *)msg->payload;
+	*completion_code = response->completion_code;
+	if (PLDM_SUCCESS != *completion_code) {
+		return PLDM_SUCCESS;
+	};
+
+	*fru_data_major_version = response->fru_data_major_version;
+	*fru_data_minor_version = response->fru_data_minor_version;
+	*fru_table_maximum_size = le32toh(response->fru_table_maximum_size);
+	*fru_table_length = le32toh(response->fru_table_length);
+	*total_record_set_identifiers =
+	    le16toh(response->total_record_set_identifiers);
+	*total_table_records = le16toh(response->total_table_records);
+	*checksum = le32toh(response->checksum);
+
+	return PLDM_SUCCESS;
+}
+
+int encode_get_fru_record_table_metadata_resp(
+    uint8_t instance_id, uint8_t completion_code,
+    uint8_t fru_data_major_version, uint8_t fru_data_minor_version,
+    uint32_t fru_table_maximum_size, uint32_t fru_table_length,
+    uint16_t total_record_set_identifiers, uint16_t total_table_records,
+    uint32_t checksum, struct pldm_msg *msg)
+{
+
+	if (msg == NULL) {
+		return PLDM_ERROR_INVALID_DATA;
+	}
+
+	struct pldm_header_info header = {0};
+	header.msg_type = PLDM_RESPONSE;
+	header.instance = instance_id;
+	header.pldm_type = PLDM_FRU;
+	header.command = PLDM_GET_FRU_RECORD_TABLE_METADATA;
+	int rc = pack_pldm_header(&header, &(msg->hdr));
+	if (PLDM_SUCCESS != rc) {
+		return rc;
+	}
+
+	struct pldm_get_fru_record_table_metadata_resp *response =
+	    (struct pldm_get_fru_record_table_metadata_resp *)msg->payload;
+	response->completion_code = completion_code;
+	if (response->completion_code == PLDM_SUCCESS) {
+		response->fru_data_major_version = fru_data_major_version;
+		response->fru_data_minor_version = fru_data_minor_version;
+		response->fru_table_maximum_size =
+		    htole32(fru_table_maximum_size);
+		response->fru_table_length = htole32(fru_table_length);
+		response->total_record_set_identifiers =
+		    htole16(total_record_set_identifiers);
+		response->total_table_records = htole16(total_table_records);
+		response->checksum = htole32(checksum);
+	}
+
+	return PLDM_SUCCESS;
+}
diff --git a/libpldm/fru.h b/libpldm/fru.h
new file mode 100644
index 0000000..e5b3fa9
--- /dev/null
+++ b/libpldm/fru.h
@@ -0,0 +1,111 @@
+#ifndef FRU_H
+#define FRU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <asm/byteorder.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base.h"
+
+#define PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES 19
+
+/** @brief PLDM FRU commands
+ */
+enum pldm_fru_commands {
+	PLDM_GET_FRU_RECORD_TABLE_METADATA = 0X01,
+};
+
+/** @struct pldm_get_fru_record_table_metadata_resp
+ *
+ *  Structure representing PLDM get FRU table metadata response.
+ */
+struct pldm_get_fru_record_table_metadata_resp {
+	uint8_t completion_code;	//!< completion code
+	uint8_t fru_data_major_version; //!< The major version of the FRU Record
+	uint8_t fru_data_minor_version; //!< The minor version of the FRU Record
+	uint32_t
+	    fru_table_maximum_size; //!< The size of the largest FRU Record data
+	uint32_t fru_table_length; //!< The total length of the FRU Record Table
+	uint16_t total_record_set_identifiers; //!< The total number of FRU
+					       //!< Record Data structures
+	uint16_t
+	    total_table_records; //!< The total number of records in the table
+	uint32_t
+	    checksum; //!< The integrity checksum on the FRU Record Table data
+} __attribute__((packed));
+
+/* Requester */
+
+/* GetFRURecordTableMetadata */
+
+/** @brief Create a PLDM request message for GetFRURecordTableMetadata
+ *
+ *  @param[in] instance_id - Message's instance id
+ *  @param[in,out] msg - Message will be written to this
+ *  @return pldm_completion_codes
+ *  @note  Caller is responsible for memory alloc and dealloc of param
+ *         'msg.payload'
+ */
+int encode_get_fru_record_table_metadata_req(uint8_t instance_id,
+					     struct pldm_msg *msg);
+
+/** @brief Decode GetFruRecordTable response data
+ *
+ *  @param[in] msg - Response message
+ *  @param[in] payload_length - Length of response message payload
+ *  @param[out] completion_code - Pointer to response msg's PLDM completion code
+ *  @param[out] fru_data_major_version - Major version of the FRU Record
+ *  @param[out] fru_data_minor_version - Minor version of the FRU Record
+ *  @param[out] fru_table_maximum_size - Size of the largest FRU Record data
+ *  @param[out] fru_table_length - Total length of the FRU Record Table
+ *  @param[out] total_Record_Set_Identifiers - Total number of FRU Record Data
+ * structures
+ *  @param[out] total_table_records - Total number of records in the table
+ *  @param[out] checksum - integrity checksum on the FRU Record Table data
+ *  @return pldm_completion_codes
+ */
+int decode_get_fru_record_table_metadata_resp(
+    const struct pldm_msg *msg, size_t payload_length, uint8_t *completion_code,
+    uint8_t *fru_data_major_version, uint8_t *fru_data_minor_version,
+    uint32_t *fru_table_maximum_size, uint32_t *fru_table_length,
+    uint16_t *total_record_set_identifiers, uint16_t *total_table_records,
+    uint32_t *checksum);
+
+/* Responder */
+
+/* GetFRURecordTableMetadata */
+
+/** @brief Create a PLDM response message for GetFRURecordTableMetadata
+ *
+ *  @param[in] instance_id - Message's instance id
+ *  @param[in] completion_code - PLDM completion code
+ *  @param[in] fru_data_major_version - Major version of the FRU Record
+ *  @param[in] fru_data_minor_version - Minor version of the FRU Record
+ *  @param[in] fru_table_maximum_size - Size of the largest FRU Record data
+ *  @param[in] fru_table_length - Total length of the FRU Record Table
+ *  @param[in] total_Record_Set_Identifiers - Total number of FRU Record Data
+ * structures
+ *  @param[in] total_table_records - Total number of records in the table
+ *  @param[in] checksum - integrity checksum on the FRU Record Table data
+ *  @param[in,out] msg - Message will be written to this
+ *  @return pldm_completion_codes
+ *  @note  Caller is responsible for memory alloc and dealloc of param
+ *         'msg.payload'
+ */
+
+int encode_get_fru_record_table_metadata_resp(
+    uint8_t instance_id, uint8_t completion_code,
+    uint8_t fru_data_major_version, uint8_t fru_data_minor_version,
+    uint32_t fru_table_maximum_size, uint32_t fru_table_length,
+    uint16_t total_record_set_identifiers, uint16_t total_table_records,
+    uint32_t checksum, struct pldm_msg *msg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libpldm/meson.build b/libpldm/meson.build
index fb2fcf6..14a90a1 100644
--- a/libpldm/meson.build
+++ b/libpldm/meson.build
@@ -4,12 +4,14 @@
   'platform.h',
   'bios.h',
   'states.h',
+  'fru.h',
 ]
 
 sources = [
   'base.c',
   'platform.c',
-  'bios.c'
+  'bios.c',
+  'fru.c',
 ]
 
 libpldm_headers = ['.', '..']
diff --git a/test/libpldm_fru_test.cpp b/test/libpldm_fru_test.cpp
new file mode 100644
index 0000000..c6a4420
--- /dev/null
+++ b/test/libpldm_fru_test.cpp
@@ -0,0 +1,291 @@
+#include <string.h>
+
+#include <array>
+
+#include "libpldm/base.h"
+#include "libpldm/fru.h"
+
+#include <gtest/gtest.h>
+
+TEST(GetFruRecordTableMetadata, testGoodEncodeRequest)
+{
+    std::array<uint8_t, sizeof(pldm_msg_hdr)> requestMsg{};
+    auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
+    auto rc = encode_get_fru_record_table_metadata_req(0, requestPtr);
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(requestPtr->hdr.request, PLDM_REQUEST);
+    ASSERT_EQ(requestPtr->hdr.instance_id, 0);
+    ASSERT_EQ(requestPtr->hdr.type, PLDM_FRU);
+    ASSERT_EQ(requestPtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
+}
+
+TEST(GetFruRecordTableMetadata, testBadEncodeRequest)
+{
+    auto rc = encode_get_fru_record_table_metadata_req(0, NULL);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+}
+
+TEST(GetFruRecordTableMetadata, testGoodDecodeResponse)
+{
+
+    std::vector<uint8_t> responseMsg(
+        sizeof(pldm_msg_hdr) + PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
+    size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
+    auto response = reinterpret_cast<pldm_get_fru_record_table_metadata_resp*>(
+        responsePtr->payload);
+
+    responsePtr->hdr.request = PLDM_RESPONSE;
+    responsePtr->hdr.instance_id = 0;
+    responsePtr->hdr.type = PLDM_FRU;
+    responsePtr->hdr.command = PLDM_GET_FRU_RECORD_TABLE_METADATA;
+    response->completion_code = PLDM_SUCCESS;
+    response->fru_data_major_version = 0x12;
+    response->fru_data_minor_version = 0x21;
+    response->fru_table_maximum_size = 0x1234ABCD;
+    response->fru_table_length = 0x56781234;
+    response->total_record_set_identifiers = 0x34EF;
+    response->total_table_records = 0xEEEF;
+    response->checksum = 0x6543FA71;
+
+    uint8_t completion_code = 0xFF;
+    uint8_t fru_data_major_version = 0x00;
+    uint8_t fru_data_minor_version = 0x00;
+    uint32_t fru_table_maximum_size = 0x00000000;
+    uint32_t fru_table_length = 0x00000000;
+    uint16_t total_record_set_identifiers = 0x0000;
+    uint16_t total_table_records = 0x0000;
+    uint32_t checksum = 0x00000000;
+
+    auto rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        &fru_data_minor_version, &fru_table_maximum_size, &fru_table_length,
+        &total_record_set_identifiers, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(completion_code, PLDM_SUCCESS);
+    ASSERT_EQ(fru_data_major_version, 0x12);
+    ASSERT_EQ(fru_data_minor_version, 0x21);
+    ASSERT_EQ(fru_table_maximum_size, 0x1234ABCD);
+    ASSERT_EQ(fru_table_length, 0x56781234);
+    ASSERT_EQ(total_record_set_identifiers, 0x34EF);
+    ASSERT_EQ(total_table_records, 0xEEEF);
+    ASSERT_EQ(checksum, 0x6543FA71);
+
+    response->fru_data_major_version = 0x00;
+    response->fru_data_minor_version = 0x00;
+    response->fru_table_maximum_size = 0x00000000;
+    response->fru_table_length = 0x00000000;
+    response->total_record_set_identifiers = 0x0000;
+    response->total_table_records = 0x0000;
+    response->checksum = 0x00000000;
+    fru_data_major_version = 0x00;
+    fru_data_minor_version = 0x00;
+    fru_table_maximum_size = 0x00000000;
+    fru_table_length = 0x00000000;
+    total_record_set_identifiers = 0x0000;
+    total_table_records = 0x0000;
+    checksum = 0x00000000;
+    response->completion_code = PLDM_ERROR_INVALID_LENGTH;
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        &fru_data_minor_version, &fru_table_maximum_size, &fru_table_length,
+        &total_record_set_identifiers, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
+    ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
+    ASSERT_EQ(completion_code, PLDM_ERROR_INVALID_LENGTH);
+    ASSERT_EQ(fru_data_major_version, 0x00);
+    ASSERT_EQ(fru_data_minor_version, 0x00);
+    ASSERT_EQ(fru_table_maximum_size, 0x00000000);
+    ASSERT_EQ(fru_table_length, 0x00000000);
+    ASSERT_EQ(total_record_set_identifiers, 0x0000);
+    ASSERT_EQ(total_table_records, 0x0000);
+    ASSERT_EQ(checksum, 0x00000000);
+}
+
+TEST(GetFruRecordTableMetadata, testBadDecodeResponse)
+{
+    std::vector<uint8_t> responseMsg(
+        sizeof(pldm_msg_hdr) + PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
+    size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
+    auto response = reinterpret_cast<pldm_get_fru_record_table_metadata_resp*>(
+        responsePtr->payload);
+
+    response->completion_code = PLDM_SUCCESS;
+    response->fru_data_major_version = 0x12;
+    response->fru_data_minor_version = 0x21;
+    response->fru_table_maximum_size = 0x1234ABCD;
+    response->fru_table_length = 0x56781234;
+    response->total_record_set_identifiers = 0x34EF;
+    response->total_table_records = 0xEEEF;
+    response->checksum = 0x6543FA71;
+
+    uint8_t completion_code = 0xFF;
+    uint8_t fru_data_major_version = 0x00;
+    uint8_t fru_data_minor_version = 0x00;
+    uint32_t fru_table_maximum_size = 0x00000000;
+    uint32_t fru_table_length = 0x00000000;
+    uint16_t total_record_set_identifiers = 0x0000;
+    uint16_t total_table_records = 0x0000;
+    uint32_t checksum = 0x00000000;
+
+    auto rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES + 2,
+        &completion_code, &fru_data_major_version, &fru_data_minor_version,
+        &fru_table_maximum_size, &fru_table_length,
+        &total_record_set_identifiers, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, NULL,
+        &fru_data_minor_version, &fru_table_maximum_size, &fru_table_length,
+        &total_record_set_identifiers, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        NULL, &fru_table_maximum_size, &fru_table_length,
+        &total_record_set_identifiers, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        &fru_data_minor_version, NULL, &fru_table_length,
+        &total_record_set_identifiers, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        &fru_data_minor_version, &fru_table_maximum_size, NULL,
+        &total_record_set_identifiers, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        &fru_data_minor_version, &fru_table_maximum_size, &fru_table_length,
+        NULL, &total_table_records, &checksum);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        &fru_data_minor_version, &fru_table_maximum_size, &fru_table_length,
+        &total_record_set_identifiers, NULL, &checksum);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+    rc = decode_get_fru_record_table_metadata_resp(
+        responsePtr, payload_length, &completion_code, &fru_data_major_version,
+        &fru_data_minor_version, &fru_table_maximum_size, &fru_table_length,
+        &total_record_set_identifiers, &total_table_records, NULL);
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+}
+
+TEST(GetFruRecordTableMetadata, testGoodEncodeResponse)
+{
+
+    std::array<uint8_t, sizeof(pldm_msg_hdr) +
+                            PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES>
+        responseMsg{};
+    auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    responsePtr->hdr.request = PLDM_RESPONSE;
+    responsePtr->hdr.instance_id = 0;
+    responsePtr->hdr.type = PLDM_FRU;
+    responsePtr->hdr.command = PLDM_GET_FRU_RECORD_TABLE_METADATA;
+
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint8_t fru_data_major_version = 0x12;
+    uint8_t fru_data_minor_version = 0x21;
+    uint32_t fru_table_maximum_size = 0x1234ABCD;
+    uint32_t fru_table_length = 0x56781234;
+    uint16_t total_record_set_identifiers = 0x34EF;
+    uint16_t total_table_records = 0xEEEF;
+    uint32_t checksum = 0x6543FA71;
+
+    auto rc = encode_get_fru_record_table_metadata_resp(
+        0, completion_code, fru_data_major_version, fru_data_minor_version,
+        fru_table_maximum_size, fru_table_length, total_record_set_identifiers,
+        total_table_records, checksum, responsePtr);
+
+    auto response = reinterpret_cast<pldm_get_fru_record_table_metadata_resp*>(
+        responsePtr->payload);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
+    ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
+    ASSERT_EQ(response->completion_code, PLDM_SUCCESS);
+    ASSERT_EQ(response->fru_data_major_version, 0x12);
+    ASSERT_EQ(response->fru_data_minor_version, 0x21);
+    ASSERT_EQ(response->fru_table_maximum_size, 0x1234ABCD);
+    ASSERT_EQ(response->fru_table_length, 0x56781234);
+    ASSERT_EQ(response->total_record_set_identifiers, 0x34EF);
+    ASSERT_EQ(response->total_table_records, 0xEEEF);
+    ASSERT_EQ(response->checksum, 0x6543FA71);
+
+    response->fru_data_major_version = 0;
+    response->fru_data_major_version = 0x00;
+    response->fru_data_minor_version = 0x00;
+    response->fru_table_maximum_size = 0x00000000;
+    response->fru_table_length = 0x00000000;
+    response->total_record_set_identifiers = 0x0000;
+    response->total_table_records = 0x0000;
+    response->checksum = 0x00000000;
+    completion_code = PLDM_ERROR_INVALID_DATA;
+    rc = encode_get_fru_record_table_metadata_resp(
+        0, completion_code, fru_data_major_version, fru_data_minor_version,
+        fru_table_maximum_size, fru_table_length, total_record_set_identifiers,
+        total_table_records, checksum, responsePtr);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
+    ASSERT_EQ(responsePtr->hdr.instance_id, 0);
+    ASSERT_EQ(responsePtr->hdr.type, PLDM_FRU);
+    ASSERT_EQ(responsePtr->hdr.command, PLDM_GET_FRU_RECORD_TABLE_METADATA);
+    ASSERT_EQ(completion_code, PLDM_ERROR_INVALID_DATA);
+    ASSERT_EQ(response->fru_data_major_version, 0x00);
+    ASSERT_EQ(response->fru_data_minor_version, 0x00);
+    ASSERT_EQ(response->fru_table_maximum_size, 0x00000000);
+    ASSERT_EQ(response->fru_table_length, 0x00000000);
+    ASSERT_EQ(response->total_record_set_identifiers, 0x0000);
+    ASSERT_EQ(response->total_table_records, 0x0000);
+    ASSERT_EQ(response->checksum, 0x00000000);
+}
+
+TEST(GetFruRecordTableMetadata, testBadEncodeResponse)
+{
+    std::array<uint8_t, sizeof(pldm_msg_hdr) +
+                            PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES>
+        responseMsg{};
+    auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint8_t fru_data_major_version = 0x12;
+    uint8_t fru_data_minor_version = 0x21;
+    uint32_t fru_table_maximum_size = 0x1234ABCD;
+    uint32_t fru_table_length = 0x56781234;
+    uint16_t total_record_set_identifiers = 0x34EF;
+    uint16_t total_table_records = 0xEEEF;
+    uint32_t checksum = 0x6543FA71;
+
+    auto rc = encode_get_fru_record_table_metadata_resp(
+        0, completion_code, fru_data_major_version, fru_data_minor_version,
+        fru_table_maximum_size, fru_table_length, total_record_set_identifiers,
+        total_table_records, checksum, NULL);
+
+    auto response = reinterpret_cast<pldm_get_fru_record_table_metadata_resp*>(
+        responsePtr->payload);
+
+    ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+    ASSERT_EQ(completion_code, PLDM_SUCCESS);
+    ASSERT_EQ(response->fru_data_major_version, 0x00);
+    ASSERT_EQ(response->fru_data_minor_version, 0x00);
+    ASSERT_EQ(response->fru_table_maximum_size, 0x00000000);
+    ASSERT_EQ(response->fru_table_length, 0x00000000);
+    ASSERT_EQ(response->total_record_set_identifiers, 0x0000);
+    ASSERT_EQ(response->total_table_records, 0x0000);
+    ASSERT_EQ(response->checksum, 0x00000000);
+}
diff --git a/test/meson.build b/test/meson.build
index 5bfad27..895d587 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -23,7 +23,8 @@
   'libpldmresponder_bios_test',
   'libpldmresponder_pdr_state_effecter_test',
   'libpldmresponder_bios_table_test',
-  'libpldmresponder_platform_test'
+  'libpldmresponder_platform_test',
+  'libpldm_fru_test',
 ]
 
 if get_option('oem-ibm').enabled()