From 2b2f381ad5482d70f93e26141c0db52722b46568 Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Mon, 12 Jun 2023 11:51:18 +0300
Subject: [PATCH] test: `custom_rep_test_min_expl` updated for V2

---
 test/unit_test/static/CMakeLists.txt          |   1 +
 .../static/custom_rep_test_min_expl.cpp       | 147 ++++++++++--------
 2 files changed, 81 insertions(+), 67 deletions(-)

diff --git a/test/unit_test/static/CMakeLists.txt b/test/unit_test/static/CMakeLists.txt
index f5135edb..4af05b6a 100644
--- a/test/unit_test/static/CMakeLists.txt
+++ b/test/unit_test/static/CMakeLists.txt
@@ -35,6 +35,7 @@ add_library(
     chrono_test.cpp
     concepts_test.cpp
     # custom_rep_test_min_expl.cpp
+    custom_rep_test_min_impl.cpp
     dimension_test.cpp
     fixed_string_test.cpp
     fractional_exponent_quantity.cpp
diff --git a/test/unit_test/static/custom_rep_test_min_expl.cpp b/test/unit_test/static/custom_rep_test_min_expl.cpp
index 689c9666..e69af5d9 100644
--- a/test/unit_test/static/custom_rep_test_min_expl.cpp
+++ b/test/unit_test/static/custom_rep_test_min_expl.cpp
@@ -20,9 +20,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#include <units/generic/dimensionless.h>
-#include <units/isq/si/length.h>
-#include <units/isq/si/prefixes.h>
+#include <mp-units/systems/si/units.h>
 #include <ostream>
 #include <type_traits>
 
@@ -43,6 +41,8 @@ template<int Mode = 0>
 class min_expl {
   std::intmax_t value_;
 public:
+  using value_type = std::intmax_t;
+
   // default construction
   min_expl()
     requires(Mode != 1)
@@ -103,6 +103,9 @@ public:
 
 }  // namespace
 
+template<int Mode>
+inline constexpr bool mp_units::is_scalar<min_expl<Mode>> = true;
+
 template<int Mode>
 struct std::common_type<std::intmax_t, min_expl<Mode>> : std::type_identity<min_expl<Mode>> {};
 template<int Mode>
@@ -110,63 +113,68 @@ struct std::common_type<min_expl<Mode>, std::intmax_t> : std::type_identity<min_
 
 namespace {
 
-using namespace units;
-using namespace units::isq::si;
+using namespace mp_units;
 
 // quantity explicitly constructible (not convertible) from the representation type
-static_assert(std::constructible_from<length<metre, min_expl<>>, min_expl<>>);
-static_assert(!std::convertible_to<min_expl<>, length<metre, min_expl<>>>);
+static_assert(!std::constructible_from<quantity<si::metre, min_expl<>>, min_expl<>>);
+static_assert(!std::convertible_to<min_expl<>, quantity<si::metre, min_expl<>>>);
 
 // not constructible from an underlying type
-static_assert(!std::constructible_from<length<metre, min_expl<>>, int>);
-static_assert(!std::convertible_to<int, length<metre, min_expl<>>>);
+static_assert(!std::constructible_from<quantity<si::metre, min_expl<>>, int>);
+static_assert(!std::convertible_to<int, quantity<si::metre, min_expl<>>>);
+
+// multiply syntax should work
+template<typename T, Unit auto U>
+concept creates_quantity = requires { T{} * U; };
+
+static_assert(creates_quantity<min_expl<>, si::metre>);
 
 // dimensionless quantity implicitly convertible from the representation type
-static_assert(std::constructible_from<dimensionless<one, min_expl<>>, min_expl<>>);
-static_assert(std::convertible_to<min_expl<>, dimensionless<one, min_expl<>>>);
+static_assert(std::constructible_from<quantity<one, min_expl<>>, min_expl<>>);
+static_assert(std::convertible_to<min_expl<>, quantity<one, min_expl<>>>);
 
 // but not from an underlying type
-static_assert(!std::constructible_from<dimensionless<one, min_expl<>>, int>);
-static_assert(!std::convertible_to<int, dimensionless<one, min_expl<>>>);
+static_assert(std::constructible_from<quantity<one, min_expl<>>, int>);
+static_assert(!std::convertible_to<int, quantity<one, min_expl<>>>);
 
 // or for ratio != 1
-static_assert(std::constructible_from<dimensionless<percent, min_expl<>>, min_expl<>>);
-static_assert(!std::convertible_to<min_expl<>, dimensionless<percent, min_expl<>>>);
+static_assert(!std::constructible_from<quantity<percent, min_expl<>>, min_expl<>>);
+static_assert(!std::convertible_to<min_expl<>, quantity<percent, min_expl<>>>);
 
 // quantity convertible from itself
-static_assert(std::constructible_from<length<metre, min_expl<>>, length<metre, min_expl<>>>);
-static_assert(std::convertible_to<length<metre, min_expl<>>, length<metre, min_expl<>>>);
+static_assert(std::constructible_from<quantity<si::metre, min_expl<>>, quantity<si::metre, min_expl<>>>);
+static_assert(std::convertible_to<quantity<si::metre, min_expl<>>, quantity<si::metre, min_expl<>>>);
 
 // not convertible from an underlying type
-static_assert(!std::constructible_from<length<metre, min_expl<>>, length<metre, int>>);
-static_assert(!std::convertible_to<length<metre, int>, length<metre, min_expl<>>>);
+static_assert(std::constructible_from<quantity<si::metre, min_expl<>>, quantity<si::metre, int>>);
+static_assert(!std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_expl<>>>);
 
 // quantity convertible from another non truncating unit
-static_assert(std::constructible_from<length<metre, min_expl<>>, length<kilometre, min_expl<>>>);
-static_assert(std::convertible_to<length<kilometre, min_expl<>>, length<metre, min_expl<>>>);
+static_assert(std::constructible_from<quantity<si::metre, min_expl<>>, quantity<si::kilo<si::metre>, min_expl<>>>);
+static_assert(std::convertible_to<quantity<si::kilo<si::metre>, min_expl<>>, quantity<si::metre, min_expl<>>>);
 
 // quantity not convertible from another truncating unit
-static_assert(!std::constructible_from<length<kilometre, min_expl<>>, length<metre, min_expl<>>>);
-static_assert(!std::convertible_to<length<metre, min_expl<>>, length<kilometre, min_expl<>>>);
+static_assert(!std::constructible_from<quantity<si::kilo<si::metre>, min_expl<>>, quantity<si::metre, min_expl<>>>);
+static_assert(!std::convertible_to<quantity<si::metre, min_expl<>>, quantity<si::kilo<si::metre>, min_expl<>>>);
 
 // rep type with explicit constructor - implicit construction of rep not allowed
-static_assert(!std::constructible_from<length<metre, min_expl<>>, int>);
-static_assert(!std::convertible_to<int, length<metre, min_expl<>>>);
+static_assert(!std::constructible_from<quantity<si::metre, min_expl<>>, int>);
+static_assert(!std::convertible_to<int, quantity<si::metre, min_expl<>>>);
 
-static_assert(!std::constructible_from<length<metre, min_expl<>>, length<metre, int>>);
-static_assert(!std::convertible_to<length<metre, int>, length<metre, min_expl<>>>);
+static_assert(!std::constructible_from<quantity<si::metre, min_expl<>>, quantity<si::metre, int>>);
+static_assert(!std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_expl<>>>);
 
-static_assert(!std::constructible_from<length<metre, int>, min_expl<>>);
-static_assert(!std::convertible_to<min_expl<>, length<metre, int>>);
+static_assert(!std::constructible_from<quantity<si::metre, int>, min_expl<>>);
+static_assert(!std::convertible_to<min_expl<>, quantity<si::metre, int>>);
 
-static_assert(!std::constructible_from<length<metre, int>, length<metre, min_expl<>>>);
-static_assert(!std::convertible_to<length<metre, min_expl<>>, length<metre, int>>);
+static_assert(!std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_expl<>>>);
+static_assert(!std::convertible_to<quantity<si::metre, min_expl<>>, quantity<si::metre, int>>);
 
-static_assert(!std::constructible_from<length<metre, min_expl<>>, dimensionless<one>>);
-static_assert(!std::convertible_to<dimensionless<one>, length<metre, min_expl<>>>);
+static_assert(!std::constructible_from<quantity<si::metre, min_expl<>>, quantity<one>>);
+static_assert(!std::convertible_to<quantity<one>, quantity<si::metre, min_expl<>>>);
 
-static_assert(!std::constructible_from<length<metre, int>, dimensionless<one, min_expl<>>>);
-static_assert(!std::convertible_to<dimensionless<one, min_expl<>>, length<metre, int>>);
+static_assert(!std::constructible_from<quantity<si::metre, int>, quantity<one, min_expl<>>>);
+static_assert(!std::convertible_to<quantity<one, min_expl<>>, quantity<si::metre, int>>);
 
 // all operations needed to satisfy concept
 static_assert(Representation<min_expl<>>);
@@ -186,7 +194,7 @@ static_assert(!Representation<min_expl<9>>);
 
 // quantity's operators should mirror the representation type capabilities
 template<typename Rep>
-concept invalid_member_operations = requires(length<metre, Rep> lhs) {
+concept invalid_member_operations = requires(quantity<si::metre, Rep> lhs) {
   requires !requires { +lhs; };
   requires !requires { -lhs; };
   requires !requires { ++lhs; };
@@ -194,50 +202,55 @@ concept invalid_member_operations = requires(length<metre, Rep> lhs) {
   requires !requires { --lhs; };
   requires !requires { lhs--; };
 
-  requires !requires(length<metre, Rep> rhs) { lhs += rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs -= rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs += rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs -= rhs; };
   requires !requires(Rep rhs) { lhs *= rhs; };
   requires !requires(Rep rhs) { lhs /= rhs; };
   requires !requires(Rep rhs) { lhs %= rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs %= rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs %= rhs; };
 
-  requires !requires(length<metre, Rep> rhs) { lhs + rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs - rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs + rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs - rhs; };
   requires !requires(Rep rhs) { lhs % rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs % rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs < rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs > rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs <= rhs; };
-  requires !requires(length<metre, Rep> rhs) { lhs >= rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs % rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs < rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs > rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs <= rhs; };
+  requires !requires(quantity<si::metre, Rep> rhs) { lhs >= rhs; };
 
-  requires !requires(length<metre, int> rhs) { lhs + rhs; };
-  requires !requires(length<metre, int> rhs) { lhs - rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs + rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs - rhs; };
   requires !requires(int rhs) { lhs % rhs; };
-  requires !requires(length<metre, int> rhs) { lhs % rhs; };
-  requires !requires(length<metre, int> rhs) { lhs == rhs; };
-  requires !requires(length<metre, int> rhs) { lhs != rhs; };
-  requires !requires(length<metre, int> rhs) { lhs < rhs; };
-  requires !requires(length<metre, int> rhs) { lhs > rhs; };
-  requires !requires(length<metre, int> rhs) { lhs <= rhs; };
-  requires !requires(length<metre, int> rhs) { lhs >= rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs % rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs == rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs != rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs < rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs > rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs <= rhs; };
+  requires !requires(quantity<si::metre, int> rhs) { lhs >= rhs; };
 
   requires !requires(std::ostream os) { os << lhs; };
 };
 static_assert(invalid_member_operations<min_expl<>>);
 
 // equality
-static_assert(length<kilometre, min_expl<>>(min_expl(2)) == length<metre, min_expl<>>(min_expl(2000)));
-static_assert(length<metre, min_expl<>>(min_expl(123)) * min_expl(2) == length<metre, min_expl<>>(min_expl(246)));
-static_assert(length<metre, min_expl<>>(min_expl(123)) * quantity{min_expl(2)} ==
-              length<metre, min_expl<>>(min_expl(246)));
-static_assert(min_expl(2) * length<metre, min_expl<>>(min_expl(123)) == length<metre, min_expl<>>(min_expl(246)));
-static_assert(quantity{min_expl(2)} * length<metre, min_expl<>>(min_expl(123)) ==
-              length<metre, min_expl<>>(min_expl(246)));
-static_assert(length<metre, min_expl<>>(min_expl(246)) / min_expl(2) == length<metre, min_expl<>>(min_expl(123)));
-static_assert(length<metre, min_expl<>>(min_expl(246)) / quantity{min_expl(2)} ==
-              length<metre, min_expl<>>(min_expl(123)));
-static_assert(length<metre, min_expl<>>(min_expl(246)) / length<metre, min_expl<>>(min_expl(2)) ==
+static_assert(quantity<si::kilo<si::metre>, min_expl<>>(min_expl(2)) ==
+              quantity<si::metre, min_expl<>>(min_expl(2'000)));
+static_assert(quantity<si::metre, min_expl<>>(min_expl(123)) * min_expl(2) ==
+              quantity<si::metre, min_expl<>>(min_expl(246)));
+static_assert(quantity<si::metre, min_expl<>>(min_expl(123)) * quantity{min_expl(2)} ==
+              quantity<si::metre, min_expl<>>(min_expl(246)));
+static_assert(min_expl(2) * quantity<si::metre, min_expl<>>(min_expl(123)) ==
+              quantity<si::metre, min_expl<>>(min_expl(246)));
+static_assert(quantity{min_expl(2)} * quantity<si::metre, min_expl<>>(min_expl(123)) ==
+              quantity<si::metre, min_expl<>>(min_expl(246)));
+static_assert(quantity<si::metre, min_expl<>>(min_expl(246)) / min_expl(2) ==
+              quantity<si::metre, min_expl<>>(min_expl(123)));
+static_assert(quantity<si::metre, min_expl<>>(min_expl(246)) / quantity{min_expl(2)} ==
+              quantity<si::metre, min_expl<>>(min_expl(123)));
+static_assert(quantity<si::metre, min_expl<>>(min_expl(246)) / quantity<si::metre, min_expl<>>(min_expl(2)) ==
               quantity{min_expl(123)});
-static_assert(length<metre, min_expl<>>(min_expl(246)) / length<metre, min_expl<>>(min_expl(2)) == min_expl(123));
+static_assert(quantity<si::metre, min_expl<>>(min_expl(246)) / quantity<si::metre, min_expl<>>(min_expl(2)) ==
+              min_expl(123));
 
 }  // namespace