diff --git a/libpldm/bios_table.c b/libpldm/bios_table.c
index d9c2505..8782a16 100644
--- a/libpldm/bios_table.c
+++ b/libpldm/bios_table.c
@@ -110,6 +110,72 @@
 	       pldm_bios_table_string_entry_decode_string_length(entry);
 }
 
+static uint16_t get_bios_attr_handle()
+{
+	static uint16_t handle = 0;
+	assert(handle != UINT16_MAX);
+
+	return handle++;
+}
+
+static void attr_table_entry_encode_header(void *entry, size_t length,
+					   uint8_t attr_type,
+					   uint16_t string_handle)
+{
+	struct pldm_bios_attr_table_entry *attr_entry = entry;
+	assert(sizeof(*attr_entry) <= length);
+	attr_entry->attr_handle = htole16(get_bios_attr_handle());
+	attr_entry->attr_type = attr_type;
+	attr_entry->string_handle = htole16(string_handle);
+}
+
+size_t pldm_bios_table_attr_entry_enum_encode_length(uint8_t pv_num,
+						     uint8_t def_num)
+{
+	return sizeof(struct pldm_bios_attr_table_entry) -
+	       MEMBER_SIZE(pldm_bios_attr_table_entry, metadata) +
+	       sizeof(pv_num) + pv_num * sizeof(uint16_t) + sizeof(def_num) +
+	       def_num;
+}
+
+void pldm_bios_table_attr_entry_enum_encode(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_enum_info *info)
+{
+	size_t length = pldm_bios_table_attr_entry_enum_encode_length(
+	    info->pv_num, info->def_num);
+	assert(length <= entry_length);
+	uint8_t attr_type = info->read_only ? PLDM_BIOS_ENUMERATION_READ_ONLY
+					    : PLDM_BIOS_ENUMERATION;
+	attr_table_entry_encode_header(entry, entry_length, attr_type,
+				       info->name_handle);
+	struct pldm_bios_attr_table_entry *attr_entry = entry;
+	attr_entry->metadata[0] = info->pv_num;
+	uint16_t *pv_hdls =
+	    (uint16_t *)(attr_entry->metadata + 1 /* sizeof(pv num) */);
+	size_t i;
+	for (i = 0; i < info->pv_num; i++)
+		pv_hdls[i] = htole16(info->pv_handle[i]);
+	attr_entry->metadata[1 + info->pv_num * sizeof(uint16_t)] =
+	    info->def_num;
+	memcpy(attr_entry->metadata + 1 /* sizeof(pv num) */ +
+		   info->pv_num * sizeof(uint16_t) + 1 /* sizeof(def num)*/,
+	       info->def_index, info->def_num);
+}
+
+int pldm_bios_table_attr_entry_enum_encode_check(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_enum_info *info)
+{
+	POINTER_CHECK(entry);
+	POINTER_CHECK(info);
+	size_t length = pldm_bios_table_attr_entry_enum_encode_length(
+	    info->pv_num, info->def_num);
+	BUFFER_SIZE_EXPECT(entry_length, length);
+	pldm_bios_table_attr_entry_enum_encode(entry, entry_length, info);
+	return PLDM_SUCCESS;
+}
+
 #define ATTR_TYPE_EXPECT(type, expected)                                       \
 	do {                                                                   \
 		if (type != expected && type != (expected | 0x80))             \
@@ -186,23 +252,74 @@
 {
 	uint8_t pv_num = pldm_bios_table_attr_entry_enum_decode_pv_num(entry);
 	uint8_t def_num = pldm_bios_table_attr_entry_enum_decode_def_num(entry);
-	return sizeof(*entry) - 1 + sizeof(pv_num) + pv_num * sizeof(uint16_t) +
-	       sizeof(def_num) + def_num;
+	return pldm_bios_table_attr_entry_enum_encode_length(pv_num, def_num);
 }
 
-#define ATTR_ENTRY_STRING_LENGTH_MIN                                           \
-	sizeof(uint8_t) /* string type */ +                                    \
-	    sizeof(uint16_t) /* minimum string length */ +                     \
-	    sizeof(uint16_t) /* maximum string length */ +                     \
-	    sizeof(uint16_t) /* default string length */
+struct attr_table_string_entry_fields {
+	uint8_t string_type;
+	uint16_t min_length;
+	uint16_t max_length;
+	uint16_t def_length;
+	uint8_t def_string[1];
+} __attribute__((packed));
+
+size_t pldm_bios_table_attr_entry_string_encode_length(uint16_t def_str_len)
+{
+	return sizeof(struct pldm_bios_attr_table_entry) -
+	       MEMBER_SIZE(pldm_bios_attr_table_entry, metadata) +
+	       sizeof(struct attr_table_string_entry_fields) -
+	       MEMBER_SIZE(attr_table_string_entry_fields, def_string) +
+	       def_str_len;
+}
+
+void pldm_bios_table_attr_entry_string_encode(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_string_info *info)
+{
+	size_t length =
+	    pldm_bios_table_attr_entry_string_encode_length(info->def_length);
+	assert(length <= entry_length);
+	uint8_t attr_type =
+	    info->read_only ? PLDM_BIOS_STRING_READ_ONLY : PLDM_BIOS_STRING;
+	attr_table_entry_encode_header(entry, entry_length, attr_type,
+				       info->name_handle);
+	struct pldm_bios_attr_table_entry *attr_entry = entry;
+	struct attr_table_string_entry_fields *attr_fields =
+	    (struct attr_table_string_entry_fields *)attr_entry->metadata;
+	attr_fields->string_type = info->string_type;
+	attr_fields->min_length = htole16(info->min_length);
+	attr_fields->max_length = htole16(info->max_length);
+	attr_fields->def_length = htole16(info->def_length);
+	if (info->def_length != 0 && info->def_string != NULL)
+		memcpy(attr_fields->def_string, info->def_string,
+		       info->def_length);
+}
+
+int pldm_bios_table_attr_entry_string_encode_check(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_string_info *info)
+{
+	POINTER_CHECK(entry);
+	POINTER_CHECK(info);
+	size_t length =
+	    pldm_bios_table_attr_entry_string_encode_length(info->def_length);
+	BUFFER_SIZE_EXPECT(entry_length, length);
+	if (info->def_length > info->max_length ||
+	    info->def_length < info->min_length ||
+	    info->min_length > info->max_length)
+		return PLDM_ERROR_INVALID_DATA;
+	if (info->string_type > 5 && info->string_type != 0xFF)
+		return PLDM_ERROR_INVALID_DATA;
+	pldm_bios_table_attr_entry_string_encode(entry, entry_length, info);
+	return PLDM_SUCCESS;
+}
 
 uint16_t pldm_bios_table_attr_entry_string_decode_def_string_length(
     const struct pldm_bios_attr_table_entry *entry)
 {
-	int def_string_pos = ATTR_ENTRY_STRING_LENGTH_MIN - sizeof(uint16_t);
-	uint16_t def_string_length =
-	    *(uint16_t *)(entry->metadata + def_string_pos);
-	return le16toh(def_string_length);
+	struct attr_table_string_entry_fields *fields =
+	    (struct attr_table_string_entry_fields *)entry->metadata;
+	return le16toh(fields->def_length);
 }
 
 int pldm_bios_table_attr_entry_string_decode_def_string_length_check(
@@ -221,10 +338,9 @@
 static size_t
 attr_table_entry_length_string(const struct pldm_bios_attr_table_entry *entry)
 {
-	uint16_t def_string_len =
+	uint16_t def_str_len =
 	    pldm_bios_table_attr_entry_string_decode_def_string_length(entry);
-	return sizeof(*entry) - 1 + ATTR_ENTRY_STRING_LENGTH_MIN +
-	       def_string_len;
+	return pldm_bios_table_attr_entry_string_encode_length(def_str_len);
 }
 
 struct attr_table_entry {
diff --git a/libpldm/bios_table.h b/libpldm/bios_table.h
index fc9c0eb..97c64ce 100644
--- a/libpldm/bios_table.h
+++ b/libpldm/bios_table.h
@@ -152,6 +152,51 @@
 pldm_bios_table_string_find_by_handle(const void *table, size_t length,
 				      uint16_t handle);
 
+/** @struct pldm_bios_table_attr_entry_enum_info
+ *
+ *  An auxiliary structure for passing parameters to @ref
+ * pldm_bios_table_attr_entry_enum_encode
+ *
+ */
+struct pldm_bios_table_attr_entry_enum_info {
+	uint16_t name_handle; //!< attribute name handle
+	bool read_only;       //!< indicate whether the attribute is read-only
+	uint8_t pv_num;       //!< number of possible values
+	const uint16_t *pv_handle; //!< handles of possible values
+	uint8_t def_num;	   //!< nnumber of default values
+	const uint8_t *def_index;  //!< indices of default values.
+};
+
+/** @brief Get length that an attribute entry(type: enum) will take
+ *  @param[in] pv_num - Number of possible values
+ *  @param[in] def_num - Number of default values
+ *  @return The length that an entry(type: enum) will take
+ */
+size_t pldm_bios_table_attr_entry_enum_encode_length(uint8_t pv_num,
+						     uint8_t def_num);
+
+/** @brief Create an entry of BIOS Attribute Table (type: enum)
+ *  @param[out] entry - Pointer to a buffer to create an entry
+ *  @param[in] entry_length - Length of the buffer to create an entry
+ *  @param[in] info - Pointer to an auxiliary structure @ref
+ * pldm_bios_table_attr_entry_enum_info
+ */
+void pldm_bios_table_attr_entry_enum_encode(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_enum_info *info);
+
+/** @brief Create an entry of BIOS Attribute Table (type: enum) and check the
+ * validity of the parameters
+ *  @param[out] entry - Pointer to a buffer to create an entry
+ *  @param[in] entry_length - Length of the buffer to create an entry
+ *  @param[in] info - Pointer to an auxiliary structure @ref
+ * pldm_bios_table_attr_entry_enum_info
+ *  @return pldm_completion_codes
+ */
+int pldm_bios_table_attr_entry_enum_encode_check(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_enum_info *info);
+
 /** @brief Get the total number of possible values for the entry
  *  @param[in] entry - Pointer to bios attribute table entry
  *  @return total number of possible values
@@ -208,6 +253,50 @@
     const struct pldm_bios_attr_table_entry *entry, uint16_t *pv_hdls,
     uint8_t pv_num);
 
+/** @struct pldm_bios_table_attr_entry_string_info
+ *
+ *  An auxiliary structure for passing parameters to @ref
+ * pldm_bios_table_attr_entry_string_encode
+ *
+ */
+struct pldm_bios_table_attr_entry_string_info {
+	uint16_t name_handle;   //!< attribute name handle
+	bool read_only;		//!< indicate whether the attribute is read-only
+	uint8_t string_type;    //!< The type of the string
+	uint16_t min_length;    //!< The minimum length of the string in bytes
+	uint16_t max_length;    //!< The maximum length of the string in bytes
+	uint16_t def_length;    //!< The length of the defaut string in bytes
+	const char *def_string; //!< The default string itself
+};
+
+/** @brief Get length that an attribute entry(type: string) will take
+ *  @param[in] def_str_len - Length of default string
+ *  @return The length that an entry(type: string) will take
+ */
+size_t pldm_bios_table_attr_entry_string_encode_length(uint16_t def_str_len);
+
+/** @brief Create an entry of BIOS Attribute Table (type: string)
+ *  @param[out] entry - Pointer to a buffer to create an entry
+ *  @param[in] entry_length - Length of the buffer to create an entry
+ *  @param[in] info - Pointer to an auxiliary structure @ref
+ * pldm_bios_table_attr_entry_string_info
+ */
+void pldm_bios_table_attr_entry_string_encode(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_string_info *info);
+
+/** @brief Create an entry of BIOS Attribute Table (type: string) and check the
+ * validity of the parameters
+ *  @param[out] entry - Pointer to a buffer to create an entry
+ *  @param[in] entry_length - Length of the buffer to create an entry
+ *  @param[in] info - Pointer to an auxiliary structure @ref
+ * pldm_bios_table_attr_entry_string_info
+ *  @return pldm_completion_codes
+ */
+int pldm_bios_table_attr_entry_string_encode_check(
+    void *entry, size_t entry_length,
+    const struct pldm_bios_table_attr_entry_string_info *info);
+
 /** @brief Get the length of default string in bytes for the entry
  *  @param[in] entry - Pointer to bios attribute table entry
  *  @return length of default string in bytes
diff --git a/libpldmresponder/bios.cpp b/libpldmresponder/bios.cpp
index 5bfe0ae..4372e21 100644
--- a/libpldmresponder/bios.cpp
+++ b/libpldmresponder/bios.cpp
@@ -128,16 +128,6 @@
     return response;
 }
 
-/** @brief Generate the next attribute handle
- *
- *  @return - uint16_t - next attribute handle
- */
-AttributeHandle nextAttributeHandle()
-{
-    static AttributeHandle attrHdl = 0;
-    return attrHdl++;
-}
-
 /** @brief Construct the BIOS string table
  *
  *  @param[in] BIOSStringTable - the string table
@@ -357,9 +347,7 @@
                             entry("ATTRIBUTE=%s", key.c_str()));
             continue;
         }
-        uint8_t typeOfAttr = (std::get<0>(value))
-                                 ? PLDM_BIOS_ENUMERATION_READ_ONLY
-                                 : PLDM_BIOS_ENUMERATION;
+        bool readOnly = (std::get<0>(value));
         PossibleValues possiVals = std::get<1>(value);
         DefaultValues defVals = std::get<2>(value);
         // both the possible and default values are stored in sorted manner to
@@ -383,35 +371,21 @@
             }
         }
         auto defValsByHdl = findDefaultValHandle(possiVals, defVals);
+        auto entryLength = pldm_bios_table_attr_entry_enum_encode_length(
+            possiValsByHdl.size(), defValsByHdl.size());
 
-        BIOSTableRow enumAttrTable(
-            (sizeof(struct pldm_bios_attr_table_entry) - 1) + sizeof(uint8_t) +
-                possiValsByHdl.size() * sizeof(uint16_t) + sizeof(uint8_t) +
-                defValsByHdl.size() * sizeof(uint8_t),
-            0);
-        BIOSTableRow::iterator it = enumAttrTable.begin();
-        auto attrPtr = reinterpret_cast<struct pldm_bios_attr_table_entry*>(
-            enumAttrTable.data());
-        attrPtr->attr_handle = nextAttributeHandle();
-        attrPtr->attr_type = typeOfAttr;
-        attrPtr->string_handle = std::move(strHandle);
-        std::advance(it, (sizeof(struct pldm_bios_attr_table_entry) - 1));
-        uint8_t numPossibleVals = possiValsByHdl.size();
-        std::copy_n(&numPossibleVals, sizeof(numPossibleVals), it);
-        std::advance(it, sizeof(numPossibleVals));
-        std::copy_n(reinterpret_cast<uint8_t*>(possiValsByHdl.data()),
-                    sizeof(uint16_t) * possiValsByHdl.size(), it);
-        std::advance(
-            it, sizeof(uint16_t) *
-                    possiValsByHdl.size()); // possible val handle is uint16_t
-        uint8_t numDefaultVals = defValsByHdl.size();
-        std::copy_n(&numDefaultVals, sizeof(numDefaultVals), it);
-        std::advance(it, sizeof(numDefaultVals));
-        std::copy(defValsByHdl.begin(), defValsByHdl.end(), it);
-        std::advance(it, defValsByHdl.size());
-
-        std::move(enumAttrTable.begin(), enumAttrTable.end(),
-                  std::back_inserter(attributeTable));
+        auto attrTableSize = attributeTable.size();
+        attributeTable.resize(attrTableSize + entryLength, 0);
+        struct pldm_bios_table_attr_entry_enum_info info = {
+            strHandle,
+            readOnly,
+            (uint8_t)possiValsByHdl.size(),
+            possiValsByHdl.data(),
+            (uint8_t)defValsByHdl.size(),
+            defValsByHdl.data(),
+        };
+        pldm_bios_table_attr_entry_enum_encode(
+            attributeTable.data() + attrTableSize, entryLength, &info);
     }
 }
 
@@ -469,7 +443,6 @@
 {
     const auto& attributeMap = getValues();
     StringHandle strHandle;
-
     for (const auto& [key, value] : attributeMap)
     {
         try
@@ -483,37 +456,19 @@
             continue;
         }
 
-        const auto& [type, strType, minStrLen, maxStrLen, defaultStrLen,
+        const auto& [readOnly, strType, minStrLen, maxStrLen, defaultStrLen,
                      defaultStr] = value;
-        uint8_t typeOfAttr =
-            type ? PLDM_BIOS_STRING_READ_ONLY : PLDM_BIOS_STRING;
+        auto entryLength =
+            pldm_bios_table_attr_entry_string_encode_length(defaultStrLen);
 
-        BIOSTableRow stringAttrTable(bios_parser::bios_string::attrTableSize +
-                                     defaultStr.size());
-        BIOSTableRow::iterator it = stringAttrTable.begin();
-        auto attrPtr = reinterpret_cast<struct pldm_bios_attr_table_entry*>(
-            stringAttrTable.data());
-        attrPtr->attr_handle = nextAttributeHandle();
-        attrPtr->attr_type = typeOfAttr;
-        attrPtr->string_handle = strHandle;
-
-        std::advance(it, (sizeof(struct pldm_bios_attr_table_entry) - 1));
-        std::copy_n(&strType, sizeof(uint8_t), it);
-        std::advance(it, sizeof(uint8_t));
-        std::copy_n(reinterpret_cast<const uint8_t*>(&minStrLen),
-                    sizeof(uint16_t), it);
-        std::advance(it, sizeof(uint16_t));
-        std::copy_n(reinterpret_cast<const uint8_t*>(&maxStrLen),
-                    sizeof(uint16_t), it);
-        std::advance(it, sizeof(uint16_t));
-        std::copy_n(reinterpret_cast<const uint8_t*>(&defaultStrLen),
-                    sizeof(uint16_t), it);
-        std::advance(it, sizeof(uint16_t));
-        std::copy_n(defaultStr.data(), defaultStr.size(), it);
-        std::advance(it, defaultStr.size());
-
-        attributeTable.insert(attributeTable.end(), stringAttrTable.begin(),
-                              stringAttrTable.end());
+        struct pldm_bios_table_attr_entry_string_info info = {
+            strHandle, readOnly,      strType,           minStrLen,
+            maxStrLen, defaultStrLen, defaultStr.data(),
+        };
+        auto attrTableSize = attributeTable.size();
+        attributeTable.resize(attrTableSize + entryLength, 0);
+        pldm_bios_table_attr_entry_string_encode(
+            attributeTable.data() + attrTableSize, entryLength, &info);
     }
 }
 
diff --git a/libpldmresponder/bios_parser.hpp b/libpldmresponder/bios_parser.hpp
index bc92e3c..6620ddb 100644
--- a/libpldmresponder/bios_parser.hpp
+++ b/libpldmresponder/bios_parser.hpp
@@ -87,15 +87,6 @@
 using AttrValuesMap =
     std::map<AttrName, std::tuple<IsReadOnly, StrType, MinStrLen, MaxStrLen,
                                   DefaultStrLen, DefaultStr>>;
-/* attrTableSize is the sum of fixed length of members which construct a string
- * attribute table, including attr_handle(uint16_t), attr_type(uint8_t),
- * string_handle(uint16_t), strType(uint8_t), minStrLen(uint16_t),
- * MaxStrLen(uint16_t), DefaultStrLen(uint16_t) */
-constexpr auto attrTableSize = 12;
-static_assert(attrTableSize == sizeof(uint16_t) + sizeof(uint8_t) +
-                                   sizeof(uint16_t) + sizeof(uint8_t) +
-                                   sizeof(uint16_t) + sizeof(uint16_t) +
-                                   sizeof(uint16_t));
 
 /** @brief Get the string related values and the default values for the
  *         BIOSString and BIOSStringReadOnly types
diff --git a/test/libpldm_bios_table_test.cpp b/test/libpldm_bios_table_test.cpp
index 8a808a5..a07036a 100644
--- a/test/libpldm_bios_table_test.cpp
+++ b/test/libpldm_bios_table_test.cpp
@@ -1,6 +1,7 @@
 #include <string.h>
 
 #include <cstring>
+#include <utility>
 #include <vector>
 
 #include "libpldm/base.h"
@@ -96,6 +97,58 @@
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 }
 
+TEST(AttrTable, EnumEntryEncodeTest)
+{
+    std::vector<uint8_t> enumEntry{
+        0, 0, /* attr handle */
+        0,    /* attr type */
+        1, 0, /* attr name handle */
+        2,    /* number of possible value */
+        2, 0, /* possible value handle */
+        3, 0, /* possible value handle */
+        1,    /* number of default value */
+        0     /* defaut value string handle index */
+    };
+
+    std::vector<uint16_t> pv_hdls{2, 3};
+    std::vector<uint8_t> defs{0};
+
+    struct pldm_bios_table_attr_entry_enum_info info = {
+        1,              /* name handle */
+        false,          /* read only */
+        2,              /* pv number */
+        pv_hdls.data(), /* pv handle */
+        1,              /*def number */
+        defs.data()     /*def index*/
+    };
+    auto encodeLength = pldm_bios_table_attr_entry_enum_encode_length(2, 1);
+    EXPECT_EQ(encodeLength, enumEntry.size());
+
+    std::vector<uint8_t> encodeEntry(encodeLength, 0);
+    pldm_bios_table_attr_entry_enum_encode(encodeEntry.data(),
+                                           encodeEntry.size(), &info);
+    // set attr handle = 0
+    encodeEntry[0] = 0;
+    encodeEntry[1] = 0;
+
+    EXPECT_EQ(enumEntry, encodeEntry);
+
+    EXPECT_DEATH(pldm_bios_table_attr_entry_enum_encode(
+                     encodeEntry.data(), encodeEntry.size() - 1, &info),
+                 "length <= entry_length");
+    auto rc = pldm_bios_table_attr_entry_enum_encode_check(
+        encodeEntry.data(), encodeEntry.size(), &info);
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+    // set attr handle = 0
+    encodeEntry[0] = 0;
+    encodeEntry[1] = 0;
+
+    EXPECT_EQ(enumEntry, encodeEntry);
+    rc = pldm_bios_table_attr_entry_enum_encode_check(
+        encodeEntry.data(), encodeEntry.size() - 1, &info);
+    EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+}
+
 TEST(AttrTable, StringEntryDecodeTest)
 {
     std::vector<uint8_t> stringEntry{
@@ -136,6 +189,86 @@
     EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 }
 
+TEST(AttrTable, StringEntryEncodeTest)
+{
+    std::vector<uint8_t> stringEntry{
+        0,   0,        /* attr handle */
+        1,             /* attr type */
+        3,   0,        /* attr name handle */
+        1,             /* string type */
+        1,   0,        /* min string length */
+        100, 0,        /* max string length */
+        3,   0,        /* default string length */
+        'a', 'b', 'c', /* defaul string */
+    };
+
+    struct pldm_bios_table_attr_entry_string_info info = {
+        3,     /* name handle */
+        false, /* read only */
+        1,     /* string type ascii */
+        1,     /* min length */
+        100,   /* max length */
+        3,     /* def length */
+        "abc", /* def string */
+    };
+    auto encodeLength = pldm_bios_table_attr_entry_string_encode_length(3);
+    EXPECT_EQ(encodeLength, stringEntry.size());
+
+    std::vector<uint8_t> encodeEntry(encodeLength, 0);
+    pldm_bios_table_attr_entry_string_encode(encodeEntry.data(),
+                                             encodeEntry.size(), &info);
+    // set attr handle = 0
+    encodeEntry[0] = 0;
+    encodeEntry[1] = 0;
+
+    EXPECT_EQ(stringEntry, encodeEntry);
+
+    EXPECT_DEATH(pldm_bios_table_attr_entry_string_encode(
+                     encodeEntry.data(), encodeEntry.size() - 1, &info),
+                 "length <= entry_length");
+    auto rc = pldm_bios_table_attr_entry_string_encode_check(
+        encodeEntry.data(), encodeEntry.size(), &info);
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+    // set attr handle = 0
+    encodeEntry[0] = 0;
+    encodeEntry[1] = 0;
+
+    EXPECT_EQ(stringEntry, encodeEntry);
+    rc = pldm_bios_table_attr_entry_string_encode_check(
+        encodeEntry.data(), encodeEntry.size() - 1, &info);
+    EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+    std::swap(info.max_length, info.min_length);
+    rc = pldm_bios_table_attr_entry_string_encode_check(
+        encodeEntry.data(), encodeEntry.size(), &info);
+    EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+    std::swap(info.max_length, info.min_length);
+
+    std::vector<uint8_t> stringEntryLength0{
+        0,   0, /* attr handle */
+        1,      /* attr type */
+        3,   0, /* attr name handle */
+        1,      /* string type */
+        1,   0, /* min string length */
+        100, 0, /* max string length */
+        0,   0, /* default string length */
+    };
+
+    info.def_length = 0;
+    info.def_string = nullptr;
+
+    encodeLength = pldm_bios_table_attr_entry_string_encode_length(0);
+    EXPECT_EQ(encodeLength, stringEntryLength0.size());
+
+    encodeEntry.resize(encodeLength);
+    pldm_bios_table_attr_entry_string_encode(encodeEntry.data(),
+                                             encodeEntry.size(), &info);
+    // set attr handle = 0
+    encodeEntry[0] = 0;
+    encodeEntry[1] = 0;
+
+    EXPECT_EQ(stringEntryLength0, encodeEntry);
+}
+
 TEST(AttrTable, ItearatorTest)
 {
     std::vector<uint8_t> enumEntry{