Adapt Catch2 test macros for coverage

Signed-off-by: Julien Jerphanion <[email protected]>

Author: jjerphan

libmamba/tests/src/util/test_cast.cpp

@@ -14,41 +14,11 @@
 
 using namespace mamba::util;
 
-using WidenTypes = std::tuple<
-    // integers
-    std::pair<char, int>,
-    std::pair<unsigned char, int>,
-    std::pair<unsigned char, unsigned int>,
-    std::pair<int, long long int>,
-    std::pair<unsigned int, long long int>,
-    std::pair<unsigned int, unsigned long long int>,
-    // floats
-    std::pair<float, double>,
-    // Mixed
-    std::pair<char, float>,
-    std::pair<unsigned char, float>,
-    std::pair<int, double>,
-    std::pair<unsigned int, double>>;
-
-using OverflowLowestTypes = std::tuple<
-    // integers
-    std::pair<char, unsigned char>,
-    std::pair<char, unsigned int>,
-    std::pair<int, char>,
-    std::pair<int, unsigned long long int>,
-    // floats
-    std::pair<double, float>,
-    // mixed
-    std::pair<double, int>,
-    std::pair<float, char>>;
-
 namespace
 {
-    template <typename T>
+    template <typename From, typename To>
     void check_exact_num_cast_widen()
     {
-        using From = typename T::first_type;
-        using To = typename T::second_type;
         static constexpr auto from_lowest = std::numeric_limits<From>::lowest();
         static constexpr auto from_max = std::numeric_limits<From>::max();
 
@@ -58,38 +28,73 @@ namespace
         REQUIRE(safe_num_cast<To>(from_max) == static_cast<To>(from_max));
     }
 
-    TEMPLATE_LIST_TEST_CASE("Exact num cast widen", "", WidenTypes)
+    TEST_CASE("Exact num cast widen - integers")
     {
-        check_exact_num_cast_widen<TestType>();
+        check_exact_num_cast_widen<char, int>();
+        check_exact_num_cast_widen<unsigned char, int>();
+        check_exact_num_cast_widen<unsigned char, unsigned int>();
+        check_exact_num_cast_widen<int, long long int>();
+        check_exact_num_cast_widen<unsigned int, long long int>();
+        check_exact_num_cast_widen<unsigned int, unsigned long long int>();
     }
 
-    template <typename T>
+    TEST_CASE("Exact num cast widen - floats")
+    {
+        check_exact_num_cast_widen<float, double>();
+    }
+
+    TEST_CASE("Exact num cast widen - mixed")
+    {
+        check_exact_num_cast_widen<char, float>();
+        check_exact_num_cast_widen<unsigned char, float>();
+        check_exact_num_cast_widen<int, double>();
+        check_exact_num_cast_widen<unsigned int, double>();
+    }
+
+    template <typename From, typename To>
     void check_exact_num_cast_narrow()
     {
-        using From = typename T::second_type;  // inversed
-        using To = typename T::first_type;     // inversed
         REQUIRE(safe_num_cast<To>(From(0)) == To(0));
         REQUIRE(safe_num_cast<To>(From(1)) == To(1));
     }
 
-    TEMPLATE_LIST_TEST_CASE("Exact num cast narrow", "", WidenTypes)
+    TEST_CASE("Exact num cast narrow - integers")
     {
-        check_exact_num_cast_narrow<TestType>();
+        check_exact_num_cast_narrow<int, char>();
+        check_exact_num_cast_narrow<unsigned int, unsigned char>();
+        check_exact_num_cast_narrow<long long int, int>();
+        check_exact_num_cast_narrow<unsigned long long int, unsigned int>();
     }
 
-    template <typename T>
+    TEST_CASE("Exact num cast narrow - floats")
+    {
+        check_exact_num_cast_narrow<double, float>();
+    }
+
+    template <typename From, typename To>
     void check_exact_num_cast_overflow()
     {
-        using From = typename T::first_type;
-        using To = typename T::second_type;
         static constexpr auto from_lowest = std::numeric_limits<From>::lowest();
-
         REQUIRE_THROWS_AS(safe_num_cast<To>(from_lowest), std::overflow_error);
     }
 
-    TEMPLATE_LIST_TEST_CASE("Exact num cast overflow", "", OverflowLowestTypes)
+    TEST_CASE("Exact num cast overflow - integers")
+    {
+        check_exact_num_cast_overflow<char, unsigned char>();
+        check_exact_num_cast_overflow<char, unsigned int>();
+        check_exact_num_cast_overflow<int, char>();
+        check_exact_num_cast_overflow<int, unsigned long long int>();
+    }
+
+    TEST_CASE("Exact num cast overflow - floats")
+    {
+        check_exact_num_cast_overflow<double, float>();
+    }
+
+    TEST_CASE("Exact num cast overflow - mixed")
     {
-        check_exact_num_cast_overflow<TestType>();
+        check_exact_num_cast_overflow<double, int>();
+        check_exact_num_cast_overflow<float, char>();
     }
 
     TEST_CASE("precision")