diff --git a/test/unit_test/static/custom_rep_min_req_test.cpp b/test/unit_test/static/custom_rep_min_req_test.cpp
index 8f7783b8..2f50c244 100644
--- a/test/unit_test/static/custom_rep_min_req_test.cpp
+++ b/test/unit_test/static/custom_rep_min_req_test.cpp
@@ -25,6 +25,7 @@
 #include "units/physical/si/frequency.h"
 #include "units/physical/si/speed.h"
 #include <chrono>
+#include <type_traits>
 #include <utility>
 
 using namespace units;
@@ -172,60 +173,60 @@ using namespace units::physical::si;
 // Quantity from Scalar
 // int <- int
 static_assert(length<metre, int>(expl_impl<int>(1)).count() == 1);
-// static_assert(length<metre, int>(impl_expl<int>(1)).count() == 1);  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, int>, impl_expl<int>>);
 static_assert(length<metre, int>(int(impl_expl<int>(1))).count() == 1);
-// static_assert(length<metre, expl_impl<int>>(1).count() == expl_impl<int>{1});  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, expl_impl<int>>, int>);
 static_assert(length<metre, expl_impl<int>>(expl_impl<int>(1)).count() == expl_impl<int>{1});
 static_assert(length<metre, impl_expl<int>>(1).count() == impl_expl<int>{1});
 
 // double <- double
 static_assert(length<metre, double>(expl_impl<double>(1.0)).count() == 1.0);
-// static_assert(length<metre, double>(impl_expl<double>(1.0)).count() == 1.0);  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, double>, impl_expl<double>>);
 static_assert(length<metre, double>(double(impl_expl<double>(1.0))).count() == 1.0);
-// static_assert(length<metre, expl_impl<double>>(1.0).count() == expl_impl<double>{1.0});  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, expl_impl<double>>, double>);
 static_assert(length<metre, expl_impl<double>>(expl_impl<double>(1.0)).count() == expl_impl<double>{1.0});
 static_assert(length<metre, impl_expl<double>>(1.0).count() == impl_expl<double>{1.0});
 
 // double <- int
 static_assert(length<metre, double>(expl_impl<int>(1)).count() == 1.0);
-// static_assert(length<metre, double>(impl_expl<int>(1)).count() == 1.0);  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, double>, impl_expl<int>>);
 static_assert(length<metre, double>(int(impl_expl<int>(1))).count() == 1.0);
-// static_assert(length<metre, expl_impl<double>>(1).count() == expl_impl<double>{1});  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, expl_impl<double>>, int>);
 static_assert(length<metre, expl_impl<double>>(expl_impl<double>(1)).count() == expl_impl<double>{1});
 static_assert(length<metre, impl_expl<double>>(1).count() == impl_expl<double>{1.0});
 
 // int <- double
-// static_assert(length<metre, int>(expl_impl<double>(1.0)).count() == 1); // should not compile (truncating conversion)
-// static_assert(length<metre, impl_expl<int>>(1.0).count() == impl_expl<int>{1});   // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<metre, int>, expl_impl<double>>);
+static_assert(!std::is_constructible_v<length<metre, impl_expl<int>>, double>);
 
 // Quantity from other Quantity with different Rep
 // int <- int
 static_assert(length<metre, int>(length<metre, expl_impl<int>>(expl_impl<int>(1))).count() == 1);
-// static_assert(length<metre, int>(length<metre, impl_expl<int>>(1)).count() == 1);  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, int>, length<metre, impl_expl<int>>>);
 static_assert(length<metre, int>(quantity_cast<int>(length<metre, impl_expl<int>>(1))).count() == 1);
-// static_assert(length<metre, expl_impl<int>>(length<metre, int>(1)).count() == expl_impl<int>{1});  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, expl_impl<int>>, length<metre, int>>);
 static_assert(length<metre, expl_impl<int>>(quantity_cast<expl_impl<int>>(length<metre, int>(1))).count() == expl_impl<int>{1});
 static_assert(length<metre, impl_expl<int>>(length<metre, int>(1)).count() == impl_expl<int>{1});
 
 // double <- double
 static_assert(length<metre, double>(length<metre, expl_impl<double>>(expl_impl<double>(1.0))).count() == 1.0);
-// static_assert(length<metre, double>(length<metre, impl_expl<double>>(1.0)).count() == 1.0);  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, double>, length<metre, impl_expl<double>>>);
 static_assert(length<metre, double>(quantity_cast<double>(length<metre, impl_expl<double>>(1.0))).count() == 1.0);
-// static_assert(length<metre, expl_impl<double>>(length<metre>(1.0).count() == expl_impl<double>{1.0});  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, expl_impl<double>>, length<metre, double>>);
 static_assert(length<metre, expl_impl<double>>(quantity_cast<expl_impl<double>>(length<metre>(1.0))).count() == expl_impl<double>{1.0});
 static_assert(length<metre, impl_expl<double>>(length<metre>(1.0)).count() == impl_expl<double>{1.0});
 
 // double <- int
 static_assert(length<metre, double>(length<metre, expl_impl<int>>(expl_impl<int>(1))).count() == 1.0);
