refactor: chrono_test refactored to V2

example/glide_computer/include/glide_computer.h

@@ -66,7 +66,7 @@ using altitude = mp_units::quantity_point<mp_units::isq::altitude[mp_units::si::
 // time
 using duration = mp_units::quantity<mp_units::isq::duration[mp_units::si::second]>;
 using timestamp = mp_units::quantity_point<mp_units::isq::time[mp_units::si::second],
-                                           mp_units::chrono_point_origin<std::chrono::system_clock>{}>;
+                                           mp_units::chrono_point_origin<std::chrono::system_clock>>;
 
 // speed
 using velocity = mp_units::quantity<mp_units::isq::speed[mp_units::si::kilo<mp_units::si::metre> / mp_units::si::hour]>;

src/core/include/mp_units/quantity.h

@@ -459,7 +459,8 @@ explicit quantity(Q) -> quantity<quantity_like_traits<Q>::reference, typename qu
 
 // non-member binary operators
 template<Quantity Q1, Quantity Q2>
-  requires(get_kind(Q1::quantity_spec) == get_kind(Q2::quantity_spec)) &&
+  requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
+           implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
           detail::InvokeResultOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec).character, std::plus<>,
                                  typename Q1::rep, typename Q2::rep>
 [[nodiscard]] constexpr Quantity auto operator+(const Q1& lhs, const Q2& rhs)
@@ -470,7 +471,8 @@ template<Quantity Q1, Quantity Q2>
 }
 
 template<Quantity Q1, Quantity Q2>
-  requires(get_kind(Q1::quantity_spec) == get_kind(Q2::quantity_spec)) &&
+  requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
+           implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
           detail::InvokeResultOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec).character, std::minus<>,
                                  typename Q1::rep, typename Q2::rep>
 [[nodiscard]] constexpr Quantity auto operator-(const Q1& lhs, const Q2& rhs)

src/utility/include/mp_units/chrono.h

@@ -66,14 +66,17 @@ struct quantity_like_traits<std::chrono::duration<Rep, Period>> {
 };
 
 template<typename C>
