diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentDataProducts.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentDataProducts.scala
index f879aaed9..f261340a9 100644
--- a/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentDataProducts.scala
+++ b/compiler/lib/src/main/scala/codegen/CppWriter/ComponentCppWriter/ComponentDataProducts.scala
@@ -373,10 +373,58 @@ case class ComponentDataProducts (
     )
 
     private def singleRecordSerializeFn(name: String, t: Type) = {
+      // Get the type name
       val typeName = TypeCppWriter.getName(s, t)
-      val paramType = if (s.isPrimitive(t, typeName))
-        typeName else s"const ${typeName}&"
-      val typeSize = s.getSerializedSizeExpr(t, typeName)
+      // Get the parameter type
+      // For strings this is a const reference to Fw::StringBase
+      // For primitive types it is the type name
+      // For othe types it is a const reference to the type name
+      val paramType = t match {
+        case Type.String(_) => "const Fw::StringBase&"
+        case _ =>
+          if s.isPrimitive(t, typeName)
+          then typeName
+          else s"const $typeName&"
+      }
+      // Generate the code for computing the size delta
+      val computeSizeDelta = (t match {
+        case ts: Type.String =>
+          val stringSize = StringCppWriter(s).getSize(ts).toString
+          s"""|const FwSizeType stringSize = $stringSize;
+              |const FwSizeType sizeDelta =
+              |  sizeof(FwDpIdType) +
+              |  elt.serializedTruncatedSize(stringSize);"""
+        case _ =>
+          val serialSize = s.getSerializedSizeExpr(t, typeName)
+          s"""|const FwSizeType sizeDelta =
+              |  sizeof(FwDpIdType) +
+              |  $serialSize;"""
+      }).stripMargin
+      // Get the expression that does the serialization
+      // For strings this is a truncated serialization
+      val serialExpr = t match {
+        case ts: Type.String =>
+          "elt.serialize(this->m_dataBuffer, stringSize)"
+        case _ => "this->m_dataBuffer.serialize(elt)"
+      }
+      // Construct the function body
+      val body = lines(
+        s"""|$computeSizeDelta
+            |Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+            |if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+            |  const FwDpIdType id = this->baseId + RecordId::$name;
+            |  status = this->m_dataBuffer.serialize(id);
+            |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+            |  status = $serialExpr;
+            |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+            |  this->m_dataSize += sizeDelta;
+            |}
+            |else {
+            |  status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+            |}
+            |return status;"""
+      )
+      // Construct the function class member
       functionClassMember(
         Some(s"""|Serialize a $name record into the packet buffer
                  |\\return The serialize status"""),
@@ -389,32 +437,82 @@ case class ComponentDataProducts (
           )
         ),
         CppDoc.Type("Fw::SerializeStatus"),
-        lines(
-          s"""|const FwSizeType sizeDelta =
-              |  sizeof(FwDpIdType) +
-              |  $typeSize;
-              |Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-              |if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
-              |  const FwDpIdType id = this->baseId + RecordId::$name;
-              |  status = this->m_dataBuffer.serialize(id);
-              |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-              |  status = this->m_dataBuffer.serialize(elt);
-              |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-              |  this->m_dataSize += sizeDelta;
-              |}
-              |else {
-              |  status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
-              |}
-              |return status;"""
-        )
+        body
       )
     }
 
     private def arrayRecordSerializeFn(name: String, t: Type) = {
+      // Get the type name and parameter type
       val typeName = TypeCppWriter.getName(s, t)
-      val paramType = s"const ${typeName}*"
-      val eltSize = if (s.isPrimitive(t, typeName))
-        s"sizeof($typeName)" else s"${typeName}::SERIALIZED_SIZE"
+      val paramType = t match {
+        case Type.String(_) => "const Fw::StringBase**"
+        case _ => s"const ${typeName}*"
+      }
+      // Generate the code for computing the size delta
+      val computeSizeDelta = (t match {
+        case ts: Type.String =>
+          val stringSize = StringCppWriter(s).getSize(ts).toString
+          s"""|const FwSizeType stringSize = $stringSize;
+              |FwSizeType sizeDelta =
+              |  sizeof(FwDpIdType) +
+              |  sizeof(FwSizeStoreType);
+              |for (FwSizeType i = 0; i < size; i++) {
+              |  const Fw::StringBase *const sbPtr = array[i];
+              |  FW_ASSERT(sbPtr != nullptr);
+              |  sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+              |}"""
+        case _ =>
+          val eltSize = if s.isPrimitive(t, typeName)
+                        then s"sizeof($typeName)"
+                        else s"${typeName}::SERIALIZED_SIZE"
+          s"""|const FwSizeType sizeDelta =
+              |  sizeof(FwDpIdType) +
+              |  sizeof(FwSizeStoreType) +
+              |  size * $eltSize;"""
+      }).stripMargin
+      // Generate the code for serializing the elements
+      val serializeElts = (t match {
+        // Optimize the U8 case
+        case Type.U8 =>
+          """|  status = this->m_dataBuffer.serialize(array, size, Fw::Serialization::OMIT_LENGTH);
+             |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);"""
+        // Handle the string case
+        case ts: Type.String =>
+          s"""|  for (FwSizeType i = 0; i < size; i++) {
+              |    const Fw::StringBase *const sbPtr = array[i];
+              |    FW_ASSERT(sbPtr != nullptr);
+              |    status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+              |    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+              |  }"""
+        // Handle the general case
+        case _ =>
+          """|  for (FwSizeType i = 0; i < size; i++) {
+             |    status = this->m_dataBuffer.serialize(array[i]);
+             |    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+             |  }"""
+      }).stripMargin
+      // Construct the function body
+      val body = lines(
+        s"""|FW_ASSERT(array != nullptr);
+            |// Compute the size delta
+            |$computeSizeDelta
+            |// Serialize the elements if they will fit
+            |Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+            |if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+            |  const FwDpIdType id = this->baseId + RecordId::$name;
+            |  status = this->m_dataBuffer.serialize(id);
+            |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+            |  status = this->m_dataBuffer.serializeSize(size);
+            |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+            |$serializeElts
+            |  this->m_dataSize += sizeDelta;
+            |}
+            |else {
+            |  status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+            |}
+            |return status;"""
+      )
+      // Construct the function class member
       functionClassMember(
         Some(s"""|Serialize a $name record into the packet buffer
                  |\\return The serialize status"""),
@@ -423,7 +521,12 @@ case class ComponentDataProducts (
           CppDoc.Function.Param(
             CppDoc.Type(paramType),
             "array",
-            Some(s"An array of ${typeName} elements")
+            Some(
+              t match {
+                case Type.String(_) => "An array of pointers to StringBase objects"
+                case _ => s"An array of $typeName elements"
+              }
+            )
           ),
           CppDoc.Function.Param(
             CppDoc.Type("FwSizeType"),
@@ -432,40 +535,7 @@ case class ComponentDataProducts (
           )
         ),
         CppDoc.Type("Fw::SerializeStatus"),
-        {
-          val serializeElts = (t match {
-            // Optimize the U8 case
-            case Type.U8 =>
-              """|  status = this->m_dataBuffer.serialize(array, size, Fw::Serialization::OMIT_LENGTH);
-                 |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);"""
-            case _ =>
-              """|  for (FwSizeType i = 0; i < size; i++) {
-                 |    status = this->m_dataBuffer.serialize(array[i]);
-                 |    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-                 |  }"""
-          }).stripMargin
-          lines(
-            s"""|FW_ASSERT(array != nullptr);
-                |const FwSizeType sizeDelta =
-                |  sizeof(FwDpIdType) +
-                |  sizeof(FwSizeStoreType) +
-                |  size * $eltSize;
-                |Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-                |if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
-                |  const FwDpIdType id = this->baseId + RecordId::$name;
-                |  status = this->m_dataBuffer.serialize(id);
-                |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-                |  status = this->m_dataBuffer.serializeSize(size);
-                |  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-                |$serializeElts
-                |  this->m_dataSize += sizeDelta;
-                |}
-                |else {
-                |  status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
-                |}
-                |return status;"""
-          )
-        }
+        body
       )
     }
 
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.cpp
index 9ed591d2f..b36226aff 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.cpp
@@ -100,12 +100,14 @@ Fw::SerializeStatus ActiveAsyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * ActiveAsyncProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -144,6 +146,67 @@ Fw::SerializeStatus ActiveAsyncProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus ActiveAsyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus ActiveAsyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus ActiveAsyncProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -151,12 +214,14 @@ Fw::SerializeStatus ActiveAsyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -202,12 +267,14 @@ Fw::SerializeStatus ActiveAsyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.hpp
index 88abc4054..91dfc54f1 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveAsyncProductsComponentAc.ref.hpp
@@ -135,6 +135,8 @@ class ActiveAsyncProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -170,6 +172,19 @@ class ActiveAsyncProductsComponentBase :
             const ActiveAsyncProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.cpp
index c75f670ab..e135fa5e3 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.cpp
@@ -98,12 +98,14 @@ Fw::SerializeStatus ActiveGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * ActiveGetProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -142,6 +144,67 @@ Fw::SerializeStatus ActiveGetProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus ActiveGetProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus ActiveGetProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus ActiveGetProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -149,12 +212,14 @@ Fw::SerializeStatus ActiveGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -200,12 +265,14 @@ Fw::SerializeStatus ActiveGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.hpp
index 9906258db..83c2b33a2 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGetProductsComponentAc.ref.hpp
@@ -133,6 +133,8 @@ class ActiveGetProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -168,6 +170,19 @@ class ActiveGetProductsComponentBase :
             const ActiveGetProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.cpp
index 9b776e79d..a5353a0b5 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.cpp
@@ -98,12 +98,14 @@ Fw::SerializeStatus ActiveGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * ActiveGuardedProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -142,6 +144,67 @@ Fw::SerializeStatus ActiveGuardedProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus ActiveGuardedProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus ActiveGuardedProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus ActiveGuardedProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -149,12 +212,14 @@ Fw::SerializeStatus ActiveGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -200,12 +265,14 @@ Fw::SerializeStatus ActiveGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.hpp
index bafda607f..42d63dadd 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveGuardedProductsComponentAc.ref.hpp
@@ -135,6 +135,8 @@ class ActiveGuardedProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -170,6 +172,19 @@ class ActiveGuardedProductsComponentBase :
             const ActiveGuardedProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.cpp
index 1f1ea0bab..5dbeb1edf 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.cpp
@@ -98,12 +98,14 @@ Fw::SerializeStatus ActiveSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * ActiveSyncProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -142,6 +144,67 @@ Fw::SerializeStatus ActiveSyncProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus ActiveSyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus ActiveSyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus ActiveSyncProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -149,12 +212,14 @@ Fw::SerializeStatus ActiveSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -200,12 +265,14 @@ Fw::SerializeStatus ActiveSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.hpp
index 9f882711e..1ad7ab700 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveSyncProductsComponentAc.ref.hpp
@@ -135,6 +135,8 @@ class ActiveSyncProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -170,6 +172,19 @@ class ActiveSyncProductsComponentBase :
             const ActiveSyncProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp
index 2158e4133..29957ad66 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.cpp
@@ -136,12 +136,14 @@ namespace M {
     )
   {
     FW_ASSERT(array != nullptr);
+    // Compute the size delta
     const FwSizeType sizeDelta =
       sizeof(FwDpIdType) +
       sizeof(FwSizeStoreType) +
       size * M::ActiveTest_Data::SERIALIZED_SIZE;
+    // Serialize the elements if they will fit
     Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-    if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
       const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
       status = this->m_dataBuffer.serialize(id);
       FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -180,6 +182,67 @@ namespace M {
     return status;
   }
 
+  Fw::SerializeStatus ActiveTestComponentBase::DpContainer ::
+    serializeRecord_StringArrayRecord(
+        const Fw::StringBase** array,
+        FwSizeType size
+    )
+  {
+    FW_ASSERT(array != nullptr);
+    // Compute the size delta
+    const FwSizeType stringSize = 80;
+    FwSizeType sizeDelta =
+      sizeof(FwDpIdType) +
+      sizeof(FwSizeStoreType);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+    }
+    // Serialize the elements if they will fit
+    Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+    if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+      const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+      status = this->m_dataBuffer.serialize(id);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+      status = this->m_dataBuffer.serializeSize(size);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+      for (FwSizeType i = 0; i < size; i++) {
+        const Fw::StringBase *const sbPtr = array[i];
+        FW_ASSERT(sbPtr != nullptr);
+        status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+        FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+      }
+      this->m_dataSize += sizeDelta;
+    }
+    else {
+      status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+    }
+    return status;
+  }
+
+  Fw::SerializeStatus ActiveTestComponentBase::DpContainer ::
+    serializeRecord_StringRecord(const Fw::StringBase& elt)
+  {
+    const FwSizeType stringSize = 80;
+    const FwSizeType sizeDelta =
+      sizeof(FwDpIdType) +
+      elt.serializedTruncatedSize(stringSize);
+    Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+    if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+      const FwDpIdType id = this->baseId + RecordId::StringRecord;
+      status = this->m_dataBuffer.serialize(id);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+      status = elt.serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+      this->m_dataSize += sizeDelta;
+    }
+    else {
+      status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+    }
+    return status;
+  }
+
   Fw::SerializeStatus ActiveTestComponentBase::DpContainer ::
     serializeRecord_U32ArrayRecord(
         const U32* array,
@@ -187,12 +250,14 @@ namespace M {
     )
   {
     FW_ASSERT(array != nullptr);
+    // Compute the size delta
     const FwSizeType sizeDelta =
       sizeof(FwDpIdType) +
       sizeof(FwSizeStoreType) +
       size * sizeof(U32);
+    // Serialize the elements if they will fit
     Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-    if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
       const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
       status = this->m_dataBuffer.serialize(id);
       FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -238,12 +303,14 @@ namespace M {
     )
   {
     FW_ASSERT(array != nullptr);
+    // Compute the size delta
     const FwSizeType sizeDelta =
       sizeof(FwDpIdType) +
       sizeof(FwSizeStoreType) +
       size * sizeof(U8);
+    // Serialize the elements if they will fit
     Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-    if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
       const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
       status = this->m_dataBuffer.serialize(id);
       FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp
index 66ff2f3eb..9aaa6e2bf 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/ActiveTestComponentAc.ref.hpp
@@ -222,6 +222,8 @@ namespace M {
           U8ArrayRecord = 300,
           U32ArrayRecord = 400,
           DataArrayRecord = 500,
+          StringRecord = 600,
+          StringArrayRecord = 700,
         };
       };
 
@@ -257,6 +259,19 @@ namespace M {
               const M::ActiveTest_Data& elt //!< The element
           );
 
+          //! Serialize a StringArrayRecord record into the packet buffer
+          //! \return The serialize status
+          Fw::SerializeStatus serializeRecord_StringArrayRecord(
+              const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+              FwSizeType size //!< The array size
+          );
+
+          //! Serialize a StringRecord record into the packet buffer
+          //! \return The serialize status
+          Fw::SerializeStatus serializeRecord_StringRecord(
+              const Fw::StringBase& elt //!< The element
+          );
+
           //! Serialize a U32ArrayRecord record into the packet buffer
           //! \return The serialize status
           Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.cpp
index 4b918e1dd..56a2c233e 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.cpp
@@ -43,12 +43,14 @@ Fw::SerializeStatus PassiveGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * PassiveGetProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -87,6 +89,67 @@ Fw::SerializeStatus PassiveGetProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus PassiveGetProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus PassiveGetProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus PassiveGetProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -94,12 +157,14 @@ Fw::SerializeStatus PassiveGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -145,12 +210,14 @@ Fw::SerializeStatus PassiveGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.hpp
index d9bcd5702..c32e95bb8 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGetProductsComponentAc.ref.hpp
@@ -128,6 +128,8 @@ class PassiveGetProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -163,6 +165,19 @@ class PassiveGetProductsComponentBase :
             const PassiveGetProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.cpp
index 747908856..0c7c8a7b3 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.cpp
@@ -43,12 +43,14 @@ Fw::SerializeStatus PassiveGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * PassiveGuardedProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -87,6 +89,67 @@ Fw::SerializeStatus PassiveGuardedProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus PassiveGuardedProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus PassiveGuardedProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus PassiveGuardedProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -94,12 +157,14 @@ Fw::SerializeStatus PassiveGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -145,12 +210,14 @@ Fw::SerializeStatus PassiveGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.hpp
index 5b535f980..ddfc14118 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveGuardedProductsComponentAc.ref.hpp
@@ -130,6 +130,8 @@ class PassiveGuardedProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -165,6 +167,19 @@ class PassiveGuardedProductsComponentBase :
             const PassiveGuardedProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.cpp
index 8610afcd0..5cafc2ff8 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.cpp
@@ -43,12 +43,14 @@ Fw::SerializeStatus PassiveSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * PassiveSyncProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -87,6 +89,67 @@ Fw::SerializeStatus PassiveSyncProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus PassiveSyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus PassiveSyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus PassiveSyncProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -94,12 +157,14 @@ Fw::SerializeStatus PassiveSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -145,12 +210,14 @@ Fw::SerializeStatus PassiveSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.hpp
index 44ee457ac..683c7c010 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveSyncProductsComponentAc.ref.hpp
@@ -130,6 +130,8 @@ class PassiveSyncProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -165,6 +167,19 @@ class PassiveSyncProductsComponentBase :
             const PassiveSyncProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp
index 7d7f17184..7c21fa661 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.cpp
@@ -43,12 +43,14 @@ Fw::SerializeStatus PassiveTestComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * PassiveTest_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -87,6 +89,67 @@ Fw::SerializeStatus PassiveTestComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus PassiveTestComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus PassiveTestComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus PassiveTestComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -94,12 +157,14 @@ Fw::SerializeStatus PassiveTestComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -145,12 +210,14 @@ Fw::SerializeStatus PassiveTestComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp
index 4ff515b1b..f804186e0 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/PassiveTestComponentAc.ref.hpp
@@ -209,6 +209,8 @@ class PassiveTestComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -244,6 +246,19 @@ class PassiveTestComponentBase :
             const PassiveTest_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.cpp
index c3ebf697b..1dc016cd8 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.cpp
@@ -100,12 +100,14 @@ Fw::SerializeStatus QueuedAsyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * QueuedAsyncProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -144,6 +146,67 @@ Fw::SerializeStatus QueuedAsyncProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus QueuedAsyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus QueuedAsyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus QueuedAsyncProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -151,12 +214,14 @@ Fw::SerializeStatus QueuedAsyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -202,12 +267,14 @@ Fw::SerializeStatus QueuedAsyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.hpp
index a93b02b6c..c524ce732 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedAsyncProductsComponentAc.ref.hpp
@@ -135,6 +135,8 @@ class QueuedAsyncProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -170,6 +172,19 @@ class QueuedAsyncProductsComponentBase :
             const QueuedAsyncProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.cpp
index 7add33d60..70ef15c68 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.cpp
@@ -98,12 +98,14 @@ Fw::SerializeStatus QueuedGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * QueuedGetProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -142,6 +144,67 @@ Fw::SerializeStatus QueuedGetProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus QueuedGetProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus QueuedGetProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus QueuedGetProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -149,12 +212,14 @@ Fw::SerializeStatus QueuedGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -200,12 +265,14 @@ Fw::SerializeStatus QueuedGetProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.hpp
index fa28b1318..0ef2eb20d 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGetProductsComponentAc.ref.hpp
@@ -133,6 +133,8 @@ class QueuedGetProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -168,6 +170,19 @@ class QueuedGetProductsComponentBase :
             const QueuedGetProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.cpp
index 0d0f080fd..e9afd222f 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.cpp
@@ -98,12 +98,14 @@ Fw::SerializeStatus QueuedGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * QueuedGuardedProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -142,6 +144,67 @@ Fw::SerializeStatus QueuedGuardedProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus QueuedGuardedProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus QueuedGuardedProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus QueuedGuardedProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -149,12 +212,14 @@ Fw::SerializeStatus QueuedGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -200,12 +265,14 @@ Fw::SerializeStatus QueuedGuardedProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.hpp
index 3a414c7e7..f2fed5842 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedGuardedProductsComponentAc.ref.hpp
@@ -135,6 +135,8 @@ class QueuedGuardedProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -170,6 +172,19 @@ class QueuedGuardedProductsComponentBase :
             const QueuedGuardedProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.cpp
index 5bd63091f..9b35b7c0a 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.cpp
@@ -98,12 +98,14 @@ Fw::SerializeStatus QueuedSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * QueuedSyncProducts_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -142,6 +144,67 @@ Fw::SerializeStatus QueuedSyncProductsComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus QueuedSyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus QueuedSyncProductsComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus QueuedSyncProductsComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -149,12 +212,14 @@ Fw::SerializeStatus QueuedSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -200,12 +265,14 @@ Fw::SerializeStatus QueuedSyncProductsComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.hpp
index 0f8e4353a..b3594df01 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedSyncProductsComponentAc.ref.hpp
@@ -135,6 +135,8 @@ class QueuedSyncProductsComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -170,6 +172,19 @@ class QueuedSyncProductsComponentBase :
             const QueuedSyncProducts_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp
index 34078f840..b11d08e03 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.cpp
@@ -134,12 +134,14 @@ Fw::SerializeStatus QueuedTestComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * QueuedTest_Data::SERIALIZED_SIZE;
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::DataArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -178,6 +180,67 @@ Fw::SerializeStatus QueuedTestComponentBase::DpContainer ::
   return status;
 }
 
+Fw::SerializeStatus QueuedTestComponentBase::DpContainer ::
+  serializeRecord_StringArrayRecord(
+      const Fw::StringBase** array,
+      FwSizeType size
+  )
+{
+  FW_ASSERT(array != nullptr);
+  // Compute the size delta
+  const FwSizeType stringSize = 80;
+  FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    sizeof(FwSizeStoreType);
+  for (FwSizeType i = 0; i < size; i++) {
+    const Fw::StringBase *const sbPtr = array[i];
+    FW_ASSERT(sbPtr != nullptr);
+    sizeDelta += sbPtr->serializedTruncatedSize(stringSize);
+  }
+  // Serialize the elements if they will fit
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringArrayRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = this->m_dataBuffer.serializeSize(size);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    for (FwSizeType i = 0; i < size; i++) {
+      const Fw::StringBase *const sbPtr = array[i];
+      FW_ASSERT(sbPtr != nullptr);
+      status = sbPtr->serialize(this->m_dataBuffer, stringSize);
+      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    }
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
+Fw::SerializeStatus QueuedTestComponentBase::DpContainer ::
+  serializeRecord_StringRecord(const Fw::StringBase& elt)
+{
+  const FwSizeType stringSize = 80;
+  const FwSizeType sizeDelta =
+    sizeof(FwDpIdType) +
+    elt.serializedTruncatedSize(stringSize);
+  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
+  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+    const FwDpIdType id = this->baseId + RecordId::StringRecord;
+    status = this->m_dataBuffer.serialize(id);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    status = elt.serialize(this->m_dataBuffer, stringSize);
+    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
+    this->m_dataSize += sizeDelta;
+  }
+  else {
+    status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
+  }
+  return status;
+}
+
 Fw::SerializeStatus QueuedTestComponentBase::DpContainer ::
   serializeRecord_U32ArrayRecord(
       const U32* array,
@@ -185,12 +248,14 @@ Fw::SerializeStatus QueuedTestComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U32);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U32ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
@@ -236,12 +301,14 @@ Fw::SerializeStatus QueuedTestComponentBase::DpContainer ::
   )
 {
   FW_ASSERT(array != nullptr);
+  // Compute the size delta
   const FwSizeType sizeDelta =
     sizeof(FwDpIdType) +
     sizeof(FwSizeStoreType) +
     size * sizeof(U8);
+  // Serialize the elements if they will fit
   Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
-  if (this->m_dataBuffer.getBuffLength() + sizeDelta <= this->m_dataBuffer.getBuffCapacity()) {
+  if ((this->m_dataBuffer.getBuffLength() + sizeDelta) <= this->m_dataBuffer.getBuffCapacity()) {
     const FwDpIdType id = this->baseId + RecordId::U8ArrayRecord;
     status = this->m_dataBuffer.serialize(id);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
diff --git a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp
index d8f6dd3e4..e2a9e0314 100644
--- a/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp
+++ b/compiler/tools/fpp-to-cpp/test/component/base/QueuedTestComponentAc.ref.hpp
@@ -220,6 +220,8 @@ class QueuedTestComponentBase :
         U8ArrayRecord = 300,
         U32ArrayRecord = 400,
         DataArrayRecord = 500,
+        StringRecord = 600,
+        StringArrayRecord = 700,
       };
     };
 
@@ -255,6 +257,19 @@ class QueuedTestComponentBase :
             const QueuedTest_Data& elt //!< The element
         );
 
