Apply code style to project files

include/ls-std/boxing/String.hpp

@@ -30,7 +30,7 @@ namespace ls::std::boxing
 
       // conversion operator
 
-      operator const char *() const; // do not make explicit!
+      operator const char *() const;  // do not make explicit!
       operator ::std::string() const; // do not make explicit!
 
       // assignment operators

include/ls-std/io/FilePathSeparatorMatch.hpp

@@ -16,10 +16,12 @@ namespace ls::std::io
 {
   struct FilePathSeparatorMatch // TODO: turn to class, rather than keeping it as struct
   {
-    bool operator()(char _char) const
-    {
-      return _char == ls::std::io::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
-    }
+    public:
+
+      bool operator()(char _char) const
+      {
+        return _char == ls::std::io::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+      }
   };
 }
 

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -16,8 +16,10 @@ namespace ls::std::io
 {
   struct KvParseParameter
   {
-    ::std::string::size_type index{};
-    ::std::string line{};
+    public:
+
+      ::std::string::size_type index{};
+      ::std::string line{};
   };
 }
 

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

@@ -10,10 +10,10 @@
 #ifndef LS_STD_LOG_LEVEL_HPP
 #define LS_STD_LOG_LEVEL_HPP
 
-#include <unordered_map>
-#include <ls-std/core/Class.hpp>
 #include "LogLevelValue.hpp"
+#include <ls-std/core/Class.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
+#include <unordered_map>
 
 namespace ls::std::io
 {

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -14,7 +14,12 @@ namespace ls::std::io
 {
   enum LogLevelValue
   {
-    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
+    FATAL = 0,
+    ERR,
+    WARN,
+    INFO,
+    DEBUG,
+    TRACE
   };
 }
 

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

@@ -10,13 +10,13 @@
 #ifndef LS_STD_LOGGER_HPP
 #define LS_STD_LOGGER_HPP
 
-#include <ls-std/core/Class.hpp>
 #include "LogLevel.hpp"
+#include <ls-std/core/Class.hpp>
 #include <ls-std/core/interface/IWriter.hpp>
 #include <ls-std/io/File.hpp>
 #include <ls-std/io/FileOutputStream.hpp>
-#include <string>
 #include <ls-std/os/dynamic-goal.hpp>
+#include <string>
 
 namespace ls::std::io
 {

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-13
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -14,7 +14,11 @@ namespace ls::std::io
 {
   enum XmlParseMode
   {
-    XML_PARSE_MODE_ANALYZE = 0, XML_PARSE_MODE_DECLARATION, XML_PARSE_MODE_OPENING_TAG, XML_PARSE_MODE_VALUE, XML_PARSE_MODE_CLOSING_TAG
+    XML_PARSE_MODE_ANALYZE = 0,
+    XML_PARSE_MODE_DECLARATION,
+    XML_PARSE_MODE_OPENING_TAG,
+    XML_PARSE_MODE_VALUE,
+    XML_PARSE_MODE_CLOSING_TAG
   };
 }
 

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

@@ -3,23 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-17
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
 #ifndef LS_STD_XML_PARSE_DATA_HPP
 #define LS_STD_XML_PARSE_DATA_HPP
 
+#include "XmlNode.hpp"
 #include <cstdint>
 #include <memory>
-#include "XmlNode.hpp"
 
 namespace ls::std::io
 {
   struct XmlParseParameter
   {
-    uint8_t level{};
-    ::std::shared_ptr<ls::std::io::XmlNode> node{};
+    public:
+
+      uint8_t level{};
+      ::std::shared_ptr<ls::std::io::XmlNode> node{};
   };
 }
 

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

@@ -10,12 +10,12 @@
 #ifndef LS_STD_XML_PARSER_HPP
 #define LS_STD_XML_PARSER_HPP
 
-#include <ls-std/core/Class.hpp>
-#include <ls-std/core/types/Types.hpp>
 #include "XmlDocument.hpp"
 #include "XmlParseMode.hpp"
 #include "XmlParseParameter.hpp"
 #include <list>
+#include <ls-std/core/Class.hpp>
+#include <ls-std/core/types/Types.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
 
 namespace ls::std::io

include/ls-std/ls-std-core.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-05-13
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -35,7 +35,7 @@
 #include <ls-std/core/utils/RegexUtils.hpp>
 #include <ls-std/core/utils/StlUtils.hpp>
 #if _WIN32
-#include <ls-std/core/utils/WindowsUtils.hpp>
+  #include <ls-std/core/utils/WindowsUtils.hpp>
 #endif
 
 #include <ls-std/core/Class.hpp>

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-05-14
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -16,9 +16,9 @@
 #include <ls-std/io/kv/KvParseParameter.hpp>
 #include <ls-std/io/kv/KvParser.hpp>
 
-#include <ls-std/io/logging/Logger.hpp>
 #include <ls-std/io/logging/LogLevel.hpp>
 #include <ls-std/io/logging/LogLevelValue.hpp>
+#include <ls-std/io/logging/Logger.hpp>
 
 #include <ls-std/io/xml/XmlAttribute.hpp>
 #include <ls-std/io/xml/XmlDeclaration.hpp>

include/ls-std/os/dynamic-goal.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-06-29
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -11,10 +11,10 @@
 #define LS_STD_DYNAMIC_GOAL_HPP
 
 #if defined(_WIN32) && defined(_MSC_VER)
-#include <ls-std/os/windows/msvc-dll-definitions.hpp>
+  #include <ls-std/os/windows/msvc-dll-definitions.hpp>
 #endif
 #if defined(unix) || defined(__APPLE__) || defined(_WIN32) && defined(__GNUC__)
-#include <ls-std/os/unix/unix-shared-object-definitions.hpp>
+  #include <ls-std/os/unix/unix-shared-object-definitions.hpp>
 #endif
 
 #endif

include/ls-std/os/windows/msvc-dll-definitions.hpp

@@ -3,15 +3,15 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-06-26
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
 #ifndef LS_STD_MSVC_DLL_DEFINITIONS_HPP
 #define LS_STD_MSVC_DLL_DEFINITIONS_HPP
 
-#define LS_STD_DLL_EXPORT        __declspec(dllexport)
-#define LS_STD_DLL_IMPORT        __declspec(dllimport)
-#define LS_STD_DYNAMIC_GOAL      LS_STD_DLL_EXPORT
+#define LS_STD_DLL_EXPORT __declspec(dllexport)
+#define LS_STD_DLL_IMPORT __declspec(dllimport)
+#define LS_STD_DYNAMIC_GOAL LS_STD_DLL_EXPORT
 
 #endif

source/ls-std/boxing/Boolean.cpp

@@ -11,9 +11,7 @@
 #include <ls-std/boxing/Boolean.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Boolean::Boolean(bool _value)
-    : ls::std::core::Class("Boolean"),
-      value(_value)
+ls::std::boxing::Boolean::Boolean(bool _value) : ls::std::core::Class("Boolean"), value(_value)
 {}
 
 ls::std::boxing::Boolean::Boolean() : ls::std::core::Class("Boolean")

source/ls-std/boxing/Double.cpp

@@ -16,9 +16,7 @@ ls::std::boxing::Double::Double() : ls::std::core::Class("Double")
   this->_assignEpsilon(0.00000001);
 }
 
-ls::std::boxing::Double::Double(double _value)
-    : ls::std::core::Class("Double"),
-      value(_value)
+ls::std::boxing::Double::Double(double _value) : ls::std::core::Class("Double"), value(_value)
 {
   this->_assignEpsilon(0.00000001);
 }

source/ls-std/boxing/Float.cpp

@@ -11,15 +11,10 @@
 #include <ls-std/boxing/Float.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Float::Float()
-    : ls::std::core::Class("Float"),
-      epsilon(0.00001f)
+ls::std::boxing::Float::Float() : ls::std::core::Class("Float"), epsilon(0.00001f)
 {}
 
-ls::std::boxing::Float::Float(float _value)
-    : ls::std::core::Class("Float"),
-      epsilon(0.00001f),
-      value(_value)
+ls::std::boxing::Float::Float(float _value) : ls::std::core::Class("Float"), epsilon(0.00001f), value(_value)
 {}
 
 ls::std::boxing::Float::~Float() = default;

source/ls-std/boxing/Integer.cpp

@@ -10,9 +10,7 @@
 #include <ls-std/boxing/Integer.hpp>
 #include <ls-std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::std::boxing::Integer::Integer(int _value)
-    : ls::std::core::Class("Integer"),
-      value(_value)
+ls::std::boxing::Integer::Integer(int _value) : ls::std::core::Class("Integer"), value(_value)
 {}
 
 ls::std::boxing::Integer::Integer() : ls::std::core::Class("Integer")

source/ls-std/boxing/Long.cpp

@@ -10,9 +10,7 @@
 #include <ls-std/boxing/Long.hpp>
 #include <ls-std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::std::boxing::Long::Long(ls::std::core::type::long_type _value)
-    : ls::std::core::Class("Long"),
-      value(_value)
+ls::std::boxing::Long::Long(ls::std::core::type::long_type _value) : ls::std::core::Class("Long"), value(_value)
 {}
 
 ls::std::boxing::Long::Long() : ls::std::core::Class("Long")

source/ls-std/boxing/String.cpp

@@ -14,9 +14,7 @@
 ls::std::boxing::String::String() : ls::std::core::Class("String")
 {}
 
-ls::std::boxing::String::String(::std::string _value)
-    : ls::std::core::Class("String"),
-      value(::std::move(_value))
+ls::std::boxing::String::String(::std::string _value) : ls::std::core::Class("String"), value(::std::move(_value))
 {}
 
 ls::std::boxing::String::~String() = default;
@@ -181,10 +179,7 @@ bool ls::std::boxing::String::startsWith(const ::std::string &_text)
 {
   ::std::string fillContent{};
 
-  for (size_t iteration{}; iteration < _amount; iteration++)
-  {
-    fillContent += _fillCharacter;
-  }
+  for (size_t iteration{}; iteration < _amount; iteration++) { fillContent += _fillCharacter; }
 
   return fillContent;
 }

source/ls-std/core/Version.cpp

@@ -10,10 +10,7 @@
 #include <ls-std/core/Version.hpp>
 #include <regex>
 
-ls::std::core::Version::Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion)
-    : majorVersion(_majorVersion),
-      minorVersion(_minorVersion),
-      patchVersion(_patchVersion)
+ls::std::core::Version::Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion) : majorVersion(_majorVersion), minorVersion(_minorVersion), patchVersion(_patchVersion)
 {}
 
 ls::std::core::Version::~Version() = default;