-struct chrono_point_origin : absolute_point_origin<isq::time> {
+struct chrono_point_origin_ : absolute_point_origin<isq::time> {
   using clock = C;
 };
+template<typename C>
+inline constexpr chrono_point_origin_<C> chrono_point_origin;
+
 
 template<typename C, typename Rep, typename Period>
 struct quantity_point_like_traits<std::chrono::time_point<C, std::chrono::duration<Rep, Period>>> {
   static constexpr auto reference = isq::time[detail::time_unit_from_chrono_period<Period>()];
-  static constexpr auto point_origin = chrono_point_origin<C>{};
+  static constexpr auto point_origin = chrono_point_origin<C>;
   using rep = Rep;
   [[nodiscard]] static constexpr auto relative(const std::chrono::time_point<C, std::chrono::duration<Rep, Period>>& qp)
   {
@@ -90,7 +93,7 @@ template<QuantityOf<isq::time> Q>
 }
 
 template<QuantityPointOf<isq::time> QP>
-  requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin>
+  requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin_>
 [[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp)
 {
   using clock = TYPENAME decltype(QP::absolute_point_origin)::clock;
@@ -98,7 +101,7 @@ template<QuantityPointOf<isq::time> QP>
   constexpr auto canonical = detail::get_canonical_unit(QP::unit);
   constexpr ratio r = as_ratio(canonical.mag);
   using ret_type = std::chrono::time_point<clock, std::chrono::duration<rep, std::ratio<r.num, r.den>>>;
-  return ret_type(to_std_duration(qp.absolute()));
+  return ret_type(to_chrono_duration(qp.absolute()));
 }
 
 }  // namespace mp_units

test/unit_test/static/CMakeLists.txt

@@ -37,7 +37,7 @@ add_library(
     dimension_test.cpp
     # angle_test.cpp
     # cgs_test.cpp
-    # chrono_test.cpp
+    chrono_test.cpp
     # concepts_test.cpp
     # custom_rep_test_min_expl.cpp
     # custom_unit_test.cpp

test/unit_test/static/chrono_test.cpp

@@ -21,95 +21,96 @@
 // SOFTWARE.
 
 #include "test_tools.h"
-#include <units/bits/external/type_traits.h>
-#include <units/chrono.h>
-#include <units/isq/si/length.h>
-#include <units/isq/si/speed.h>
-#include <units/quantity_point.h>
+#include <mp_units/bits/external/type_traits.h>
+#include <mp_units/chrono.h>
+#include <mp_units/quantity_point.h>
+#include <mp_units/systems/si/unit_symbols.h>
 #include <ratio>
 
 namespace {
 
-using namespace units;
-using namespace units::isq;
-using namespace units::isq::si::literals;
+using namespace mp_units;
+using namespace mp_units::si::unit_symbols;
 using namespace std::chrono_literals;
 using sys_seconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
 using sys_days =
   std::chrono::time_point<std::chrono::system_clock,
                           std::chrono::duration<long, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>>;
-template<typename C, typename U, typename Rep = double>
-using time_point = quantity_point<clock_origin<C>, U, Rep>;
+template<Unit auto U, typename C, typename Rep = double>
+using time_point = quantity_point<isq::time[U], chrono_point_origin<C>, Rep>;
 
 static_assert(QuantityLike<std::chrono::seconds>);
 static_assert(QuantityPointLike<sys_seconds>);
 
 // construction - same rep type
-static_assert(std::constructible_from<si::time<si::second, std::chrono::seconds::rep>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::second, std::chrono::seconds::rep>>);
-static_assert(std::constructible_from<si::time<si::hour, std::chrono::hours::rep>, std::chrono::hours>);
-static_assert(!std::convertible_to<std::chrono::hours, si::time<si::hour, std::chrono::hours::rep>>);
-static_assert(std::constructible_from<si::time<si::second, std::chrono::hours::rep>, std::chrono::hours>);
-static_assert(!std::convertible_to<std::chrono::hours, si::time<si::second, std::chrono::hours::rep>>);
-static_assert(!std::constructible_from<si::time<si::hour, std::chrono::seconds::rep>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour, std::chrono::seconds::rep>>);
 static_assert(
-  std::constructible_from<time_point<std::chrono::system_clock, si::second, sys_seconds::rep>, sys_seconds>);
+  std::constructible_from<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
+static_assert(std::constructible_from<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>);
+static_assert(!std::convertible_to<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
+static_assert(std::constructible_from<quantity<isq::time[si::second], std::chrono::hours::rep>, std::chrono::hours>);
+static_assert(!std::convertible_to<std::chrono::hours, quantity<isq::time[si::second], std::chrono::hours::rep>>);
+static_assert(!std::constructible_from<quantity<isq::time[si::hour], std::chrono::seconds::rep>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour], std::chrono::seconds::rep>>);
 static_assert(
-  !std::constructible_from<time_point<std::chrono::steady_clock, si::second, sys_seconds::rep>, sys_seconds>);
-static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::second, sys_seconds::rep>>);
-static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::day, sys_days::rep>, sys_days>);
-static_assert(!std::constructible_from<time_point<std::chrono::steady_clock, si::day, sys_days::rep>, sys_days>);
-static_assert(!std::convertible_to<sys_days, time_point<std::chrono::system_clock, si::day, sys_days::rep>>);
-static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::second, sys_days::rep>, sys_days>);
-static_assert(!std::constructible_from<time_point<std::chrono::steady_clock, si::second, sys_days::rep>, sys_days>);
-static_assert(!std::convertible_to<sys_days, time_point<std::chrono::system_clock, si::second, sys_days::rep>>);
-static_assert(!std::constructible_from<time_point<std::chrono::system_clock, si::day, sys_seconds::rep>, sys_seconds>);
-static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::day, sys_seconds::rep>>);
+  std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+static_assert(
+  !std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
+static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_days::rep>, sys_days>);
+static_assert(!std::constructible_from<time_point<si::day, std::chrono::steady_clock, sys_days::rep>, sys_days>);
+static_assert(!std::convertible_to<sys_days, time_point<si::day, std::chrono::system_clock, sys_days::rep>>);
+static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_days::rep>, sys_days>);
+static_assert(!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_days::rep>, sys_days>);
+static_assert(!std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock, sys_days::rep>>);
+static_assert(!std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock, sys_seconds::rep>>);
 
 // construction - different rep type (integral to a floating-point)
-static_assert(std::constructible_from<si::time<si::second>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::second>>);
-static_assert(std::constructible_from<si::time<si::second>, std::chrono::hours>);
-static_assert(!std::convertible_to<std::chrono::hours, si::time<si::second>>);
-static_assert(std::constructible_from<si::time<si::hour>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour>>);
-static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::second>, sys_seconds>);
-static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::second>>);
-static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::second>, sys_days>);
-static_assert(!std::convertible_to<sys_days, time_point<std::chrono::system_clock, si::second>>);
-static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::day>, sys_seconds>);
-static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::day>>);
+static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second]>>);
+static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::hours>);
+static_assert(!std::convertible_to<std::chrono::hours, quantity<isq::time[si::second]>>);
+static_assert(std::constructible_from<quantity<isq::time[si::hour]>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour]>>);
+static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock>>);
+static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_days>);
+static_assert(!std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock>>);
+static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock>>);
 
 
 // CTAD
