add test (doctest)

CMakeLists.txt

@@ -16,6 +16,26 @@ set(ADC_DEVICE_HEADERS
     device/adc_device_command.h
 )
 
+option(BUILD_TESTS "Buiuld tests" ON)
+
+if (BUILD_TESTS)
+    find_package(doctest)
+
+    set(VALUEHOLDER_TEST_APP adc_valueholder_test)
+    add_executable(${VALUEHOLDER_TEST_APP} tests/adc_valueholder_test.cpp)
+
+    if (NOT doctest_FOUND)
+        include(FetchContent)
+        FetchContent_Declare(
+            doctest
+            GIT_REPOSITORY https://github.com/doctest/doctest.git
+            GIT_TAG 2.4.11
+        )
+        FetchContent_MakeAvailable(doctest)
+    endif()
+
+    target_link_libraries(${VALUEHOLDER_TEST_APP} PRIVATE doctest::doctest)
+endif(BUILD_TESTS)
 
 include(GNUInstallDirs)
 

common/adc_value_holder.h

@@ -97,7 +97,8 @@ class AdcValueHolder
 {
 protected:
     template <typename T>
-    using arg_t = typename traits::adc_func_traits<T>::ret_t;
+    // using arg_t = typename traits::adc_func_traits<T>::ret_t;
+    using arg_t = typename traits::adc_func_traits<std::remove_reference_t<T>>::ret_t;
 
     std::function<void(std::any&)> _getterWrapper;
     std::function<void(const std::any&)> _setterWrapper;
@@ -113,7 +114,7 @@ protected:
     {
         using value_t = arg_t<decltype(getter)>;
 
-        static_assert(std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");
+        // static_assert(std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");
 
         using g_t = decltype(getter);
         _getterWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<g_t>(getter))](std::any& val) {
@@ -125,7 +126,7 @@ protected:
         using vld_t = decltype(validator);
         using s_t = decltype(setter);
 
-        if constexpr (std::is_same_v<vld_t, decltype(AdcValueHolderDummyValidator)>) {  // no validation
+        if constexpr (std::is_same_v<vld_t, decltype(AdcValueHolderDummyValidator<value_t>)>) {  // no validation
             _setterWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<s_t>(setter)), this](const std::any& val) {
                 auto& setter = std::get<0>(wrapper);
 
@@ -160,14 +161,19 @@ public:
     constexpr static std::tuple<char, short, int, long, long long, float, double> _defaultTrivialConvTypes{};
 
     // always-true validator
-    constexpr static auto AdcValueHolderDummyValidator = [](const auto&) { return true; };
+    // constexpr static auto AdcValueHolderDummyValidator = [](const auto&) { return true; };
+    template <typename VT>
+    constexpr static bool AdcValueHolderDummyValidator(const VT&)
+    {
+        return true;
+    };
 
     /*  CONSTRUCTORS AND DESTRUCTOR  */
 
-    AdcValueHolder(
+    AdcValueHolder(std::invocable<> auto&& getter,
-        std::invocable<> auto&& getter,
                    std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
-        std::predicate<const arg_t<decltype(getter)>&> auto&& validator = AdcValueHolder::AdcValueHolderDummyValidator)
+                   std::predicate<const arg_t<decltype(getter)>&> auto&& validator =
+                       AdcValueHolder::AdcValueHolderDummyValidator<arg_t<decltype(getter)>>)
         : _internalTypeIndex(std::type_index(typeid(arg_t<decltype(getter)>)))
     {
         init(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
@@ -176,11 +182,11 @@ public:
 
 
     template <typename... Ts>
-    AdcValueHolder(
+    AdcValueHolder(std::invocable<> auto&& getter,
-        std::invocable<> auto&& getter,
                    std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
                    const std::tuple<Ts...>& trivialConvTypes,
-        std::predicate<const arg_t<decltype(getter)>&> auto&& validator = AdcValueHolder::AdcValueHolderDummyValidator)
+                   std::predicate<const arg_t<decltype(getter)>&> auto&& validator =
+                       AdcValueHolder::AdcValueHolderDummyValidator<arg_t<decltype(getter)>>)
         : AdcValueHolder(std::forward<decltype(getter)>(getter),
                          std::forward<decltype(setter)>(setter),
                          std::forward<decltype(validator)>(validator))

tests/adc_valueholder_test.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+// #include <doctest/doctest.h>
+
+#include "../common/adc_value_holder.h"
+
+// TEST_CASE("[ADC VALUEHOLDER]")
+// {
+//     int ch_i = 10;
+
+//     auto getter = [&ch_i]() { return ch_i; };
+//     auto setter = [&ch_i](const int& v) { ch_i = v; };
+//     auto validator = [&ch_i](const int& v) {
+//         if (v < 0)
+//             return false;
+//          else
+//             return true;
+//     };
+
+//     adc::AdcValueHolder vh(getter, setter, validator);
+// }
+
+
+int main()
+{
+    int ch_i = 10;
+
+    auto getter = [&ch_i]() { return ch_i; };
+    auto setter = [&ch_i](const int& v) { ch_i = v; };
+    auto validator = [&ch_i](const int& v) {
+        if (v < 0)
+            return false;
+        else
+            return true;
+    };
+
+    // adc::AdcValueHolder vh(getter, setter, validator);
+    adc::AdcValueHolder vh(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes, validator);
+
+    vh = 77;
+
+    std::cout << "(vh = 77) => ch_i = " << ch_i << "\n";
+
+    std::cout << (double)vh << "\n";
+}