Rewrite configuration tests in catch2

- Drop s_conf check in operator<< as s_conf cannot be nullptr there
- Add arithmetic type cast to string values

1 files changed, 36 insertions, 18 deletions

diff --git a/lib/configuration/configuration.h b/lib/configuration/configuration.h
index 3d0a49d..9816ab7 100644
--- a/lib/configuration/configuration.h
+++ b/lib/configuration/configuration.h
@@ -17,7 +17,6 @@
 #include <type_traits>
 #include <unordered_map>
 #include <variant>
-#include <vector>
 
 #if defined(__clang__)
 #define consumable(X) [[clang::consumable(X)]]
@@ -41,9 +40,14 @@ class consumable(unconsumed) Configuration : private std::unordered_map<std::str
     friend std::ostream &operator<<(std::ostream &out, const Configuration &obj);
 
 public:
-    return_typestate(unconsumed) explicit Configuration();
-    return_typestate(unconsumed) explicit Configuration(std::initializer_list<std::pair<std::string, conf_value_t>> l) noexcept;
-    return_typestate(unconsumed) explicit Configuration(Configuration && other param_typestate(unconsumed)) = default;
+    return_typestate(unconsumed) Configuration();
+    return_typestate(unconsumed) Configuration(std::initializer_list<std::pair<std::string, conf_value_t>> l) noexcept;
+
+    return_typestate(unconsumed) Configuration(const Configuration &other param_typestate(unconsumed)) = default;
+    Configuration &operator=(const Configuration &) = delete;
+
+    return_typestate(unconsumed) Configuration(Configuration && other param_typestate(unconsumed)) = default;
+    Configuration &operator=(Configuration &&) = delete;
 
     ~Configuration() = default;
 
@@ -53,11 +57,13 @@ public:
     template <typename T>
     callable_when(unconsumed) [[nodiscard]] std::optional<T> value(const char *path) const
     {
-        if(use_global)
+        if(use_global) {
             return instance()->value<T>(path);
+        }
 
-        if(count(path) == 0)
+        if(count(path) == 0) {
             return std::nullopt;
+        }
 
         return std::get<T>(at(path));
     }
@@ -65,8 +71,9 @@ public:
     template <concept_value_t T>
     callable_when(unconsumed) [[nodiscard]] std::optional<T> value(const char *path) const
     {
-        if(use_global)
+        if(use_global) {
             return instance()->value<T>(path);
+        }
 
         if(this->count(path) == 0) {
             return std::nullopt;
@@ -76,35 +83,46 @@ public:
         const auto value = at(path);
 
         if(std::holds_alternative<int>(value)) {
-            if constexpr(std::is_arithmetic<T>::value)
+            if constexpr(std::is_arithmetic<T>::value) {
                 return static_cast<T>(std::get<int>(value));
-            else if constexpr(std::is_constructible<T, std::string>::value)
+            } else if constexpr(std::is_constructible<T, std::string>::value) {
                 return T{ std::to_string(std::get<int>(value)) };
+            }
 
         } else if(std::holds_alternative<bool>(value)) {
-            if constexpr(std::is_constructible<T, bool>::value)
+            if constexpr(std::is_constructible<T, bool>::value) {
                 return std::get<bool>(value);
-            else if constexpr(std::is_constructible<T, const char *>::value) {
-                if(std::get<bool>(value))
-                    return T{ "true" };
-                else
-                    return T{ "false" };
+            } else if constexpr(std::is_constructible<T, const char *>::value) {
+                return std::get<bool>(value) ? T{ "true" } : T{ "false" };
             }
 
         } else if(std::holds_alternative<std::string>(value)) {
             auto str = std::get<std::string>(value);
-            if(str.front() == '~')
+
+            try {
+                if constexpr(std::is_floating_point<T>::value) {
+                    return static_cast<T>(std::stod(str));
+                } else if constexpr(std::is_arithmetic<T>::value) {
+                    return static_cast<T>(std::stol(str));
+                }
+            } catch(std::invalid_argument &) {
+                return std::nullopt;
+            }
+
+            if(str.front() == '~') {
                 str.replace(0, 1, m_homePath);
+            }
 
-            if constexpr(std::is_constructible<T, std::string>::value)
+            if constexpr(std::is_constructible<T, std::string>::value) {
                 return T{ str };
+            }
         }
 
         return std::nullopt;
     }
 
     template <typename T>
-    callable_when(unconsumed) T &shortcut(T &, const char *) const
+    callable_when(unconsumed) T &shortcut(T & /* unused */, const char * /* unused */) const
     {
         return T{};
     }