source/ls-std/encoding/Base64.cpp

@@ -18,7 +18,7 @@ ls::std::encoding::Base64::~Base64() = default;
 {
   ::std::string encodedString{};
 
-  for(size_t index = 0 ; index < _sequence.size() ; index += 3)
+  for (size_t index = 0; index < _sequence.size(); index += 3)
   {
     ::std::string byteTriple = ls::std::encoding::Base64::_getNextByteTriple(_sequence, index);
     encodedString += ls::std::encoding::Base64::_encodeByteTriple(byteTriple);
@@ -31,7 +31,7 @@ ls::std::encoding::Base64::~Base64() = default;
 {
   ::std::string decodedString{};
 
-  for (int index{} ; index < _sequence.size() ; index += 4)
+  for (int index{}; index < _sequence.size(); index += 4)
   {
     ::std::string quadruple = ls::std::encoding::Base64::_getNextByteQuadruple(_sequence, index);
     decodedString += ls::std::encoding::Base64::_decodeByteQuadruple(quadruple);
@@ -58,7 +58,7 @@ ls::std::encoding::Base64::~Base64() = default;
   return _encodedString;
 }
 
-::std::string ls::std::encoding::Base64::_decodeByteQuadruple(const ::std::string& _quadruple)
+::std::string ls::std::encoding::Base64::_decodeByteQuadruple(const ::std::string &_quadruple)
 {
   ::std::string decodedText{};
   uint8_t shiftValue = 16;
@@ -77,7 +77,7 @@ ls::std::encoding::Base64::~Base64() = default;
   return decodedText;
 }
 
-::std::string ls::std::encoding::Base64::_encodeByteTriple(const ::std::string& _byteTriple)
+::std::string ls::std::encoding::Base64::_encodeByteTriple(const ::std::string &_byteTriple)
 {
   ::std::string encodedText{};
   uint32_t bitStorage = ls::std::encoding::Base64::_toEncodingBitStorage(_byteTriple);
@@ -85,7 +85,7 @@ ls::std::encoding::Base64::~Base64() = default;
   static ::std::unordered_map<uint8_t, char> encodingMap = ls::std::encoding::Base64::_getEncodingMap();
   uint8_t shiftValue = 18;
 
-  for (uint8_t bitMaskIndex = 0 ; bitMaskIndex < 4 ; bitMaskIndex++)
+  for (uint8_t bitMaskIndex = 0; bitMaskIndex < 4; bitMaskIndex++)
   {
     uint32_t extractedBitSequence = ls::std::encoding::Base64::_extractBitSequence(bitMaskStorage[bitMaskIndex], bitStorage);
     extractedBitSequence = extractedBitSequence >> shiftValue;
@@ -103,12 +103,12 @@ uint32_t ls::std::encoding::Base64::_extractBitSequence(uint32_t _bitMask, uint3
 
 uint32_t ls::std::encoding::Base64::_generateBitMask(uint32_t _maskValue, uint8_t _shiftValue)
 {
-  if(_shiftValue == 0)
+  if (_shiftValue == 0)
   {
     return _maskValue;
   }
 
-  if(_shiftValue < 0)
+  if (_shiftValue < 0)
   {
     return _maskValue >> _shiftValue;
   }
@@ -171,7 +171,7 @@ uint32_t ls::std::encoding::Base64::_toDecodingBitStorage(const ::std::string &_
   uint8_t letterCounter = 1;
   ::std::unordered_map<char, uint8_t> decodingMap = ls::std::encoding::Base64::_getDecodingMap();
 
-  for(char letter : _quadruple)
+  for (char letter : _quadruple)
   {
     uint32_t bitMask = ls::std::encoding::Base64::_generateBitMask(decodingMap[(char) letter], (4 - letterCounter) * 6); // must be hardcoded - even in case of less than 4 characters, so that conversion is correct
     ls::std::encoding::Base64::_mergeBitSequence(bitStorage, bitMask);
@@ -186,7 +186,7 @@ uint32_t ls::std::encoding::Base64::_toEncodingBitStorage(const ::std::string &_
   uint32_t bitStorage{};
   uint8_t shiftValue = 16;
 
-  for(char letter : _triple)
+  for (char letter : _triple)
   {
     uint32_t bitMask = ls::std::encoding::Base64::_generateBitMask((uint8_t) letter, shiftValue);
     ls::std::encoding::Base64::_mergeBitSequence(bitStorage, bitMask);

source/ls-std/event/EventHandler.cpp

@@ -10,7 +10,7 @@
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 #include <ls-std/event/EventHandler.hpp>
 
-ls::std::event::EventHandler::EventHandler(const ls::std::core::type::event_id& _id) : ls::std::event::Narrator()
+ls::std::event::EventHandler::EventHandler(const ls::std::core::type::event_id &_id) : ls::std::event::Narrator()
 {
   this->_assignId(_id);
 }

source/ls-std/io/File.cpp

@@ -10,25 +10,23 @@
 #include <algorithm>
 #include <cstdio>
 #ifdef _WIN32
-#include <direct.h>
+  #include <direct.h>
 #endif
 #include <fstream>
 #include <ls-std/core/exception/FileOperationException.hpp>
 #include <ls-std/io/File.hpp>
 #include <ls-std/io/FilePathSeparatorMatch.hpp>
-#include <sys/stat.h>
 #include <sstream>
+#include <sys/stat.h>
 #ifdef _WIN32
-#include <tchar.h>
+  #include <tchar.h>
 #endif
 #if defined(unix) || defined(__APPLE__)
-#include <unistd.h>
+  #include <unistd.h>
 #endif
 #include <vector>
 
-ls::std::io::File::File(::std::string _absoluteFilePath)
-    : ls::std::core::Class("File"),
-      absoluteFilePath(ls::std::io::File::_normalizePath(::std::move(_absoluteFilePath)))
+ls::std::io::File::File(::std::string _absoluteFilePath) : ls::std::core::Class("File"), absoluteFilePath(ls::std::io::File::_normalizePath(::std::move(_absoluteFilePath)))
 {}
 
 ls::std::io::File::~File() = default;
@@ -52,12 +50,12 @@ bool ls::std::io::File::canRead()
 {
   bool readable;
 
-  #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
   readable = ls::std::io::File::_isReadableUnix(this->absoluteFilePath);
-  #endif
-  #ifdef _WIN32
+#endif
+#ifdef _WIN32
   readable = ls::std::io::File::_isReadableWindows(this->absoluteFilePath);
-  #endif
+#endif
 
   return readable;
 }
@@ -116,12 +114,12 @@ bool ls::std::io::File::exists()
 {
   ::std::string workingDirectory{};
 
-  #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
   workingDirectory = ls::std::io::File::_getWorkingDirectoryUnix();
-  #endif
-  #ifdef _WIN32
+#endif
+#ifdef _WIN32
   workingDirectory = ls::std::io::File::_getWorkingDirectoryWindows();
-  #endif
+#endif
 
   return workingDirectory;
 }
@@ -195,7 +193,7 @@ void ls::std::io::File::makeDirectories()
   const char separator = ls::std::io::FilePathSeparator::get();
   ::std::string currentHierarchy{};
 
-  for (const auto &subDirectory: subDirectories)
+  for (const auto &subDirectory : subDirectories)
   {
     currentHierarchy += subDirectory;
 
@@ -298,7 +296,9 @@ bool ls::std::io::File::_equals(ls::std::io::File &_file, ls::std::io::File &_fo
 
 bool ls::std::io::File::_exists(const ::std::string &_path)
 {
-  struct stat _stat{};
+  struct stat _stat
+  {
+  };
   return (stat(_path.c_str(), &_stat) == 0);
 }
 
@@ -309,7 +309,7 @@ bool ls::std::io::File::_exists(const ::std::string &_path)
   const char separator = ls::std::io::FilePathSeparator::get();
   subDirectoryNames.pop_back();
 
-  for (auto const &subDirectoryName: subDirectoryNames)
+  for (auto const &subDirectoryName : subDirectoryNames)
   {
     parent += subDirectoryName + separator;
   }
@@ -362,7 +362,9 @@ bool ls::std::io::File::_exists(const ::std::string &_path)
 bool ls::std::io::File::_isDirectory(const ::std::string &_path)
 {
   bool match{};
-  struct stat _stat{};
+  struct stat _stat
+  {
+  };
 
   if (stat(_path.c_str(), &_stat) == 0)
   {
@@ -378,7 +380,9 @@ bool ls::std::io::File::_isExecutable(const ::std::string &_path)
 
   if (ls::std::io::File::_exists(_path))
   {
-    struct stat _stat{};
+    struct stat _stat
+    {
+    };
 
     if (stat(_path.c_str(), &_stat) == 0)
     {
@@ -392,7 +396,9 @@ bool ls::std::io::File::_isExecutable(const ::std::string &_path)
 bool ls::std::io::File::_isFile(const ::std::string &_path)
 {
   bool match{};
-  struct stat _stat{};
+  struct stat _stat
+  {
+  };
 
   if (stat(_path.c_str(), &_stat) == 0)
   {
@@ -410,7 +416,9 @@ bool ls::std::io::File::_isReadableUnix(const ::std::string &_path)
 
   if (ls::std::io::File::_exists(_path))
   {
-    struct stat _stat{};
+    struct stat _stat
+    {
+    };
 
     if (stat(_path.c_str(), &_stat) == 0)
     {
@@ -455,7 +463,9 @@ bool ls::std::io::File::_isWritable(const ::std::string &_path)
 
   if (ls::std::io::File::_exists(_path))
   {
-    struct stat _stat{};
+    struct stat _stat
+    {
+    };
 
     if (stat(_path.c_str(), &_stat) == 0)
     {
@@ -469,7 +479,9 @@ bool ls::std::io::File::_isWritable(const ::std::string &_path)
 time_t ls::std::io::File::_lastModified(const ::std::string &_path)
 {
   time_t lastModifiedTimeStamp{};
-  struct stat _stat{};
+  struct stat _stat
+  {
+  };
 
   if (stat(_path.c_str(), &_stat) == 0)
   {
@@ -483,12 +495,12 @@ time_t ls::std::io::File::_lastModified(const ::std::string &_path)
 {
   ::std::list<::std::string> filesInDirectory{};
 
-  #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
   filesInDirectory = ls::std::io::File::_listUnix(_path, true);
-  #endif
-  #ifdef _WIN32
+#endif
+#ifdef _WIN32
   filesInDirectory = ls::std::io::File::_listWindows(_path, true);
-  #endif
+#endif
 
   return filesInDirectory;
 }
@@ -497,12 +509,12 @@ time_t ls::std::io::File::_lastModified(const ::std::string &_path)
 {
   ::std::list<::std::string> filesInDirectory{};
 
-  #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
   filesInDirectory = ls::std::io::File::_listUnix(_path, false);
-  #endif
-  #ifdef _WIN32
+#endif
+#ifdef _WIN32
   filesInDirectory = ls::std::io::File::_listWindows(_path, false);
-  #endif
+#endif
 
   return filesInDirectory;
 }
@@ -555,13 +567,13 @@ int ls::std::io::File::_mkdir(const ::std::string &_path)
 {
   int result;
 
-  #ifdef _WIN32
+#ifdef _WIN32
   result = mkdir(_path.c_str());
-  #endif
+#endif
 
-  #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
   result = mkdir(_path.c_str(), 0777);
-  #endif
+#endif
 
   return result;
 }
@@ -603,12 +615,12 @@ int ls::std::io::File::_mkdir(const ::std::string &_path)
 
 void ls::std::io::File::_remove(const ::std::string &_path)
 {
-  #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
   ls::std::io::File::_removeUnix(_path);
-  #endif
-  #ifdef _WIN32
+#endif
+#ifdef _WIN32
   ls::std::io::File::_removeWindows(_path);
-  #endif
+#endif
 }
 
 #if defined(unix) || defined(__APPLE__)
@@ -639,13 +651,13 @@ bool ls::std::io::File::_renameTo(const ::std::string &_oldName, const ::std::st
   static const char unixSeparator = ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
   static const char windowsSeparator = ls::std::io::FilePathSeparator::getWindowsFilePathSeparator();
 
-  #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
   ::std::replace(_path.begin(), _path.end(), windowsSeparator, unixSeparator);
-  #endif
+#endif
 
-  #ifdef _WIN32
+#ifdef _WIN32
   ::std::replace(_path.begin(), _path.end(), unixSeparator, windowsSeparator);
-  #endif
+#endif
 
   return _path;
 }

source/ls-std/io/FileOutputStream.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -11,17 +11,12 @@
 #include <ls-std/core/exception/FileOperationException.hpp>
 #include <ls-std/io/FileOutputStream.hpp>
 
-ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file)
-    : ls::std::core::Class("FileOutputStream"),
-      file(_file)
+ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file) : ls::std::core::Class("FileOutputStream"), file(_file)
 {
   this->_init();
 }
 
-ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file, bool _append)
-    : ls::std::core::Class("FileOutputStream"),
-      append(_append),
-      file(_file)
+ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file, bool _append) : ls::std::core::Class("FileOutputStream"), append(_append), file(_file)
 {
   this->_init();
 }

source/ls-std/io/FileWriter.cpp

@@ -12,9 +12,7 @@
 #include <ls-std/core/exception/FileOperationException.hpp>
 #include <ls-std/io/FileWriter.hpp>
 
-ls::std::io::FileWriter::FileWriter(ls::std::io::File &_file)
-    : ls::std::core::Class("FileWriter"),
-      file(_file)
+ls::std::io::FileWriter::FileWriter(ls::std::io::File &_file) : ls::std::core::Class("FileWriter"), file(_file)
 {
   ls::std::io::FileWriter::_init(_file);
 }

source/ls-std/io/kv/KvFileReader.cpp

@@ -12,9 +12,7 @@
 #include <ls-std/io/kv/KvFileReader.hpp>
 #include <ls-std/io/kv/KvParser.hpp>
 
-ls::std::io::KvFileReader::KvFileReader(const ::std::shared_ptr<ls::std::io::KvDocument> &_document, const ::std::string &_absolutePath)
-    : ls::std::core::Class("KvFileReader"),
-      kvFile(ls::std::io::File{""})
+ls::std::io::KvFileReader::KvFileReader(const ::std::shared_ptr<ls::std::io::KvDocument> &_document, const ::std::string &_absolutePath) : ls::std::core::Class("KvFileReader"), kvFile(ls::std::io::File{""})
 {
   this->_assignDocument(_document);
   this->_assignFile(ls::std::io::File{_absolutePath});

source/ls-std/io/kv/KvPair.cpp

@@ -10,9 +10,7 @@
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 #include <ls-std/io/kv/KvPair.hpp>
 
-ls::std::io::KvPair::KvPair(const ls::std::core::type::kv_key &_key, ls::std::core::type::kv_value _value)
-    : ls::std::core::Class("KvPair"),
-      value(::std::move(_value))
+ls::std::io::KvPair::KvPair(const ls::std::core::type::kv_key &_key, ls::std::core::type::kv_value _value) : ls::std::core::Class("KvPair"), value(::std::move(_value))
 {
   this->_assignKey(_key);
 }

source/ls-std/io/kv/KvParser.cpp

@@ -8,8 +8,8 @@
  * */
 
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
-#include <ls-std/io/kv/KvParser.hpp>
 #include <ls-std/io/NewLine.hpp>
+#include <ls-std/io/kv/KvParser.hpp>
 
 ls::std::io::KvParser::KvParser(const ::std::shared_ptr<ls::std::io::KvDocument> &_document) : ls::std::core::Class("KvParser")
 {
@@ -48,7 +48,7 @@ bool ls::std::io::KvParser::_contains(const ::std::string &_text, const ::std::s
   return _text.find(_searchText) != ::std::string::npos;
 }
 
-bool ls::std::io::KvParser::_lineHasPair(const ls::std::io::KvParseParameter& _parseParameter)
+bool ls::std::io::KvParser::_lineHasPair(const ls::std::io::KvParseParameter &_parseParameter)
 {
   return ls::std::io::KvParser::_contains(_parseParameter.line, "=") && ls::std::io::KvParser::_contains(_parseParameter.line, ";");
 }
@@ -63,7 +63,7 @@ void ls::std::io::KvParser::_parse(const ls::std::core::type::byte_field &_data)
   }
 }
 
-void ls::std::io::KvParser::_parsePair(const ls::std::io::KvParseParameter& _parseParameter)
+void ls::std::io::KvParser::_parsePair(const ls::std::io::KvParseParameter &_parseParameter)
 {
   if (ls::std::io::KvParser::_lineHasPair(_parseParameter))
   {

source/ls-std/io/logging/LogLevel.cpp

@@ -10,9 +10,7 @@
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 #include <ls-std/io/logging/LogLevel.hpp>
 
-ls::std::io::LogLevel::LogLevel(const ls::std::io::LogLevelValue &_value)
-    : ls::std::core::Class("LogLevel"),
-      value(_value)
+ls::std::io::LogLevel::LogLevel(const ls::std::io::LogLevelValue &_value) : ls::std::core::Class("LogLevel"), value(_value)
 {
   this->_init();
 }

source/ls-std/io/logging/Logger.cpp

@@ -13,12 +13,10 @@
 #include <ls-std/io/NewLine.hpp>
 #include <ls-std/io/logging/Logger.hpp>
 #if defined(_MSC_VER) || defined(__APPLE__)
-#include <sstream>
+  #include <sstream>
 #endif
 
-ls::std::io::Logger::Logger(const ::std::shared_ptr<ls::std::core::interface_type::IWriter> &_writer)
-    : ls::std::core::Class("Logger"),
-      logLevel(ls::std::io::LogLevelValue::INFO)
+ls::std::io::Logger::Logger(const ::std::shared_ptr<ls::std::core::interface_type::IWriter> &_writer) : ls::std::core::Class("Logger"), logLevel(ls::std::io::LogLevelValue::INFO)
 {
   this->_assignWriter(_writer);
 }
@@ -137,7 +135,7 @@ void ls::std::io::Logger::_log(const ls::std::core::type::byte *_data, const ls:
   this->writer->write(message);
 }
 
-::std::string ls::std::io::Logger::_padRight(const ::std::string& _text)
+::std::string ls::std::io::Logger::_padRight(const ::std::string &_text)
 {
   return _text + ls::std::io::Logger::_createFillContent(_text);
 }

source/ls-std/io/xml/XmlAttribute.cpp

@@ -10,7 +10,7 @@
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 #include <ls-std/io/xml/XmlAttribute.hpp>
 
-ls::std::io::XmlAttribute::XmlAttribute(const ::std::string& _name) : ls::std::core::Class("XmlAttribute")
+ls::std::io::XmlAttribute::XmlAttribute(const ::std::string &_name) : ls::std::core::Class("XmlAttribute")
 {
   this->_assignName(_name);
 }
@@ -27,12 +27,12 @@ ls::std::io::XmlAttribute::~XmlAttribute() = default;
   return this->value;
 }
 
-void ls::std::io::XmlAttribute::setName(const ::std::string& _name)
+void ls::std::io::XmlAttribute::setName(const ::std::string &_name)
 {
   this->_assignName(_name);
 }
 
-void ls::std::io::XmlAttribute::setValue(const ::std::string& _value)
+void ls::std::io::XmlAttribute::setValue(const ::std::string &_value)
 {
   this->_assignValue(_value);
 }

source/ls-std/io/xml/XmlDeclaration.cpp

@@ -9,7 +9,7 @@
 
 #include <ls-std/io/xml/XmlDeclaration.hpp>
 
-ls::std::io::XmlDeclaration::XmlDeclaration(const ::std::string& _version) : ls::std::core::Class("XmlDeclaration")
+ls::std::io::XmlDeclaration::XmlDeclaration(const ::std::string &_version) : ls::std::core::Class("XmlDeclaration")
 {
   this->version.setValue(_version);
 }
@@ -31,17 +31,17 @@ ls::std::io::XmlDeclaration::~XmlDeclaration() = default;
   return this->version.getValue();
 }
 
-void ls::std::io::XmlDeclaration::setEncoding(const ::std::string& _encoding)
+void ls::std::io::XmlDeclaration::setEncoding(const ::std::string &_encoding)
 {
   this->encoding.setValue(_encoding);
 }
 
-void ls::std::io::XmlDeclaration::setStandalone(const ::std::string& _standalone)
+void ls::std::io::XmlDeclaration::setStandalone(const ::std::string &_standalone)
 {
   this->standalone.setValue(_standalone);
 }
 
-void ls::std::io::XmlDeclaration::setVersion(const ::std::string& _version)
+void ls::std::io::XmlDeclaration::setVersion(const ::std::string &_version)
 {
   this->version.setValue(_version);
 }

source/ls-std/io/xml/XmlNode.cpp

@@ -11,9 +11,7 @@
 #include <ls-std/core/utils/StlUtils.hpp>
 #include <ls-std/io/xml/XmlNode.hpp>
 
-ls::std::io::XmlNode::XmlNode(::std::string _name)
-    : ls::std::core::Class("XmlNode"),
-      name(::std::move(_name))
+ls::std::io::XmlNode::XmlNode(::std::string _name) : ls::std::core::Class("XmlNode"), name(::std::move(_name))
 {}
 
 ls::std::io::XmlNode::~XmlNode() = default;

source/ls-std/io/xml/XmlParser.cpp

@@ -100,7 +100,7 @@ bool ls::std::io::XmlParser::_contains(const ::std::string &_text, const ::std::
   ::std::shared_ptr<ls::std::io::XmlNode> node = ::std::make_shared<ls::std::io::XmlNode>(_name);
   ::std::shared_ptr<ls::std::io::XmlAttribute> attribute{};
 
-  for (const auto &parsedAttribute: _attributes)
+  for (const auto &parsedAttribute : _attributes)
   {
     attribute = ::std::make_shared<ls::std::io::XmlAttribute>(parsedAttribute.first);
     attribute->setValue(parsedAttribute.second);
@@ -119,7 +119,7 @@ bool ls::std::io::XmlParser::_endsWith(const ::std::string &_text, const ::std::
 {
   ::std::pair<::std::string, ::std::string> attribute{};
 
-  for (const auto &currentAttribute: _attributes)
+  for (const auto &currentAttribute : _attributes)
   {
     if (currentAttribute.first == _name)
     {
@@ -136,7 +136,7 @@ size_t ls::std::io::XmlParser::_findAttributeEndPosition(const ls::std::core::ty
   ::std::string::size_type position = ::std::string::npos;
   ::std::string::size_type counter{};
 
-  for (char letter: _data)
+  for (char letter : _data)
   {
     if (letter == '"')
     {
@@ -269,35 +269,35 @@ void ls::std::io::XmlParser::_parse(const ls::std::core::type::byte_field &_data
       {
         this->_analyze(_data, index);
       }
-        break;
+      break;
       case XML_PARSE_MODE_DECLARATION:
       {
         --index;
         index = this->_parseDeclaration(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
-        break;
+      break;
       case XML_PARSE_MODE_OPENING_TAG:
       {
         --index;
         index = ls::std::io::XmlParser::_parseOpeningTag(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
-        break;
+      break;
       case XML_PARSE_MODE_VALUE:
       {
         --index;
         index = ls::std::io::XmlParser::_parseValue(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
-        break;
+      break;
       case XML_PARSE_MODE_CLOSING_TAG:
       {
         --index;
         index = ls::std::io::XmlParser::_parseClosingTag(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
-        break;
+      break;
     }
   }
 }

source/ls-std/time/Date.cpp

@@ -10,7 +10,7 @@
 #include <iomanip>
 #include <ls-std/time/Date.hpp>
 #if defined(_WIN32) || defined(__APPLE__)
-#include <sstream> // only MSVC and Apple need this
+  #include <sstream> // only MSVC and Apple need this
 #endif
 
 ls::std::time::Date::Date() : ls::std::core::Class("Date")

test/TestHelper.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -14,21 +14,21 @@
 #include <climits>
 #include <fstream>
 #include <ls-std/core/types/Types.hpp>
-#include <stdexcept>
 #include <sstream>
+#include <stdexcept>
 #include <string>
 #if defined(unix) || defined(__APPLE__)
-#include <sys/stat.h>
-#include <unistd.h>
+  #include <sys/stat.h>
+  #include <unistd.h>
 #endif
 #include <vector>
 #ifdef _WIN32
-#include <windows.h>
+  #include <windows.h>
 #endif
 
 namespace ls::std::test
 {
-  class TestHelper
+  class TestHelper // TODO: create source file & move to "classes" location
   {
     public:
 
@@ -77,7 +77,9 @@ namespace ls::std::test
 
       static bool _fileExists(const ::std::string &_path)
       {
-        struct stat _stat{};
+        struct stat _stat
+        {
+        };
         return (stat(_path.c_str(), &_stat) == 0);
       }
 
@@ -85,12 +87,12 @@ namespace ls::std::test
       {
         char separator;
 
-        #ifdef _WIN32
+#ifdef _WIN32
         separator = '\\';
-        #endif
-        #if defined(unix) || defined(__APPLE__)
+#endif
+#if defined(unix) || defined(__APPLE__)
         separator = '/';
-        #endif
+#endif
 
         return separator;
       }
@@ -118,7 +120,7 @@ namespace ls::std::test
         const char separator = ls::std::test::TestHelper::_getFilePathSeparator();
         subDirectoryNames.pop_back();
 
-        for (auto const &subDirectoryName: subDirectoryNames)
+        for (auto const &subDirectoryName : subDirectoryNames)
         {
           parent += subDirectoryName + separator;
         }
@@ -130,17 +132,17 @@ namespace ls::std::test
       {
         ::std::string workingDirectory{};
 
-        #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
         workingDirectory = ls::std::test::TestHelper::_getWorkingDirectoryUnix();
-        #endif
-        #ifdef _WIN32
+#endif
+#ifdef _WIN32
         workingDirectory = ls::std::test::TestHelper::_getWorkingDirectoryWindows();
-        #endif
+#endif
 
         return workingDirectory;
       }
 
-      #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
       static ::std::string _getWorkingDirectoryUnix()
       {
         ::std::string workingDirectory{};
@@ -157,9 +159,9 @@ namespace ls::std::test
 
         return workingDirectory;
       }
-      #endif
+#endif
 
-      #ifdef _WIN32
+#ifdef _WIN32
       static ::std::string _getWorkingDirectoryWindows()
       {
         ::std::string workingDirectory{};
@@ -176,7 +178,7 @@ namespace ls::std::test
 
         return workingDirectory;
       }
-      #endif
+#endif
 
       static ::std::string _normalizePath(::std::string _path)
       {
@@ -218,13 +220,13 @@ namespace ls::std::test
         static const char unixSeparator = '/';
         static const char windowsSeparator = '\\';
 
-        #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
         ::std::replace(_path.begin(), _path.end(), windowsSeparator, unixSeparator);
-        #endif
+#endif
 
-        #ifdef _WIN32
+#ifdef _WIN32
         ::std::replace(_path.begin(), _path.end(), unixSeparator, windowsSeparator);
-        #endif
+#endif
 
         return _path;
       }

test/cases/boxing/BooleanTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -154,16 +154,19 @@ namespace
 
   TEST_F(BooleanTest, parse_with_invalid_parameter)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Boolean expression{};
-                     expression.parse("hello");
-                   } catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Boolean expression{};
+            expression.parse("hello");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(BooleanTest, toString_true)

test/cases/boxing/DoubleTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -348,15 +348,17 @@ namespace
   {
     Double x{};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     x.setEpsilon(0.0);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            x.setEpsilon(0.0);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/boxing/FloatTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -337,15 +337,17 @@ namespace
   {
     Float x{};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     x.setEpsilon(0.0f);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            x.setEpsilon(0.0f);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/boxing/IntegerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -118,32 +118,38 @@ namespace
 
   TEST_F(IntegerTest, operator_div_by_zero_with_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Integer x{9};
-                     Integer y{0};
+    EXPECT_THROW(
+        {
+          try
+          {
+            Integer x{9};
+            Integer y{0};
 
-                     x = x / y;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+            x = x / y;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   TEST_F(IntegerTest, operator_div_by_zero_with_value)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Integer x{9};
-                     x = x / 0;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Integer x{9};
+            x = x / 0;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   TEST_F(IntegerTest, operator_mod_with_reference)
@@ -232,32 +238,38 @@ namespace
 
   TEST_F(IntegerTest, operator_div_assign_by_zero_with_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Integer x{9};
-                     Integer y{0};
+    EXPECT_THROW(
+        {
+          try
+          {
+            Integer x{9};
+            Integer y{0};
 
-                     x = x /= y;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+            x = x /= y;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   TEST_F(IntegerTest, operator_div_assign_by_zero_with_value)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Integer x{9};
-                     x = x /= 0;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Integer x{9};
+            x = x /= 0;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   // comparison operators

test/cases/boxing/LongTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -119,32 +119,38 @@ namespace
 
   TEST_F(LongTest, operator_div_by_zero_with_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Long x{9};
-                     Long y{0};
+    EXPECT_THROW(
+        {
+          try
+          {
+            Long x{9};
+            Long y{0};
 
-                     x = x / y;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+            x = x / y;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   TEST_F(LongTest, operator_div_by_zero_with_value)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Long x{9};
-                     x = x / (type::long_type) 0;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Long x{9};
+            x = x / (type::long_type) 0;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   TEST_F(LongTest, operator_mod_with_reference)
@@ -233,32 +239,38 @@ namespace
 
   TEST_F(LongTest, operator_div_equals_by_zero_with_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Long x{9};
-                     Long y{0};
+    EXPECT_THROW(
+        {
+          try
+          {
+            Long x{9};
+            Long y{0};
 
-                     x = x /= y;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+            x = x /= y;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   TEST_F(LongTest, operator_div_equals_by_zero_with_value)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Long x{9};
-                     x = x /= (type::long_type) 0;
-                   } catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Long x{9};
+            x = x /= (type::long_type) 0;
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 
   // comparison operators

test/cases/boxing/StringTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -45,7 +45,7 @@ namespace
   {
     String greetings{"Hello! "};
     String question{"How are you? "};
-    const string& answer = "I'm good by the way!";
+    const string &answer = "I'm good by the way!";
 
     greetings = greetings + question + answer;
 

test/cases/core/ClassTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-16
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -33,16 +33,18 @@ namespace
 
   TEST_F(ClassTest, constructor_empty_parameter)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Class object{""};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Class object{""};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(ClassTest, destructor)

test/cases/core/exception/EventNotHandledExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-27
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(EventNotHandledExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw EventNotHandledException{};
-                   }
-                   catch (const EventNotHandledException &_exception)
-                   {
-                     EXPECT_STREQ("EventNotHandledException thrown - event was not handled - nothing happened!", _exception.what());
-                     throw;
-                   }
-                 }, EventNotHandledException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw EventNotHandledException{};
+          }
+          catch (const EventNotHandledException &_exception)
+          {
+            EXPECT_STREQ("EventNotHandledException thrown - event was not handled - nothing happened!", _exception.what());
+            throw;
+          }
+        },
+        EventNotHandledException);
   }
 }

test/cases/core/exception/EventNotSubscribedExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-27
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(EventNotSubscribedExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw EventNotSubscribedException{};
-                   }
-                   catch (const EventNotSubscribedException &_exception)
-                   {
-                     EXPECT_STREQ("EventNotSubscribedException thrown - event was not subscribed!", _exception.what());
-                     throw;
-                   }
-                 }, EventNotSubscribedException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw EventNotSubscribedException{};
+          }
+          catch (const EventNotSubscribedException &_exception)
+          {
+            EXPECT_STREQ("EventNotSubscribedException thrown - event was not subscribed!", _exception.what());
+            throw;
+          }
+        },
+        EventNotSubscribedException);
   }
 }

test/cases/core/exception/FileNotFoundExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-01
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(FileNotFoundExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw FileNotFoundException{};
-                   }
-                   catch (const FileNotFoundException &_exception)
-                   {
-                     EXPECT_STREQ("FileNotFoundException thrown - file not found!", _exception.what());
-                     throw;
-                   }
-                 }, FileNotFoundException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw FileNotFoundException{};
+          }
+          catch (const FileNotFoundException &_exception)
+          {
+            EXPECT_STREQ("FileNotFoundException thrown - file not found!", _exception.what());
+            throw;
+          }
+        },
+        FileNotFoundException);
   }
 }

test/cases/core/exception/FileOperationExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-01
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(FileOperationExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw FileOperationException{};
-                   }
-                   catch (const FileOperationException &_exception)
-                   {
-                     EXPECT_STREQ("FileOperationException thrown - file operation failed!", _exception.what());
-                     throw;
-                   }
-                 }, FileOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw FileOperationException{};
+          }
+          catch (const FileOperationException &_exception)
+          {
+            EXPECT_STREQ("FileOperationException thrown - file operation failed!", _exception.what());
+            throw;
+          }
+        },
+        FileOperationException);
   }
 }

test/cases/core/exception/IllegalArgumentExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-01
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(IllegalArgumentExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw IllegalArgumentException{};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     EXPECT_STREQ("IllegalArgumentException thrown - passed argument is not valid!", _exception.what());
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw IllegalArgumentException{};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            EXPECT_STREQ("IllegalArgumentException thrown - passed argument is not valid!", _exception.what());
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/core/exception/IllegalArithmeticOperationExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-01
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(IllegalArithmeticOperationExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw IllegalArithmeticOperationException{};
-                   }
-                   catch (const IllegalArithmeticOperationException &_exception)
-                   {
-                     EXPECT_STREQ("IllegalArithmeticOperationException thrown - arithmetic operation is not allowed!", _exception.what());
-                     throw;
-                   }
-                 }, IllegalArithmeticOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw IllegalArithmeticOperationException{};
+          }
+          catch (const IllegalArithmeticOperationException &_exception)
+          {
+            EXPECT_STREQ("IllegalArithmeticOperationException thrown - arithmetic operation is not allowed!", _exception.what());
+            throw;
+          }
+        },
+        IllegalArithmeticOperationException);
   }
 }

test/cases/core/exception/IncompleteJsonExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-01
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(IncompleteJsonExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw IncompleteJsonException{};
-                   }
-                   catch (const IncompleteJsonException &_exception)
-                   {
-                     EXPECT_STREQ("IncompleteJsonException thrown - this JSON string is incomplete.", _exception.what());
-                     throw;
-                   }
-                 }, IncompleteJsonException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw IncompleteJsonException{};
+          }
+          catch (const IncompleteJsonException &_exception)
+          {
+            EXPECT_STREQ("IncompleteJsonException thrown - this JSON string is incomplete.", _exception.what());
+            throw;
+          }
+        },
+        IncompleteJsonException);
   }
 }

test/cases/core/exception/NullPointerExceptionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-01
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -30,16 +30,18 @@ namespace
 
   TEST_F(NullPointerExceptionTest, constructor)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     throw NullPointerException{};
-                   }
-                   catch (const NullPointerException &_exception)
-                   {
-                     EXPECT_STREQ("NullPointerException thrown - reference is null!", _exception.what());
-                     throw;
-                   }
-                 }, NullPointerException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            throw NullPointerException{};
+          }
+          catch (const NullPointerException &_exception)
+          {
+            EXPECT_STREQ("NullPointerException thrown - reference is null!", _exception.what());
+            throw;
+          }
+        },
+        NullPointerException);
   }
 }

test/cases/event/EventHandlerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -32,16 +32,18 @@ namespace
 
   TEST_F(EventHandlerTest, constructor_empty_parameter)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventHandler eventHandler{""};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventHandler eventHandler{""};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventHandlerTest, getId)

test/cases/event/EventManagerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -41,77 +41,87 @@ namespace
 
   TEST_F(EventManagerTest, subscribe_empty_id)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.subscribe("", make_shared<DailyNewsAgency>());
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.subscribe("", make_shared<DailyNewsAgency>());
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, subscribe_no_listener)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.subscribe("TMP_ID", nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.subscribe("TMP_ID", nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, subscribe_no_event_handler_available)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.subscribe("TMP_DIR", make_shared<DailyNewsAgency>());
-                   }
-                   catch (const EventNotSubscribedException &_exception)
-                   {
-                     throw;
-                   }
-                 }, EventNotSubscribedException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.subscribe("TMP_DIR", make_shared<DailyNewsAgency>());
+          }
+          catch (const EventNotSubscribedException &_exception)
+          {
+            throw;
+          }
+        },
+        EventNotSubscribedException);
   }
 
   TEST_F(EventManagerTest, unsubscribe_empty_id)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.unsubscribe("", make_shared<DailyNewsAgency>());
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.unsubscribe("", make_shared<DailyNewsAgency>());
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, unsubscribe_no_listener)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.unsubscribe("TMP_ID", nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.unsubscribe("TMP_ID", nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, addEventHandler)
@@ -129,32 +139,36 @@ namespace
 
   TEST_F(EventManagerTest, addEventHandler_no_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.addEventHandler(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.addEventHandler(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, fire_event_handler_not_available)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.fire(Event{"TMP_ID"});
-                   }
-                   catch (const EventNotHandledException &_exception)
-                   {
-                     throw;
-                   }
-                 }, EventNotHandledException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.fire(Event{"TMP_ID"});
+          }
+          catch (const EventNotHandledException &_exception)
+          {
+            throw;
+          }
+        },
+        EventNotHandledException);
   }
 
   TEST_F(EventManagerTest, hasEventHandler)
@@ -172,17 +186,19 @@ namespace
 
   TEST_F(EventManagerTest, hasEventHandler_empty_id)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.hasEventHandler("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.hasEventHandler("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, removeEventHandler)
@@ -202,17 +218,19 @@ namespace
 
   TEST_F(EventManagerTest, removeEventHandler_no_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     EventManager eventManager{};
-                     eventManager.removeEventHandler(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            EventManager eventManager{};
+            eventManager.removeEventHandler(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, production_example)
@@ -223,8 +241,8 @@ namespace
 
     // create event handler
 
-    shared_ptr<EventHandler> seriousNewsEventHandler = make_shared<EventHandler>(seriousNewsEventId);   // event id
-    shared_ptr<EventHandler> gossipNewsEventHandler = make_shared<EventHandler>(gossipNewsEventId);     // event id
+    shared_ptr<EventHandler> seriousNewsEventHandler = make_shared<EventHandler>(seriousNewsEventId); // event id
+    shared_ptr<EventHandler> gossipNewsEventHandler = make_shared<EventHandler>(gossipNewsEventId);   // event id
 
     // create and fill event manager with handler
 

test/cases/event/EventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -41,16 +41,18 @@ namespace
 
   TEST_F(EventTest, constructor_empty_parameter)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Event event{""};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Event event{""};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(EventTest, addParameter)
@@ -126,16 +128,18 @@ namespace
 
   TEST_F(EventTest, setId_empty_parameter)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Event event{"TMP_ID"};
-                     event.setId("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Event event{"TMP_ID"};
+            event.setId("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/event/NarratorTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -69,17 +69,19 @@ namespace
 
   TEST_F(NarratorTest, addListener_no_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Narrator paintingMachine{};
-                     paintingMachine.addListener(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Narrator paintingMachine{};
+            paintingMachine.addListener(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(NarratorTest, clear)
@@ -124,17 +126,19 @@ namespace
 
   TEST_F(NarratorTest, removeListener_no_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Narrator paintingMachine{};
-                     paintingMachine.removeListener(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Narrator paintingMachine{};
+            paintingMachine.removeListener(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(NarratorTest, tell)

test/cases/event/serialization/SerializableJsonEventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-20
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -34,16 +34,18 @@ namespace
 
   TEST_F(SerializableJsonEventTest, constructor_parameter_not_set)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     SerializableJsonEvent serializable{nullptr};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            SerializableJsonEvent serializable{nullptr};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(SerializableJsonEventTest, marshal)
@@ -81,15 +83,17 @@ namespace
     Event event{"TMP_EVENT"};
     SerializableJsonEvent serializable{make_shared<Event>(event)};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     serializable.setValue(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            serializable.setValue(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/io/FileOutputStreamTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -38,16 +38,18 @@ namespace
     string path = TestHelper::getResourcesFolderLocation() + "not_existing.txt";
     File file{path};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     FileOutputStream outputStream{file};
-                   }
-                   catch (const FileNotFoundException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileNotFoundException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            FileOutputStream outputStream{file};
+          }
+          catch (const FileNotFoundException &_exception)
+          {
+            throw;
+          }
+        },
+        FileNotFoundException);
   }
 
   TEST_F(FileOutputStreamTest, write)
@@ -96,24 +98,26 @@ namespace
 
   TEST_F(FileOutputStreamTest, write_no_permission_to_write)
   {
-    #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
     File file{TestHelper::getResourcesFolderLocation() + "no-writable.txt"};
-    #endif
-    #ifdef _WIN32
+#endif
+#ifdef _WIN32
     File file{TestHelper::getResourcesFolderLocation() + "no-writable-windows.txt"};
-    #endif
+#endif
 
     FileOutputStream outputStream{file};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     outputStream.write("something");
-                   }
-                   catch (const FileOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            outputStream.write("something");
+          }
+          catch (const FileOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        FileOperationException);
   }
 }

test/cases/io/FileReaderTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -38,16 +38,18 @@ namespace
   {
     File file{TestHelper::getResourcesFolderLocation() + "does_not_exist.txt"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     FileReader reader{file};
-                   }
-                   catch (const FileNotFoundException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileNotFoundException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            FileReader reader{file};
+          }
+          catch (const FileNotFoundException &_exception)
+          {
+            throw;
+          }
+        },
+        FileNotFoundException);
   }
 
   TEST_F(FileReaderTest, read)
@@ -68,16 +70,18 @@ namespace
     FileReader reader{file};
     file.remove();
 
-    EXPECT_THROW({
-                   try
-                   {
-                     byte_field content = reader.read();
-                   }
-                   catch (const FileOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            byte_field content = reader.read();
+          }
+          catch (const FileOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        FileOperationException);
   }
 
   TEST_F(FileReaderTest, reset)

test/cases/io/FileTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -63,12 +63,12 @@ namespace
 
   TEST_F(FileTest, canExecute)
   {
-    #ifdef _WIN32
+#ifdef _WIN32
     File executableFile{TestHelper::getResourcesFolderLocation() + "app.exe"};
-    #endif
-    #if defined(unix) || defined(__APPLE__)
+#endif
+#if defined(unix) || defined(__APPLE__)
     File executableFile{TestHelper::getResourcesFolderLocation() + "app"};
-    #endif
+#endif
 
     ASSERT_TRUE(executableFile.canExecute());
   }
@@ -89,16 +89,18 @@ namespace
   {
     File file{""};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     file.canRead();
-                   }
-                   catch (const FileOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            file.canRead();
+          }
+          catch (const FileOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        FileOperationException);
   }
 
   TEST_F(FileTest, canWrite)
@@ -109,14 +111,14 @@ namespace
 
   TEST_F(FileTest, canWrite_not_writable)
   {
-    #if defined(unix) || defined(__APPLE__)
+#if defined(unix) || defined(__APPLE__)
     File noWritableFile{TestHelper::getResourcesFolderLocation() + "no-writable.txt"};
     ASSERT_FALSE(noWritableFile.canWrite());
-    #endif
-    #ifdef _WIN32
+#endif
+#ifdef _WIN32
     File noWritableFile{TestHelper::getResourcesFolderLocation() + "no-writable-windows.txt"};
     ASSERT_FALSE(noWritableFile.canWrite());
-    #endif
+#endif
   }
 
   TEST_F(FileTest, createNewFile)
@@ -135,16 +137,18 @@ namespace
   {
     File file{TestHelper::getResourcesFolderLocation() + "simple.txt"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     file.createNewFile();
-                   }
-                   catch (const FileOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            file.createNewFile();
+          }
+          catch (const FileOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        FileOperationException);
   }
 
   TEST_F(FileTest, exists)
@@ -306,16 +310,18 @@ namespace
   {
     File directory{TestHelper::getResourcesFolderLocation() + "list-test"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     directory.makeDirectory();
-                   }
-                   catch (const FileOperationException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileOperationException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            directory.makeDirectory();
+          }
+          catch (const FileOperationException &_exception)
+          {
+            throw;
+          }
+        },
+        FileOperationException);
   }
 
   TEST_F(FileTest, makeDirectories)

test/cases/io/FileWriterTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -38,16 +38,18 @@ namespace
     string path = TestHelper::getResourcesFolderLocation() + "not_existing_file.txt";
     File file{path};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     FileWriter writer{file};
-                   }
-                   catch (const FileNotFoundException &_exception)
-                   {
-                     throw;
-                   }
-                 }, FileNotFoundException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            FileWriter writer{file};
+          }
+          catch (const FileNotFoundException &_exception)
+          {
+            throw;
+          }
+        },
+        FileNotFoundException);
   }
 
   TEST_F(FileWriterTest, reset)