-// static_assert(length<metre, double>(length<metre, impl_expl<int>>(1)).count() == 1.0);  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, double>, length<metre, impl_expl<int>>>);
 static_assert(length<metre, double>(quantity_cast<int>(length<metre, impl_expl<int>>(1))).count() == 1.0);
-// static_assert(length<metre, expl_impl<double>>(length<metre, int>(1)).count() == expl_impl<double>{1});  // should not compile (not convertible)
+static_assert(!std::is_constructible_v<length<metre, expl_impl<double>>, length<metre, int>>);
 static_assert(length<metre, expl_impl<double>>(quantity_cast<expl_impl<double>>(length<metre, int>(1))).count() == expl_impl<double>{1});
 static_assert(length<metre, impl_expl<double>>(length<metre, int>(1)).count() == impl_expl<double>{1.0});
 
 // int <- double
-// static_assert(length<metre, int>(length<metre, expl_impl<double>>(1.0)).count() == 1); // should not compile (truncating conversion)
-// static_assert(length<metre, impl_expl<int>>(length<metre, double>(1.0)).count() == impl_expl<int>{1});   // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<metre, int>, length<metre, expl_impl<double>>>);
+static_assert(!std::is_constructible_v<length<metre, impl_expl<int>>, length<metre, double>>);
 
 // unit conversions
 
