Add list value evaluator to SerializableSectionPairRow class

CMakeLists.txt

@@ -171,6 +171,7 @@ set(SOURCE_FILES_IO
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/logging/Logger.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/logging/LogLevel.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/section-pair/evaluator/SectionPairIdentifierArgumentEvaluator.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/section-pair/evaluator/SectionPairRowSingleValueArgumentEvaluator.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/section-pair/evaluator/SectionPairValueArgumentEvaluator.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/section-pair/model/SectionPairDocument.cpp
@@ -272,6 +273,7 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LoggerTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LogLevelTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/section-pair/evaluator/SectionPairIdentifierArgumentEvaluatorTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluatorTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/section-pair/evaluator/SectionPairRowSingleValueArgumentEvaluatorTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/section-pair/evaluator/SectionPairValueArgumentEvaluatorTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/section-pair/validator/SectionPairIdentifierValidatorTest.cpp

include/ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.hpp

@@ -0,0 +1,35 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-02-20
+* Changed:         2023-02-20
+*
+* */
+
+#ifndef LS_STD_SECTION_PAIR_ROW_LIST_VALUE_ARGUMENT_EVALUATOR_HPP
+#define LS_STD_SECTION_PAIR_ROW_LIST_VALUE_ARGUMENT_EVALUATOR_HPP
+
+#include <ls-std/core/Class.hpp>
+#include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/os/dynamic-goal.hpp>
+#include <string>
+
+namespace ls::std::io
+{
+  class LS_STD_DYNAMIC_GOAL SectionPairRowListValueArgumentEvaluator : public ls::std::core::Class, public ls::std::core::interface_type::IEvaluator
+  {
+    public:
+
+      explicit SectionPairRowListValueArgumentEvaluator(::std::string _listValueRow);
+      ~SectionPairRowListValueArgumentEvaluator() override;
+
+      void evaluate() override;
+
+    private:
+
+      ::std::string listValueRow{};
+  };
+}
+
+#endif

include/ls-std/io/section-pair/validator/SectionPairRowListValueValidator.hpp

@@ -11,12 +11,13 @@
 #define LS_STD_SECTION_PAIR_ROW_LIST_VALUE_VALIDATOR_HPP
 
 #include <ls-std/core/Class.hpp>
+#include <ls-std/core/interface/IValidator.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
 #include <string>
 
 namespace ls::std::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowListValueValidator : public ls::std::core::Class, ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairRowListValueValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
   {
     public:
 

include/ls-std/ls-std-io.hpp

@@ -17,6 +17,7 @@
 #include <ls-std/io/section-pair/SectionPairRowEnumType.hpp>
 #include <ls-std/io/section-pair/SectionPairTypes.hpp>
 #include <ls-std/io/section-pair/evaluator/SectionPairIdentifierArgumentEvaluator.hpp>
+#include <ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/evaluator/SectionPairRowSingleValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/evaluator/SectionPairValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/model/SectionPairDocument.hpp>

source/ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.cpp

@@ -0,0 +1,26 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-02-20
+* Changed:         2023-02-20
+*
+* */
+
+#include <ls-std/core/exception/IllegalArgumentException.hpp>
+#include <ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.hpp>
+#include <ls-std/io/section-pair/validator/SectionPairRowListValueValidator.hpp>
+
+ls::std::io::SectionPairRowListValueArgumentEvaluator::SectionPairRowListValueArgumentEvaluator(::std::string _listValueRow) : ls::std::core::Class("SectionPairRowListValueArgumentEvaluator"), listValueRow(::std::move(_listValueRow))
+{}
+
+ls::std::io::SectionPairRowListValueArgumentEvaluator::~SectionPairRowListValueArgumentEvaluator() = default;
+
+void ls::std::io::SectionPairRowListValueArgumentEvaluator::evaluate()
+{
+  if (!ls::std::io::SectionPairRowListValueValidator{this->listValueRow}.isValid())
+  {
+    ::std::string message = "\"" + this->listValueRow + "\" is not a valid section pair list value row!";
+    throw ls::std::core::IllegalArgumentException{message};
+  }
+}

source/ls-std/io/section-pair/serialization/SerializableSectionPairRow.cpp

@@ -3,11 +3,12 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2023-02-19
+* Changed:         2023-02-20
 *
 * */
 
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
+#include <ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/evaluator/SectionPairRowSingleValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/model/SectionPairRow.hpp>
 #include <ls-std/io/section-pair/model/SectionPairRowListValue.hpp>
@@ -72,6 +73,7 @@ void ls::std::io::SerializableSectionPairRow::unmarshal(const ls::std::core::typ
 
 void ls::std::io::SerializableSectionPairRow::_unmarshalListValue(const ls::std::core::type::byte_field &_data)
 {
+  ls::std::io::SectionPairRowListValueArgumentEvaluator{_data}.evaluate();
   ::std::string::size_type separatorPosition = _data.find(':');
   ::std::string newLine = this->parameter.getNewLine();
 

test/cases/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluatorTest.cpp

@@ -0,0 +1,70 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-02-20
+* Changed:         2023-02-20
+*
+* */
+
+#include <gtest/gtest.h>
+#include <ls-std/ls-std-core.hpp>
+#include <ls-std/ls-std-io.hpp>
+#include <string>
+
+using namespace ls::std::core;
+using namespace ls::std::io;
+using namespace ::std;
+
+namespace
+{
+  class SectionPairRowListValueArgumentEvaluatorTest : public ::testing::Test
+  {
+    protected:
+
+      SectionPairRowListValueArgumentEvaluatorTest() = default;
+      ~SectionPairRowListValueArgumentEvaluatorTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  class SectionPairRowListValueArgumentEvaluatorNotValidTest : public ::testing::TestWithParam<string>
+  {
+    protected:
+
+      SectionPairRowListValueArgumentEvaluatorNotValidTest() = default;
+      ~SectionPairRowListValueArgumentEvaluatorNotValidTest() override = default;
+  };
+
+  TEST_F(SectionPairRowListValueArgumentEvaluatorTest, getClassName)
+  {
+    shared_ptr<SectionPairRowListValueArgumentEvaluator> evaluator = make_shared<SectionPairRowListValueArgumentEvaluator>("color=blue");
+    ASSERT_STREQ("SectionPairRowListValueArgumentEvaluator", evaluator->getClassName().c_str());
+  }
+
+  TEST_P(SectionPairRowListValueArgumentEvaluatorNotValidTest, evaluate)
+  {
+    EXPECT_THROW(
+        {
+          try
+          {
+            SectionPairRowListValueArgumentEvaluator(GetParam()).evaluate();
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            ::std::string actual = _exception.what();
+            ::std::string expected = "IllegalArgumentException thrown - \"" + GetParam() + "\" is not a valid section pair list value row!";
+
+            ASSERT_STREQ(expected.c_str(), actual.c_str());
+            throw;
+          }
+        },
+        IllegalArgumentException);
+  }
+
+  INSTANTIATE_TEST_SUITE_P(SectionPairRowListValueArgumentEvaluatorTest, SectionPairRowListValueArgumentEvaluatorNotValidTest, ::testing::Values("colors:", "colors:\n red", "colors:\r\n  red"));
+}

test/cases/io/section-pair/serialization/SerializableSectionPairRowTest.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-12
-* Changed:         2023-02-19
+* Changed:         2023-02-20
 *
 * */
 
@@ -37,28 +37,36 @@ namespace
       {}
   };
 
-  class SerializableSectionPairRowSerializationLineBreakTest : public ::testing::TestWithParam<string>
+  class SerializableSectionPairRowTest_LineBreakTest : public ::testing::TestWithParam<string>
   {
     protected:
 
-      SerializableSectionPairRowSerializationLineBreakTest() = default;
-      ~SerializableSectionPairRowSerializationLineBreakTest() override = default;
+      SerializableSectionPairRowTest_LineBreakTest() = default;
+      ~SerializableSectionPairRowTest_LineBreakTest() override = default;
   };
 
-  class SerializableSectionPairRowSerializationValidTest : public ::testing::TestWithParam<array<string, 3>>
+  class SerializableSectionPairRowTest_IsValidSingleValueTest : public ::testing::TestWithParam<array<string, 3>>
   {
     protected:
 
-      SerializableSectionPairRowSerializationValidTest() = default;
-      ~SerializableSectionPairRowSerializationValidTest() override = default;
+      SerializableSectionPairRowTest_IsValidSingleValueTest() = default;
+      ~SerializableSectionPairRowTest_IsValidSingleValueTest() override = default;
   };
 
-  class SerializableSectionPairRowSerializationNotValidTest : public ::testing::TestWithParam<string>
+  class SerializableSectionPairRowTest_IsInvalidSingleValueTest : public ::testing::TestWithParam<string>
   {
     protected:
 
-      SerializableSectionPairRowSerializationNotValidTest() = default;
-      ~SerializableSectionPairRowSerializationNotValidTest() override = default;
+      SerializableSectionPairRowTest_IsInvalidSingleValueTest() = default;
+      ~SerializableSectionPairRowTest_IsInvalidSingleValueTest() override = default;
+  };
+
+  class SerializableSectionPairRowTest_IsInvalidListValueTest : public ::testing::TestWithParam<string>
+  {
+    protected:
+
+      SerializableSectionPairRowTest_IsInvalidListValueTest() = default;
+      ~SerializableSectionPairRowTest_IsInvalidListValueTest() override = default;
   };
 
   TEST_F(SerializableSectionPairRowTest, constructor_no_reference)
@@ -96,7 +104,7 @@ namespace
     ASSERT_TRUE(serializable.getValue() != nullptr);
   }
 
-  TEST_P(SerializableSectionPairRowSerializationLineBreakTest, marshal_single_value)
+  TEST_P(SerializableSectionPairRowTest_LineBreakTest, marshal_single_value)
   {
     string newLine = GetParam();
     shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createSingleValueForMarshal(newLine);
@@ -107,7 +115,7 @@ namespace
     ASSERT_STREQ(expected.c_str(), actual.c_str());
   }
 
-  TEST_P(SerializableSectionPairRowSerializationLineBreakTest, marshal_list_value)
+  TEST_P(SerializableSectionPairRowTest_LineBreakTest, marshal_list_value)
   {
     string newLine = GetParam();
     shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createListValueForMarshal(newLine);
@@ -117,7 +125,7 @@ namespace
     ASSERT_STREQ(expected.c_str(), serializable->marshal().c_str());
   }
 
-  TEST_P(SerializableSectionPairRowSerializationLineBreakTest, unmarshal_single_value)
+  TEST_P(SerializableSectionPairRowTest_LineBreakTest, unmarshal_single_value)
   {
     shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createSingleValueForUnmarshal(GetParam());
     serializable->unmarshal("favourite-color=blue");
@@ -127,7 +135,23 @@ namespace
     ASSERT_STREQ("blue", dynamic_pointer_cast<SectionPairRowSingleValue>(row->getValue())->get().c_str());
   }
 
-  TEST_P(SerializableSectionPairRowSerializationValidTest, unmarshal_single_value)
+  TEST_P(SerializableSectionPairRowTest_LineBreakTest, unmarshal_list_value)
+  {
+    string newLine = GetParam();
+    shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createListValueForUnmarshal(newLine);
+
+    string data = "favourite-colors:" + newLine + "  blue" + newLine + "  red" + newLine + "  purple" + newLine;
+    serializable->unmarshal(data);
+    shared_ptr<SectionPairRow> row = dynamic_pointer_cast<SectionPairRow>(serializable->getValue());
+
+    ASSERT_STREQ("favourite-colors", row->getKey().c_str());
+    ASSERT_EQ(3, dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->getSize());
+    ASSERT_STREQ("blue", dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->get(0).c_str());
+    ASSERT_STREQ("red", dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->get(1).c_str());
+    ASSERT_STREQ("purple", dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->get(2).c_str());
+  }
+
+  TEST_P(SerializableSectionPairRowTest_IsValidSingleValueTest, unmarshal_single_value)
   {
     shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createSingleValueForUnmarshal(NewLine::getWindowsNewLine());
     serializable->unmarshal(GetParam().at(0));
@@ -137,7 +161,7 @@ namespace
     ASSERT_STREQ(GetParam().at(2).c_str(), dynamic_pointer_cast<SectionPairRowSingleValue>(row->getValue())->get().c_str());
   }
 
-  TEST_P(SerializableSectionPairRowSerializationNotValidTest, unmarshal_single_value)
+  TEST_P(SerializableSectionPairRowTest_IsInvalidSingleValueTest, unmarshal_single_value)
   {
     shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createSingleValueForUnmarshal(NewLine::get());
 
@@ -155,23 +179,26 @@ namespace
         IllegalArgumentException);
   }
 
-  TEST_P(SerializableSectionPairRowSerializationLineBreakTest, unmarshal_list_value)
+  TEST_P(SerializableSectionPairRowTest_IsInvalidListValueTest, unmarshal_list_value)
   {
-    string newLine = GetParam();
-    shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createListValueForUnmarshal(newLine);
+    shared_ptr<SerializableSectionPairRow> serializable = SerializableSectionPairRowProvider::createListValueForUnmarshal(NewLine::get());
 
-    string data = "favourite-colors:" + newLine + "  blue" + newLine + "  red" + newLine + "  purple" + newLine;
-    serializable->unmarshal(data);
-    shared_ptr<SectionPairRow> row = dynamic_pointer_cast<SectionPairRow>(serializable->getValue());
-
-    ASSERT_STREQ("favourite-colors", row->getKey().c_str());
-    ASSERT_EQ(3, dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->getSize());
-    ASSERT_STREQ("blue", dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->get(0).c_str());
-    ASSERT_STREQ("red", dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->get(1).c_str());
-    ASSERT_STREQ("purple", dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->get(2).c_str());
+    EXPECT_THROW(
+        {
+          try
+          {
+            serializable->unmarshal(GetParam());
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
-  INSTANTIATE_TEST_SUITE_P(SerializableSectionPairRowTest, SerializableSectionPairRowSerializationLineBreakTest, ::testing::Values(NewLine::getUnixNewLine(), NewLine::getWindowsNewLine()));
-  INSTANTIATE_TEST_SUITE_P(SerializableSectionPairRowTest, SerializableSectionPairRowSerializationValidTest, ::testing::Values(array<string, 3>{"favourite-color=blue", "favourite-color", "blue"}, array<string, 3>{"hair-color=red" + NewLine::getWindowsNewLine(), "hair-color", "red"}));
-  INSTANTIATE_TEST_SUITE_P(SerializableSectionPairRowTest, SerializableSectionPairRowSerializationNotValidTest, ::testing::Values("favourite-color", "color="));
+  INSTANTIATE_TEST_SUITE_P(LineBreakTest, SerializableSectionPairRowTest_LineBreakTest, ::testing::Values(NewLine::getUnixNewLine(), NewLine::getWindowsNewLine()));
+  INSTANTIATE_TEST_SUITE_P(IsValidSingleValueTest, SerializableSectionPairRowTest_IsValidSingleValueTest, ::testing::Values(array<string, 3>{"favourite-color=blue", "favourite-color", "blue"}, array<string, 3>{"hair-color=red" + NewLine::getWindowsNewLine(), "hair-color", "red"}));
+  INSTANTIATE_TEST_SUITE_P(IsInvalidSingleValueTest, SerializableSectionPairRowTest_IsInvalidSingleValueTest, ::testing::Values("favourite-color", "color="));
+  INSTANTIATE_TEST_SUITE_P(IsInvalidListValueTest, SerializableSectionPairRowTest_IsInvalidListValueTest, ::testing::Values("favourite-color:\n", "colors:\r\n  blue"));
 }