Add operators to LogLevel class

- add more operators to LogLevel class
- add test coverage for LogLevel class
- improve error handling in LogLevel class

CMakeLists.txt

@@ -179,7 +179,8 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/IncompleteJsonExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/NullPointerExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/io/xml/XmlParserTestWrapper.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/base/LibraryVersionTest.cpp)
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/base/LibraryVersionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LogLevelTest.cpp)
 endif ()
 
 ##########################################################

include/ls_std/io/logging/LogLevel.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -26,8 +26,14 @@ namespace ls_std
 
       operator unsigned char() const;
       ls_std::LogLevel &operator=(const ls_std::LogLevelValue &_value);
+      bool operator<(const ls_std::LogLevelValue &_value);
       bool operator<=(const ls_std::LogLevelValue &_value);
+      bool operator>(const ls_std::LogLevelValue &_value);
+      bool operator>=(const ls_std::LogLevelValue &_value);
+      bool operator==(const ls_std::LogLevelValue &_value);
 
+      void setLogLevel(const ls_std::LogLevelValue &_value);
+      void setLogLevel(const std::string &_value);
       std::string toString() const;
 
     private:
@@ -35,7 +41,9 @@ namespace ls_std
       std::unordered_map<uint8_t, std::string> level{};
       ls_std::LogLevelValue value{};
 
+      ls_std::LogLevelValue _getValueFromString(const std::string &_value);
       void _init();
+      bool _isValidLogLevelString(const std::string &_value);
   };
 }
 

include/ls_std/io/logging/LogLevelValue.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -14,7 +14,7 @@ namespace ls_std
 {
   enum LogLevelValue
   {
-    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE, OFF
+    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
   };
 }
 

source/ls_std/io/logging/LogLevel.cpp

@@ -3,11 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
 #include <ls_std/io/logging/LogLevel.hpp>
+#include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::LogLevel::LogLevel(const ls_std::LogLevelValue &_value)
     : ls_std::Class("LogLevel"),
@@ -16,8 +17,10 @@ ls_std::LogLevel::LogLevel(const ls_std::LogLevelValue &_value)
   this->_init();
 }
 