+        //! Serialize a StringArrayRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringArrayRecord(
+            const Fw::StringBase** array, //!< An array of pointers to StringBase objects
+            FwSizeType size //!< The array size
+        );
+
+        //! Serialize a StringRecord record into the packet buffer
+        //! \return The serialize status
+        Fw::SerializeStatus serializeRecord_StringRecord(
+            const Fw::StringBase& elt //!< The element
+        );
+
         //! Serialize a U32ArrayRecord record into the packet buffer
         //! \return The serialize status
         Fw::SerializeStatus serializeRecord_U32ArrayRecord(
diff --git a/compiler/tools/fpp-to-cpp/test/component/include/products.fppi b/compiler/tools/fpp-to-cpp/test/component/include/products.fppi
index 5dcb43819..72b42e786 100644
--- a/compiler/tools/fpp-to-cpp/test/component/include/products.fppi
+++ b/compiler/tools/fpp-to-cpp/test/component/include/products.fppi
@@ -27,6 +27,12 @@ product record U32ArrayRecord: U32 array id 400
 @ Record 5
 product record DataArrayRecord: Data array id 500
 
+@ Record 6
+product record StringRecord: string id 600
+
+@ Record 7
+product record StringArrayRecord: string array id 700
+
 # ----------------------------------------------------------------------
 # Containers
 # ----------------------------------------------------------------------
diff --git a/docs/fpp-spec.html b/docs/fpp-spec.html
index 933b77c1a..0a47d9f6f 100644
--- a/docs/fpp-spec.html
+++ b/docs/fpp-spec.html
@@ -7154,7 +7154,7 @@ <h3 id="Types_String-Types">16.6. String Types</h3>
 <p>The <strong>string types</strong> correspond to the
 <a href="#Type-Names_String-Type-Names">string type names</a>.
 A string type is written <code>string</code> or <code>string size</code> <em>n</em>,
-where <em>n</em> is an integer value in the range [0,2<sup>31</sup>].
+where <em>n</em> is an integer value in the range [1,2<sup>31</sup>].
 There is one string type <code>string</code> and one string type <code>string</code> <em>n</em>
 for each legal value of <em>n</em>.</p>
 </div>
@@ -8494,7 +8494,7 @@ <h3 id="Analysis-and-Translation_Translation-Tools">20.4. Translation Tools</h3>
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2024-02-27 22:29:34 -0800
+Last updated 2024-04-10 17:04:04 -0700
 </div>
 </div>
 <script src="code-prettify/run_prettify.js"></script>
diff --git a/docs/fpp-users-guide.html b/docs/fpp-users-guide.html
index e830482fd..b0d07bcc4 100644
--- a/docs/fpp-users-guide.html
+++ b/docs/fpp-users-guide.html
@@ -11729,7 +11729,7 @@ <h4 id="Writing-C-Plus-Plus-Implementations_Implementing-Deployments_Public-Symb
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2024-03-07 15:17:49 -0800
+Last updated 2024-04-10 17:04:06 -0700
 </div>
 </div>
 <script src="code-prettify/run_prettify.js"></script>
diff --git a/docs/spec/Types.adoc b/docs/spec/Types.adoc
index 46ff12fea..69cd8c620 100644
--- a/docs/spec/Types.adoc
+++ b/docs/spec/Types.adoc
@@ -36,7 +36,7 @@ are called the *primitive types*.
 The *string types* correspond to the
 <<Type-Names_String-Type-Names,string type names>>.
 A string type is written `string` or `string size` _n_,
-where _n_ is an integer value in the range [0,2^31^].
+where _n_ is an integer value in the range [1,2^31-1].
 There is one string type `string` and one string type `string` _n_
 for each legal value of _n_.