From e353bb3436d6efa150f34abf493aa434a3f16b5a Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Mon, 13 Feb 2023 19:07:16 +0100
Subject: [PATCH] refactor(unit test): support for new features added to unit
 and dimension unit tests

---
 test/unit_test/static/dimension_test.cpp |  5 +-
 test/unit_test/static/unit_test.cpp      | 59 ++++++++++++------------
 2 files changed, 33 insertions(+), 31 deletions(-)

diff --git a/test/unit_test/static/dimension_test.cpp b/test/unit_test/static/dimension_test.cpp
index c6534d05..25b609e9 100644
--- a/test/unit_test/static/dimension_test.cpp
+++ b/test/unit_test/static/dimension_test.cpp
@@ -23,6 +23,7 @@
 #include "test_tools.h"
 #include <mp_units/dimension.h>
 #include <mp_units/quantity.h>
+#include <mp_units/quantity_spec.h>
 #include <mp_units/reference.h>
 #include <mp_units/unit.h>
 
@@ -38,7 +39,7 @@ inline constexpr struct mass_ : base_dimension<"M"> {} mass;
 inline constexpr struct time_ : base_dimension<"T"> {} time;
 
 QUANTITY_SPEC_(q_time, time);
-inline constexpr struct second_ : named_unit<"s", q_time> {} second;
+inline constexpr struct second_ : named_unit<"s", kind_of<q_time>> {} second;
 
 inline constexpr auto frequency = 1 / time;
 inline constexpr auto action = 1 / time;
@@ -67,7 +68,7 @@ static_assert(Dimension<std::remove_const_t<decltype(frequency)>>);
 
 static_assert(detail::DerivedDimension<dimension_one_>);
 static_assert(detail::DerivedDimension<decltype(length / length)>);  // dimension_one
-static_assert(BaseDimension<decltype(speed * time)>);        // length
+static_assert(BaseDimension<decltype(speed * time)>);                // length
 
 // derived dimension expression template syntax verification
 static_assert(is_of_type<1 / time, derived_dimension<dimension_one_, per<time_>>>);
diff --git a/test/unit_test/static/unit_test.cpp b/test/unit_test/static/unit_test.cpp
index 9ade6e1a..b6af6a4e 100644
--- a/test/unit_test/static/unit_test.cpp
+++ b/test/unit_test/static/unit_test.cpp
@@ -47,11 +47,11 @@ QUANTITY_SPEC_(time, dim_time);
 QUANTITY_SPEC_(thermodynamic_temperature, dim_thermodynamic_temperature);
 
 // base units
-inline constexpr struct second_ : named_unit<"s", time> {} second;
-inline constexpr struct metre_ : named_unit<"m", length> {} metre;
-inline constexpr struct gram_ : named_unit<"g", mass> {} gram;
+inline constexpr struct second_ : named_unit<"s", kind_of<time>> {} second;
+inline constexpr struct metre_ : named_unit<"m", kind_of<length>> {} metre;
+inline constexpr struct gram_ : named_unit<"g", kind_of<mass>> {} gram;
 inline constexpr struct kilogram_ : decltype(si::kilo<gram>) {} kilogram;
-inline constexpr struct kelvin_ : named_unit<"K", thermodynamic_temperature> {} kelvin;
+inline constexpr struct kelvin_ : named_unit<"K", kind_of<thermodynamic_temperature>> {} kelvin;
 
 // hypothetical natural units for c=1
 inline constexpr struct nu_second_ : named_unit<"s"> {} nu_second;
@@ -128,15 +128,15 @@ static_assert(!NamedUnit<kilometre_>);
 static_assert(is_of_type<metre, metre_>);
 static_assert(is_of_type<get_canonical_unit(metre).reference_unit, metre_>);
 static_assert(get_canonical_unit(metre).mag == mag<1>);
-static_assert(interconvertible(metre, metre));
-static_assert(!interconvertible(metre, second));
+static_assert(convertible_to(metre, metre));
+static_assert(!convertible_to(metre, second));
 static_assert(metre == metre);
 static_assert(metre != second);
 
 static_assert(is_of_type<degree_Celsius, degree_Celsius_>);
 static_assert(is_of_type<get_canonical_unit(degree_Celsius).reference_unit, kelvin_>);
 static_assert(get_canonical_unit(degree_Celsius).mag == mag<1>);
-static_assert(interconvertible(degree_Celsius, kelvin));
+static_assert(convertible_to(degree_Celsius, kelvin));
 static_assert(degree_Celsius == kelvin);
 
 static_assert(is_of_type<radian, radian_>);
@@ -146,28 +146,28 @@ static_assert(get_canonical_unit(radian).mag == mag<1>);
 static_assert(is_of_type<degree, degree_>);
 static_assert(is_of_type<get_canonical_unit(degree).reference_unit, one_>);
 static_assert(get_canonical_unit(degree).mag == mag_pi / mag<180>);
-static_assert(interconvertible(radian, degree));
+static_assert(convertible_to(radian, degree));
 static_assert(radian != degree);
 
 static_assert(is_of_type<steradian, steradian_>);
 static_assert(is_of_type<get_canonical_unit(steradian).reference_unit, one_>);
 static_assert(get_canonical_unit(steradian).mag == mag<1>);
-static_assert(interconvertible(radian, steradian));  // !!!
-static_assert(radian == steradian);                  // !!!
+static_assert(convertible_to(radian, steradian));  // !!!
+static_assert(radian == steradian);                // !!!
 
 static_assert(is_of_type<minute, minute_>);
 static_assert(is_of_type<get_canonical_unit(minute).reference_unit, second_>);
 static_assert(get_canonical_unit(minute).mag == mag<60>);