@@ -236,43 +237,43 @@ static_assert(length<metre, impl_expl<int>>(length<kilometre, impl_expl<int>>(1)
 static_assert(length<metre, expl_impl<int>>(length<kilometre, expl_impl<int>>(expl_impl<int>(1))).count() == expl_impl<int>(1000));
 static_assert(length<metre, expl_expl<int>>(length<kilometre, expl_expl<int>>(expl_expl<int>(1))).count() == expl_expl<int>(1000));
 
-// static_assert(length<kilometre, impl<int>>(length<metre, impl<int>>(2000)).count() == impl<int>(2));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<kilometre, impl<int>>, length<metre, impl<int>>>);
 static_assert(length<kilometre, impl<int>>(quantity_cast<kilometre>(length<metre, impl<int>>(2000))).count() == impl<int>(2));
-// static_assert(length<kilometre, expl<int>>(length<metre, expl<int>>(expl<int>(2000))).count() == expl<int>(2));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<kilometre, expl<int>>, length<metre, expl<int>>>);
 static_assert(length<kilometre, expl<int>>(quantity_cast<kilometre>(length<metre, expl<int>>(expl<int>(2000)))).count() == expl<int>(2));
-// static_assert(length<kilometre, impl_impl<int>>(length<metre, impl_impl<int>>(2000)).count() == impl_impl<int>(2));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<kilometre, impl_impl<int>>, length<metre, impl_impl<int>>>);
 static_assert(length<kilometre, impl_impl<int>>(quantity_cast<kilometre>(length<metre, impl_impl<int>>(2000))).count() == impl_impl<int>(2));
-// static_assert(length<kilometre, impl_expl<int>>(length<metre, impl_expl<int>>(2000)).count() == impl_expl<int>(2));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<kilometre, impl_expl<int>>, length<metre, impl_expl<int>>>);
 static_assert(length<kilometre, impl_expl<int>>(quantity_cast<kilometre>(length<metre, impl_expl<int>>(2000))).count() == impl_expl<int>(2));
-// static_assert(length<kilometre, expl_impl<int>>(length<metre, expl_impl<int>>(expl_impl<int>(2000))).count() == expl_impl<int>(2));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<kilometre, expl_impl<int>>, length<metre, expl_impl<int>>>);
 static_assert(length<kilometre, expl_impl<int>>(quantity_cast<kilometre>(length<metre, expl_impl<int>>(expl_impl<int>(2000)))).count() == expl_impl<int>(2));
-// static_assert(length<kilometre, expl_expl<int>>(length<metre, expl_expl<int>>(expl_expl<int>(2000))).count() == expl_expl<int>(2));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<length<kilometre, expl_expl<int>>, length<metre, expl_expl<int>>>);
 static_assert(length<kilometre, expl_expl<int>>(quantity_cast<kilometre>(length<metre, expl_expl<int>>(expl_expl<int>(2000)))).count() == expl_expl<int>(2));
 
-// static_assert(speed<metre_per_second, impl<int>>(speed<kilometre_per_hour, impl<int>>(72)).count() == impl<int>(20));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<metre_per_second, impl<int>>, speed<kilometre_per_hour, impl<int>>>);
 static_assert(speed<metre_per_second, impl<int>>(quantity_cast<metre_per_second>(speed<kilometre_per_hour, impl<int>>(72))).count() == impl<int>(20));
-// static_assert(speed<metre_per_second, expl<int>>(speed<kilometre_per_hour, expl<int>>(expl(72))).count() == expl<int>(20));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<metre_per_second, expl<int>>, speed<kilometre_per_hour, expl<int>>>);
 static_assert(speed<metre_per_second, expl<int>>(quantity_cast<metre_per_second>(speed<kilometre_per_hour, expl<int>>(expl<int>(72)))).count() == expl<int>(20));
-// static_assert(speed<metre_per_second, impl_impl<int>>(speed<kilometre_per_hour, impl_impl<int>>(72)).count() == impl_impl<int>(20));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<metre_per_second, impl_impl<int>>, speed<kilometre_per_hour, impl_impl<int>>>);
 static_assert(speed<metre_per_second, impl_impl<int>>(quantity_cast<metre_per_second>(speed<kilometre_per_hour, impl_impl<int>>(72))).count() == impl_impl<int>(20));
-// static_assert(speed<metre_per_second, impl_expl<int>>(speed<kilometre_per_hour, impl_expl<int>>(72)).count() == impl_expl<int>(20));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<metre_per_second, impl_expl<int>>, speed<kilometre_per_hour, impl_expl<int>>>);
 static_assert(speed<metre_per_second, impl_expl<int>>(quantity_cast<metre_per_second>(speed<kilometre_per_hour, impl_expl<int>>(72))).count() == impl_expl<int>(20));
-// static_assert(speed<metre_per_second, expl_impl<int>>(speed<kilometre_per_hour, expl_impl<int>>(expl_impl(72))).count() == expl_impl<int>(20));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<metre_per_second, expl_impl<int>>, speed<kilometre_per_hour, expl_impl<int>>>);
 static_assert(speed<metre_per_second, expl_impl<int>>(quantity_cast<metre_per_second>(speed<kilometre_per_hour, expl_impl<int>>(expl_impl<int>(72)))).count() == expl_impl<int>(20));
-// static_assert(speed<metre_per_second, expl_expl<int>>(speed<kilometre_per_hour, expl_expl<int>>(expl_expl(72))).count() == expl_expl<int>(20));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<metre_per_second, expl_expl<int>>, speed<kilometre_per_hour, expl_expl<int>>>);
 static_assert(speed<metre_per_second, expl_expl<int>>(quantity_cast<metre_per_second>(speed<kilometre_per_hour, expl_expl<int>>(expl_expl<int>(72)))).count() == expl_expl<int>(20));
 
-// static_assert(speed<kilometre_per_hour, impl<int>>(speed<metre_per_second, impl<int>>(20)).count() == impl<int>(72));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<kilometre_per_hour, impl<int>>, speed<metre_per_second, impl<int>>>);
 static_assert(speed<kilometre_per_hour, impl<int>>(quantity_cast<kilometre_per_hour>(speed<metre_per_second, impl<int>>(20))).count() == impl<int>(72));
-// static_assert(speed<kilometre_per_hour, expl<int>>(speed<metre_per_second, expl<int>>(expl<int>(20))).count() == expl<int>(72));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<kilometre_per_hour, expl<int>>, speed<metre_per_second, expl<int>>>);
 static_assert(speed<kilometre_per_hour, expl<int>>(quantity_cast<kilometre_per_hour>(speed<metre_per_second, expl<int>>(expl<int>(20)))).count() == expl<int>(72));
-// static_assert(speed<kilometre_per_hour, impl_impl<int>>(speed<metre_per_second, impl_impl<int>>(20)).count() == impl_impl<int>(72));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<kilometre_per_hour, impl_impl<int>>, speed<metre_per_second, impl_impl<int>>>);
 static_assert(speed<kilometre_per_hour, impl_impl<int>>(quantity_cast<kilometre_per_hour>(speed<metre_per_second, impl_impl<int>>(20))).count() == impl_impl<int>(72));
-// static_assert(speed<kilometre_per_hour, impl_expl<int>>(speed<metre_per_second, impl_expl<int>>(20)).count() == impl_expl<int>(72));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<kilometre_per_hour, impl_expl<int>>, speed<metre_per_second, impl_expl<int>>>);
 static_assert(speed<kilometre_per_hour, impl_expl<int>>(quantity_cast<kilometre_per_hour>(speed<metre_per_second, impl_expl<int>>(20))).count() == impl_expl<int>(72));
-// static_assert(speed<kilometre_per_hour, expl_impl<int>>(speed<metre_per_second, expl_impl<int>>(expl_impl<int>(20))).count() == expl_impl<int>(72));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<kilometre_per_hour, expl_impl<int>>, speed<metre_per_second, expl_impl<int>>>);
 static_assert(speed<kilometre_per_hour, expl_impl<int>>(quantity_cast<kilometre_per_hour>(speed<metre_per_second, expl_impl<int>>(expl_impl<int>(20)))).count() == expl_impl<int>(72));
-// static_assert(speed<kilometre_per_hour, expl_expl<int>>(speed<metre_per_second, expl_expl<int>>(expl_expl<int>(20))).count() == expl_expl<int>(72));  // should not compile (truncating conversion)
+static_assert(!std::is_constructible_v<speed<kilometre_per_hour, expl_expl<int>>, speed<metre_per_second, expl_expl<int>>>);
 static_assert(speed<kilometre_per_hour, expl_expl<int>>(quantity_cast<kilometre_per_hour>(speed<metre_per_second, expl_expl<int>>(expl_expl<int>(20)))).count() == expl_expl<int>(72));
 
 }  // namespace