-ls_std::LogLevel::LogLevel() : Class("LogLevel")
-{}
+ls_std::LogLevel::LogLevel() : ls_std::Class("LogLevel")
+{
+  this->_init();
+}
 
 ls_std::LogLevel::operator unsigned char() const
 {
@@ -30,16 +33,69 @@ ls_std::LogLevel &ls_std::LogLevel::operator=(const ls_std::LogLevelValue &_valu
   return *this;
 }
 
+bool ls_std::LogLevel::operator<(const ls_std::LogLevelValue &_value)
+{
+  return this->value < _value;
+}
+
 bool ls_std::LogLevel::operator<=(const ls_std::LogLevelValue &_value)
 {
   return this->value <= _value;
 }
 
+bool ls_std::LogLevel::operator>(const ls_std::LogLevelValue &_value)
+{
+  return this->value > _value;
+}
+
+bool ls_std::LogLevel::operator>=(const ls_std::LogLevelValue &_value)
+{
+  return this->value >= _value;
+}
+
+bool ls_std::LogLevel::operator==(const ls_std::LogLevelValue &_value)
+{
+  return this->value == _value;
+}
+
+void ls_std::LogLevel::setLogLevel(const ls_std::LogLevelValue &_value)
+{
+  this->value = _value;
+}
+
+void ls_std::LogLevel::setLogLevel(const std::string &_value)
+{
+  if (this->_isValidLogLevelString(_value))
+  {
+    this->value = _getValueFromString(_value);
+  }
+  else
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+}
+
 std::string ls_std::LogLevel::toString() const
 {
   return this->level.at(this->value);
 }
 
+ls_std::LogLevelValue ls_std::LogLevel::_getValueFromString(const std::string &_value)
+{
+  ls_std::LogLevelValue logLevelValue{};
+
+  for (const auto &logLevelString : this->level)
+  {
+    if (logLevelString.second == _value)
+    {
+      logLevelValue = (ls_std::LogLevelValue) logLevelString.first;
+      break;
+    }
+  }
+
+  return logLevelValue;
+}
+
 void ls_std::LogLevel::_init()
 {
   this->level.insert({ls_std::LogLevelValue::FATAL, "FATAL"});
@@ -48,5 +104,21 @@ void ls_std::LogLevel::_init()
   this->level.insert({ls_std::LogLevelValue::INFO, "INFO"});
   this->level.insert({ls_std::LogLevelValue::DEBUG, "DEBUG"});
   this->level.insert({ls_std::LogLevelValue::TRACE, "TRACE"});
-  this->level.insert({ls_std::LogLevelValue::OFF, "OFF"});
+}
+
+bool ls_std::LogLevel::_isValidLogLevelString(const std::string &_value)
+{
+  bool isValidString{};
+
+  for (const auto &logLevelString : this->level)
+  {
+    isValidString = logLevelString.second == _value;
+
+    if (isValidString)
+    {
+      break;
+    }
+  }
+
+  return isValidString;
 }

test/cases/io/logging/LogLevelTest.cpp

@@ -0,0 +1,177 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-05-02
+ * Changed:         2021-05-02
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std.hpp>
+
+namespace
+{
+  class LogLevelTest : public ::testing::Test
+  {
+    protected:
+
+      LogLevelTest() = default;
+      ~LogLevelTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(LogLevelTest, constructor_withLogLevelValueParameter)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::INFO};
+    ASSERT_EQ(ls_std::LogLevelValue::INFO, logLevel);
+  }
+
+  TEST_F(LogLevelTest, constructor_default)
+  {
+    ls_std::LogLevel logLevel{};
+    ASSERT_EQ(ls_std::LogLevelValue::FATAL, logLevel);
+  }
+
+  TEST_F(LogLevelTest, operator_assign)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::DEBUG};
+    logLevel = ls_std::LogLevelValue::INFO;
+
+    ASSERT_EQ(ls_std::LogLevelValue::INFO, logLevel);
+  }
+
+  TEST_F(LogLevelTest, operator_lessThan)
+  {
+    ls_std::LogLevel logLevel{}; // default is FATAL
+
+    ASSERT_TRUE(logLevel < ls_std::LogLevelValue::ERR);
+    ASSERT_TRUE(logLevel < ls_std::LogLevelValue::WARN);
+    ASSERT_TRUE(logLevel < ls_std::LogLevelValue::INFO);
+    ASSERT_TRUE(logLevel < ls_std::LogLevelValue::DEBUG);
+    ASSERT_TRUE(logLevel < ls_std::LogLevelValue::TRACE);
+  }
+
+  TEST_F(LogLevelTest, operator_lessThan_notLessThan)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::DEBUG};
+    ASSERT_FALSE(logLevel < ls_std::LogLevelValue::ERR);
+  }
+
+  TEST_F(LogLevelTest, operator_lessThanEqual)
+  {
+    ls_std::LogLevel logLevel{}; // default is FATAL
+
+    ASSERT_TRUE(logLevel <= ls_std::LogLevelValue::FATAL);
+    ASSERT_TRUE(logLevel <= ls_std::LogLevelValue::ERR);
+    ASSERT_TRUE(logLevel <= ls_std::LogLevelValue::WARN);
+    ASSERT_TRUE(logLevel <= ls_std::LogLevelValue::INFO);
+    ASSERT_TRUE(logLevel <= ls_std::LogLevelValue::DEBUG);
+    ASSERT_TRUE(logLevel <= ls_std::LogLevelValue::TRACE);
+  }
+
+  TEST_F(LogLevelTest, operator_lessThanEqual_notLessThanEqual)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::DEBUG};
+    ASSERT_FALSE(logLevel <= ls_std::LogLevelValue::ERR);
+  }
+
+  TEST_F(LogLevelTest, operator_greaterThan)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::DEBUG};
+    ASSERT_TRUE(logLevel > ls_std::LogLevelValue::ERR);
+  }
+
+  TEST_F(LogLevelTest, operator_greaterThan_notGreaterThan)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::DEBUG};
+    ASSERT_FALSE(logLevel > ls_std::LogLevelValue::DEBUG);
+  }
+
+  TEST_F(LogLevelTest, operator_greaterThanEqual)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::DEBUG};
+    ASSERT_TRUE(logLevel >= ls_std::LogLevelValue::ERR);
+  }
+
+  TEST_F(LogLevelTest, operator_greaterThanEqual_notGreaterThanEqual)
+  {
+    ls_std::LogLevel logLevel{};
+    ASSERT_FALSE(logLevel >= ls_std::LogLevelValue::ERR);
+  }
+
+  TEST_F(LogLevelTest, operator_equals)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::DEBUG};
+    ASSERT_TRUE(logLevel == ls_std::LogLevelValue::DEBUG);
+  }
+
+  TEST_F(LogLevelTest, operator_equals_notEquals)
+  {
+    ls_std::LogLevel logLevel{ls_std::LogLevelValue::TRACE};
+    ASSERT_FALSE(logLevel == ls_std::LogLevelValue::DEBUG);
+  }
+
+  TEST_F(LogLevelTest, setLogLevel_logLevelValue)
+  {
+    ls_std::LogLevel logLevel{};
+    logLevel.setLogLevel(ls_std::LogLevelValue::INFO);
+
+    ASSERT_EQ(ls_std::LogLevelValue::INFO, logLevel);
+  }
+
+  TEST_F(LogLevelTest, setLogLevel_string)
+  {
+    ls_std::LogLevel logLevel{};
+
+    logLevel.setLogLevel("FATAL");
+    ASSERT_EQ(ls_std::LogLevelValue::FATAL, logLevel);
+    logLevel.setLogLevel("ERROR");
+    ASSERT_EQ(ls_std::LogLevelValue::ERR, logLevel);
+    logLevel.setLogLevel("WARN");
+    ASSERT_EQ(ls_std::LogLevelValue::WARN, logLevel);
+    logLevel.setLogLevel("INFO");
+    ASSERT_EQ(ls_std::LogLevelValue::INFO, logLevel);
+    logLevel.setLogLevel("DEBUG");
+    ASSERT_EQ(ls_std::LogLevelValue::DEBUG, logLevel);
+    logLevel.setLogLevel("TRACE");
+    ASSERT_EQ(ls_std::LogLevelValue::TRACE, logLevel);
+  }
+
+  TEST_F(LogLevelTest, setLogLevel_string_noValidString)
+  {
+    ls_std::LogLevel logLevel{};
+
+    EXPECT_THROW({
+                   try
+                   {
+                     logLevel.setLogLevel("This is not a valid log level!");
+                   }
+                   catch (const ls_std::IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::IllegalArgumentException);
+  }
+
+  TEST_F(LogLevelTest, toString)
+  {
+    ls_std::LogLevel logLevel{};
+    ASSERT_STREQ("FATAL", logLevel.toString().c_str());
+    logLevel.setLogLevel(ls_std::LogLevelValue::ERR);
+    ASSERT_STREQ("ERROR", logLevel.toString().c_str());
+    logLevel.setLogLevel(ls_std::LogLevelValue::WARN);
+    ASSERT_STREQ("WARN", logLevel.toString().c_str());
+    logLevel.setLogLevel(ls_std::LogLevelValue::INFO);
+    ASSERT_STREQ("INFO", logLevel.toString().c_str());
+    logLevel.setLogLevel(ls_std::LogLevelValue::DEBUG);
+    ASSERT_STREQ("DEBUG", logLevel.toString().c_str());
+    logLevel.setLogLevel(ls_std::LogLevelValue::TRACE);
+    ASSERT_STREQ("TRACE", logLevel.toString().c_str());
+  }
+}