test/cases/io/kv/KvFileReaderTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -43,31 +43,35 @@ namespace
 
   TEST_F(KvFileReaderTest, constructor_no_document_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     string kvPath = TestHelper::getResourcesFolderLocation() + "server-settings.kv";
-                     KvFileReader reader = KvFileReader(nullptr, kvPath);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            string kvPath = TestHelper::getResourcesFolderLocation() + "server-settings.kv";
+            KvFileReader reader = KvFileReader(nullptr, kvPath);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(KvFileReaderTest, constructor_invalid_file_path)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     KvFileReader reader = KvFileReader(make_shared<KvDocument>(), "invalid_path");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            KvFileReader reader = KvFileReader(make_shared<KvDocument>(), "invalid_path");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(KvFileReaderTest, getDocument)
@@ -101,16 +105,18 @@ namespace
   {
     const shared_ptr<KvFileReader> &reader = createTestKVFileReader();
 
-    EXPECT_THROW({
-                   try
-                   {
-                     reader->setFile(File{"invalid_path"});
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            reader->setFile(File{"invalid_path"});
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(KvFileReaderTest, setDocument)
@@ -130,15 +136,17 @@ namespace
   {
     const shared_ptr<KvFileReader> &reader = createTestKVFileReader();
 
-    EXPECT_THROW({
-                   try
-                   {
-                     reader->setDocument(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            reader->setDocument(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/io/kv/KvPairTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -33,16 +33,18 @@ namespace
 
   TEST_F(KvPairTest, constructor_with_empty_key)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     KvPair pair = KvPair("", "1989");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            KvPair pair = KvPair("", "1989");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(KvPairTest, getKey)

test/cases/io/kv/KvParserTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -34,16 +34,18 @@ namespace
 
   TEST_F(KvParserTest, constructor_no_document_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     KvParser parser{nullptr};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            KvParser parser{nullptr};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(KvParserTest, getDocument)
@@ -88,15 +90,17 @@ namespace
     shared_ptr<KvDocument> document = make_shared<KvDocument>();
     KvParser parser{document};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     parser.setDocument(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            parser.setDocument(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/io/logging/LogLevelTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-02
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -151,16 +151,18 @@ namespace
   {
     LogLevel logLevel{};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     logLevel.setLogLevel("This is not a valid log level!");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            logLevel.setLogLevel("This is not a valid log level!");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(LogLevelTest, toString)

test/cases/io/logging/LoggerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -61,16 +61,18 @@ namespace
 
   TEST_F(LoggerTest, constructor_no_writer_reference)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     Logger logger{nullptr};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            Logger logger{nullptr};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(LoggerTest, debug)

test/cases/io/xml/XmlAttributeTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -32,16 +32,18 @@ namespace
 
   TEST_F(XmlAttributeTest, constructor_empty_name)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     XmlAttribute attribute{""};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            XmlAttribute attribute{""};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlAttributeTest, getName)
@@ -66,17 +68,19 @@ namespace
 
   TEST_F(XmlAttributeTest, setName_empty_name)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     XmlAttribute attribute{"id"};
-                     attribute.setName("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            XmlAttribute attribute{"id"};
+            attribute.setName("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlAttributeTest, setValue)
@@ -89,17 +93,19 @@ namespace
 
   TEST_F(XmlAttributeTest, setValue_empty_value)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     XmlAttribute attribute{"id"};
-                     attribute.setValue("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            XmlAttribute attribute{"id"};
+            attribute.setValue("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlAttributeTest, toXml)

test/cases/io/xml/XmlDeclarationTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-29
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -32,16 +32,18 @@ namespace
 
   TEST_F(XmlDeclarationTest, constructor_empty_version)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     XmlDeclaration declaration{""};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            XmlDeclaration declaration{""};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlDeclarationTest, getEncoding)
@@ -76,16 +78,18 @@ namespace
   {
     XmlDeclaration declaration{"1.0"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     declaration.setEncoding("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            declaration.setEncoding("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlDeclarationTest, setStandalone)
@@ -102,16 +106,18 @@ namespace
   {
     XmlDeclaration declaration{"1.0"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     declaration.setStandalone("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            declaration.setStandalone("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlDeclarationTest, setVersion)
@@ -129,16 +135,18 @@ namespace
   {
     XmlDeclaration declaration{"1.0"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     declaration.setVersion("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            declaration.setVersion("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlDeclarationTest, toXml)

test/cases/io/xml/XmlDocumentTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-30
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -60,16 +60,18 @@ namespace
   {
     XmlDocument document{};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     document.setDeclaration(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            document.setDeclaration(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlDocumentTest, setRootElement)
@@ -87,16 +89,18 @@ namespace
   {
     XmlDocument document{};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     document.setRootElement(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            document.setRootElement(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlDocumentTest, toXml)

test/cases/io/xml/XmlNodeTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-25
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -78,32 +78,36 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addAttributeAfter(nullptr, "assets");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addAttributeAfter(nullptr, "assets");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addAttributeAfter_empty_name)
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addAttributeAfter(make_shared<XmlAttribute>("id"), "");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addAttributeAfter(make_shared<XmlAttribute>("id"), "");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addAttributeBefore)
@@ -151,32 +155,36 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addAttributeBefore(nullptr, "assets");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addAttributeBefore(nullptr, "assets");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addAttributeBefore_empty_name)
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addAttributeBefore(make_shared<XmlAttribute>("id"), "");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addAttributeBefore(make_shared<XmlAttribute>("id"), "");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addAttributeToBeginning)
@@ -210,16 +218,18 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addAttributeToBeginning(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addAttributeToBeginning(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addAttributeToEnd)
@@ -253,16 +263,18 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addAttributeToEnd(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addAttributeToEnd(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addChildAfter)
@@ -320,32 +332,36 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addChildAfter(nullptr, make_shared<XmlNode>("children"));
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addChildAfter(nullptr, make_shared<XmlNode>("children"));
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addChildAfter_no_search_reference)
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addChildAfter(make_shared<XmlNode>("newChild"), nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addChildAfter(make_shared<XmlNode>("newChild"), nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addChildBefore)
@@ -403,32 +419,36 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addChildBefore(nullptr, make_shared<XmlNode>("children"));
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addChildBefore(nullptr, make_shared<XmlNode>("children"));
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addChildBefore_no_search_reference)
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addChildBefore(make_shared<XmlNode>("newChild"), nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addChildBefore(make_shared<XmlNode>("newChild"), nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addChildToBeginning)
@@ -477,16 +497,18 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addChildToBeginning(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addChildToBeginning(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, addChildToEnd)
@@ -535,16 +557,18 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.addChildToEnd(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.addChildToEnd(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, clearValue)
@@ -626,16 +650,18 @@ namespace
   {
     XmlNode dialogNode{"dialogNode"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.hasAttribute("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.hasAttribute("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, hasChild)
@@ -660,16 +686,18 @@ namespace
   {
     XmlNode dialogNode{"dialogNode"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.hasChild("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.hasChild("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, hasChildV2)
@@ -696,16 +724,18 @@ namespace
     XmlNode dialogNode{"dialog"};
     shared_ptr<XmlNode> searchNode{};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.hasChild(searchNode);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.hasChild(searchNode);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, removeFirstAttribute)
@@ -860,16 +890,18 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.setName("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.setName("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, setValue)
@@ -884,16 +916,18 @@ namespace
   {
     XmlNode dialogNode{"dialog"};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     dialogNode.setValue("");
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            dialogNode.setValue("");
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlNodeTest, toXml)

test/cases/io/xml/XmlParserTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -47,16 +47,18 @@ namespace
   {
     shared_ptr<XmlDocument> document{};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     XmlParser xmlParser{document};
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            XmlParser xmlParser{document};
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlParserTest, read)
@@ -251,15 +253,17 @@ namespace
     shared_ptr<XmlDocument> document = make_shared<XmlDocument>();
     XmlParser xmlParser{document};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     xmlParser.setDocument(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            xmlParser.setDocument(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/cases/io/xml/XmlReaderTest.cpp

@@ -67,16 +67,18 @@ namespace
     shared_ptr<XmlDocument> document = make_shared<XmlDocument>();
     XmlReader xmlReader{document, xmlPath};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     xmlReader.setDocument(nullptr);
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            xmlReader.setDocument(nullptr);
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 
   TEST_F(XmlReaderTest, setFile)
@@ -95,15 +97,17 @@ namespace
     XmlReader xmlReader{make_shared<XmlDocument>(), xmlPath};
     File xmlFile{xmlPath};
 
-    EXPECT_THROW({
-                   try
-                   {
-                     xmlReader.setFile(File{""});
-                   }
-                   catch (const IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, IllegalArgumentException);
+    EXPECT_THROW(
+        {
+          try
+          {
+            xmlReader.setFile(File{""});
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            throw;
+          }
+        },
+        IllegalArgumentException);
   }
 }

test/classes/base/ClassWrapper.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2023-02-03
+ * Changed:         2023-02-04
  *
  * */
 
@@ -19,9 +19,12 @@ namespace ls_std_core_test
   {
     public:
 
-      ClassWrapper() : ls::std::core::Class("ClassWrapper") {};
+      ClassWrapper() : ls::std::core::Class("ClassWrapper"){};
       MOCK_METHOD0(Die, void());
-      ~ClassWrapper() override { Die(); }
+      ~ClassWrapper() override
+      {
+        Die();
+      }
   };
 }
 

test/classes/event/TestDataMercedesCar.cpp

@@ -3,12 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2022-05-14
+ * Changed:         2023-02-04
  *
  * */
 
-#include "Colour.hpp"
 #include "TestDataMercedesCar.hpp"
+#include "Colour.hpp"
 
 ls_std_event_test::TestDataMercedesCar::TestDataMercedesCar() : TestDataCar()
 {