-static_assert(interconvertible(minute, second));
+static_assert(convertible_to(minute, second));
 static_assert(minute != second);
 
 static_assert(is_of_type<hour, hour_>);
 static_assert(is_of_type<get_canonical_unit(hour).reference_unit, second_>);
 static_assert(get_canonical_unit(hour).mag == mag<3600>);
-static_assert(interconvertible(hour, second));
+static_assert(convertible_to(hour, second));
 
-static_assert(interconvertible(hour, minute));
-static_assert(interconvertible(hour, hour));
+static_assert(convertible_to(hour, minute));
+static_assert(convertible_to(hour, hour));
 static_assert(hour != second);
 static_assert(hour != minute);
 static_assert(hour == hour);
@@ -176,14 +176,14 @@ static_assert(is_of_type<newton, newton_>);
 static_assert(
   is_of_type<get_canonical_unit(newton).reference_unit, derived_unit<gram_, metre_, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(newton).mag == mag<1000>);  // !!! (because of kilogram)
-static_assert(interconvertible(newton, newton));
+static_assert(convertible_to(newton, newton));
 static_assert(newton == newton);
 
 static_assert(is_of_type<joule, joule_>);
 static_assert(
   is_of_type<get_canonical_unit(joule).reference_unit, derived_unit<gram_, power<metre_, 2>, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(joule).mag == mag<1000>);  // !!! (because of kilogram)
-static_assert(interconvertible(joule, joule));
+static_assert(convertible_to(joule, joule));
 static_assert(joule == joule);
 static_assert(joule != newton);
 
@@ -194,8 +194,8 @@ static_assert(is_of_type<standard_gravity_unit, standard_gravity_unit_>);
 static_assert(
   is_of_type<get_canonical_unit(standard_gravity_unit).reference_unit, derived_unit<metre_, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(standard_gravity_unit).mag == mag<ratio{980'665, 100'000}>);
-static_assert(interconvertible(standard_gravity_unit, standard_gravity_unit));
-static_assert(interconvertible(standard_gravity_unit, metre / square<second>));
+static_assert(convertible_to(standard_gravity_unit, standard_gravity_unit));
+static_assert(convertible_to(standard_gravity_unit, metre / square<second>));
 static_assert(standard_gravity_unit == standard_gravity_unit);
 static_assert(standard_gravity_unit != metre / square<second>);  // magnitude is different
 static_assert(standard_gravity_unit.symbol == "[g]");
@@ -204,7 +204,7 @@ static_assert(standard_gravity_unit.symbol == "[g]");
 static_assert(is_of_type<kilometre, kilometre_>);
 static_assert(is_of_type<get_canonical_unit(kilometre).reference_unit, metre_>);
 static_assert(get_canonical_unit(kilometre).mag == mag<1000>);
-static_assert(interconvertible(kilometre, metre));
+static_assert(convertible_to(kilometre, metre));
 static_assert(kilometre != metre);
 static_assert(kilometre.symbol == "km");
 
@@ -212,7 +212,7 @@ static_assert(is_of_type<kilojoule, kilojoule_>);
 static_assert(is_of_type<get_canonical_unit(kilojoule).reference_unit,
                          derived_unit<gram_, power<metre_, 2>, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(kilojoule).mag == mag<1'000'000>);
-static_assert(interconvertible(kilojoule, joule));
+static_assert(convertible_to(kilojoule, joule));
 static_assert(kilojoule != joule);
 static_assert(kilojoule.symbol == "kJ");
 
@@ -438,33 +438,34 @@ static_assert(si::kilo<metre> * si::milli<metre> == si::deca<metre> * si::deci<m
 
 // comparisons of equivalent units (named vs unnamed/derived)
 static_assert(1 / second == hertz);
-static_assert(interconvertible(1 / second, hertz));
+static_assert(convertible_to(1 / second, hertz));
 
 // comparisons of equivalent units of different quantities
 static_assert(hertz == becquerel);
-static_assert(interconvertible(hertz, becquerel));
+static_assert(convertible_to(hertz, becquerel));
 
 // comparisons of scaled units
 static_assert(si::kilo<metre> == kilometre);
 static_assert(mag<1000> * metre == si::kilo<metre>);
 static_assert(mag<1000> * metre == kilometre);
-static_assert(interconvertible(si::kilo<metre>, kilometre));
-static_assert(interconvertible(mag<1000> * metre, si::kilo<metre>));
-static_assert(interconvertible(mag<1000> * metre, kilometre));
+static_assert(convertible_to(si::kilo<metre>, kilometre));
+static_assert(convertible_to(mag<1000> * metre, si::kilo<metre>));
+static_assert(convertible_to(mag<1000> * metre, kilometre));
 
 static_assert(metre != kilometre);
-static_assert(interconvertible(metre, kilometre));
+static_assert(convertible_to(metre, kilometre));
 static_assert(mag<100> * metre != kilometre);
-static_assert(interconvertible(mag<100> * metre, kilometre));
+static_assert(convertible_to(mag<100> * metre, kilometre));
 static_assert(si::milli<metre> != kilometre);
-static_assert(interconvertible(si::milli<metre>, kilometre));
+static_assert(convertible_to(si::milli<metre>, kilometre));
 
 // comparisons of non-convertible units
 static_assert(metre != metre * metre);
-static_assert(!interconvertible(metre, metre* metre));
+static_assert(!convertible_to(metre, metre* metre));
 
 // one
 static_assert(is_of_type<metre / metre, one_>);
+static_assert(is_of_type<si::kilo<metre> / metre, derived_unit<si::kilo_<metre>, per<metre_>>>);
 static_assert(metre / metre == one);
 static_assert(hertz * second == one);