-static_assert(compare<decltype(quantity{1s}), si::time<si::second, std::chrono::seconds::rep>>);
-static_assert(compare<decltype(quantity{1h}), si::time<si::hour, std::chrono::hours::rep>>);
-static_assert(compare<decltype(quantity_point{sys_seconds{1s}}),
-                      time_point<std::chrono::system_clock, si::second, sys_seconds::rep>>);
-static_assert(compare<decltype(quantity_point{sys_days{sys_days::duration{1}}}),
-                      time_point<std::chrono::system_clock, si::day, sys_days::rep>>);
+static_assert(is_of_type<quantity{1s}, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
+static_assert(is_of_type<quantity{1h}, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
+static_assert(
+  is_of_type<quantity_point{sys_seconds{1s}}, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
+static_assert(is_of_type<quantity_point{sys_days{sys_days::duration{1}}},
+                         time_point<si::day, std::chrono::system_clock, sys_days::rep>>);
 
 // operators
-static_assert(quantity{1s} + 1_q_s == 2_q_s);
-static_assert(quantity{1s} + 1_q_min == 61_q_s);
-static_assert(10_q_m / quantity{2s} == 5_q_m_per_s);
-static_assert(quantity_point{sys_seconds{1s}} + 1_q_s == time_point<std::chrono::system_clock, si::second>{2_q_s});
-static_assert(quantity_point{sys_seconds{1s}} + 1_q_min == time_point<std::chrono::system_clock, si::second>{61_q_s});
+static_assert(quantity{1s} + 1 * s == 2 * s);
+static_assert(quantity{1s} + 1 * min == 61 * s);
+static_assert(10 * m / quantity{2s} == 5 * (m / s));
+static_assert(quantity_point{sys_seconds{1s}} + 1 * s ==
+              time_point<si::second, std::chrono::system_clock, sys_seconds::rep>{2 * s});
+static_assert(quantity_point{sys_seconds{1s}} + 1 * min ==
+              time_point<si::second, std::chrono::system_clock, sys_seconds::rep>{61 * s});
 
 // to_std_duration
-static_assert(to_std_duration(1_q_s) == 1s);
-static_assert(to_std_duration(2_q_h) == 2h);
-static_assert(to_std_duration(3_q_ns) == 3ns);
-static_assert(to_std_duration(quantity{1s}) == 1s);
-static_assert(to_std_duration(quantity{2h}) == 2h);
-static_assert(to_std_duration(quantity{3ns}) == 3ns);
-static_assert(is_same_v<decltype(to_std_duration(1_q_s))::period, std::ratio<1>>);
-static_assert(is_same_v<decltype(to_std_duration(2_q_h))::period, std::ratio<3600>>);
-static_assert(is_same_v<decltype(to_std_duration(3_q_ns))::period, std::nano>);
+static_assert(to_chrono_duration(1 * s) == 1s);
+static_assert(to_chrono_duration(2 * h) == 2h);
+static_assert(to_chrono_duration(3 * ns) == 3ns);
+static_assert(to_chrono_duration(quantity{1s}) == 1s);
+static_assert(to_chrono_duration(quantity{2h}) == 2h);
+static_assert(to_chrono_duration(quantity{3ns}) == 3ns);
+static_assert(is_same_v<decltype(to_chrono_duration(1 * s))::period, std::ratio<1>>);
+static_assert(is_same_v<decltype(to_chrono_duration(2 * h))::period, std::ratio<3600>>);
+static_assert(is_same_v<decltype(to_chrono_duration(3 * ns))::period, std::nano>);
 
 // to_std_time_point
-static_assert(to_std_time_point(quantity_point{sys_seconds{1s}}) == sys_seconds{1s});
-static_assert(to_std_time_point(quantity_point{sys_days{sys_days::duration{1}}}) == sys_days{sys_days::duration{1}});
+static_assert(to_chrono_time_point(quantity_point{sys_seconds{1s}}) == sys_seconds{1s});
+static_assert(to_chrono_time_point(quantity_point{sys_days{sys_days::duration{1}}}) == sys_days{sys_days::duration{1}});
 
 }  // namespace