From 7ce8173b402f4bc4c4ef85585c676c85ae2d5d6f Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Tue, 1 Aug 2023 12:04:31 +0200
Subject: [PATCH] test: initial version of `quantity_point_test` added

---
 test/unit_test/static/quantity_point_test.cpp | 995 +++++++++++++-----
 1 file changed, 751 insertions(+), 244 deletions(-)

diff --git a/test/unit_test/static/quantity_point_test.cpp b/test/unit_test/static/quantity_point_test.cpp
index cd57a32d5..401e39cb8 100644
--- a/test/unit_test/static/quantity_point_test.cpp
+++ b/test/unit_test/static/quantity_point_test.cpp
@@ -21,308 +21,815 @@
 // SOFTWARE.
 
 #include "test_tools.h"
-#include <units/bits/common_type.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/isq/si/uscs/length.h>
-#include <units/isq/si/volume.h>
-#include <units/quantity_point.h>
+#include <mp-units/chrono.h>
+#include <mp-units/quantity_point.h>
+#include <mp-units/systems/isq/space_and_time.h>
+#include <mp-units/systems/si/si.h>
 #include <limits>
 #include <type_traits>
 #include <utility>
 
 namespace {
 
-using namespace units;
-using namespace isq::si;
-using namespace references;
+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>;
 
-struct sea_level_origin : point_origin<dim_length> {};
+inline constexpr struct mean_sea_level : absolute_point_origin<isq::height> {
+} mean_sea_level;
 
+inline constexpr quantity_point<isq::height[m], mean_sea_level> ground_level{42 * isq::height[m]};
+inline constexpr quantity_point<isq::height[m], mean_sea_level> everest_base_camp{5364 * m};
+
+QUANTITY_SPEC(special_height, isq::height);
+QUANTITY_SPEC(activity, 1 / isq::time);
+
+/////////////////////
 // class invariants
+/////////////////////
 
-template<typename DimLength>
+static_assert(sizeof(quantity_point<si::metre>) == sizeof(double));
+static_assert(sizeof(quantity_point<isq::length[m]>) == sizeof(double));
+static_assert(sizeof(quantity_point<si::metre, absolute_point_origin<isq::length>{}, short>) == sizeof(short));
+static_assert(sizeof(quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, short>) == sizeof(short));
+
+template<template<auto, auto, typename> typename QP>
 concept invalid_types = requires {
-  // unit of a different dimension:
-  requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
-  // quantity used as Rep:
-  requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
-  // quantity point used as Rep:
-  requires !requires {
-    typename quantity_point<dynamic_origin<DimLength>, metre, quantity_point<dynamic_origin<DimLength>, metre, int>>;
-  };
-  // reordered arguments:
-  requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
-  // dimension used as origin:
-  requires !requires { typename quantity_point<DimLength, second, int>; };
+  // unit of a different dimension
+  requires !requires { typename QP<si::second, absolute_point_origin<isq::length>{}, int>; };
+  requires !requires { typename QP<si::second, absolute_point_origin<kind_of<isq::length>>{}, int>; };
+  // not compatible quantity_spec
+  requires !requires { typename QP<isq::width[si::metre], absolute_point_origin<isq::height>{}, int>; };
+  requires !requires { typename QP<isq::width[m], absolute_point_origin<isq::thickness>{}, int>; };
+  // quantity used as Rep
+  requires !requires { typename QP<si::metre, absolute_point_origin<isq::length>{}, quantity<si::metre, int>>; };
+  // quantity point used as Rep
+  requires !requires { typename QP<si::metre, absolute_point_origin<isq::length>{}, quantity_point<si::metre>>; };
+  // reordered arguments
+  requires !requires { typename QP<absolute_point_origin<isq::length>{}, si::metre, double>; };
+  // quantity_spec used as origin
+  requires !requires { typename QP<si::metre, isq::length, int>; };
+  // quantity_spec used as a reference
+  requires !requires { typename QP<isq::length, absolute_point_origin<isq::length>{}, int>; };
+  // dimension used as a reference
+  requires !requires { typename QP<isq::dim_length, absolute_point_origin<isq::length>{}, int>; };
+  // bool used as a representation type
+  requires !requires { typename QP<si::metre, absolute_point_origin<isq::length>{}, bool>; };
+  // incompatible quantity_spec in the origin and quantity_point
+  requires !requires { typename QP<isq::length[m], absolute_point_origin<isq::height>{}, int>; };
+  requires !requires { typename QP<isq::length[m], mean_sea_level, int>; };
+  requires !requires { typename QP<isq::length[m], ground_level, int>; };
 };
+static_assert(invalid_types<quantity_point>);
+
+template<template<auto, auto> typename QP>
+concept valid_types = requires {
+  typename QP<si::metre, absolute_point_origin<kind_of<isq::length>>{}>;
+  typename QP<si::metre, absolute_point_origin<isq::length>{}>;
+  typename QP<si::metre, absolute_point_origin<isq::height>{}>;
+  typename QP<isq::length[m], absolute_point_origin<isq::length>{}>;
+  typename QP<isq::height[m], absolute_point_origin<isq::length>{}>;
+  typename QP<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}>;
+  typename QP<isq::height[m], absolute_point_origin<kind_of<isq::length>>{}>;
+  typename QP<isq::thickness[m], absolute_point_origin<isq::width>{}>;
+  typename QP<si::metre, mean_sea_level>;
+  typename QP<isq::height[m], mean_sea_level>;
+  typename QP<special_height[m], mean_sea_level>;
+  typename QP<si::metre, ground_level>;
+  typename QP<isq::height[m], ground_level>;
+  typename QP<special_height[m], ground_level>;
+};
+static_assert(valid_types<quantity_point>);
+
+static_assert(std::is_trivially_default_constructible_v<quantity_point<si::metre>>);
+static_assert(std::is_trivially_copy_constructible_v<quantity_point<si::metre>>);
+static_assert(std::is_trivially_move_constructible_v<quantity_point<si::metre>>);
+static_assert(std::is_trivially_copy_assignable_v<quantity_point<si::metre>>);
+static_assert(std::is_trivially_move_assignable_v<quantity_point<si::metre>>);
+static_assert(std::is_trivially_destructible_v<quantity_point<si::metre>>);
+
+static_assert(std::is_nothrow_default_constructible_v<quantity_point<si::metre>>);
+static_assert(std::is_nothrow_copy_constructible_v<quantity_point<si::metre>>);
+static_assert(std::is_nothrow_move_constructible_v<quantity_point<si::metre>>);
+static_assert(std::is_nothrow_copy_assignable_v<quantity_point<si::metre>>);
+static_assert(std::is_nothrow_move_assignable_v<quantity_point<si::metre>>);
+static_assert(std::is_nothrow_destructible_v<quantity_point<si::metre>>);
+
+static_assert(std::is_trivially_copyable_v<quantity_point<si::metre>>);
+static_assert(std::is_standard_layout_v<quantity_point<si::metre>>);
+
+static_assert(std::default_initializable<quantity_point<si::metre>>);
+static_assert(std::move_constructible<quantity_point<si::metre>>);
+static_assert(std::copy_constructible<quantity_point<si::metre>>);
+static_assert(std::equality_comparable<quantity_point<si::metre>>);
+static_assert(std::totally_ordered<quantity_point<si::metre>>);
+static_assert(std::regular<quantity_point<si::metre>>);
+
+static_assert(std::three_way_comparable<quantity_point<si::metre>>);
+
+
+//////////////////
+// member values
+//////////////////
+
+static_assert(quantity_point<si::metre>::reference == si::metre);
+static_assert(quantity_point<si::metre>::quantity_spec == kind_of<isq::length>);
+static_assert(quantity_point<si::metre>::dimension == isq::dim_length);
+static_assert(quantity_point<si::metre>::unit == si::metre);
+static_assert(is_of_type<quantity_point<si::metre>::point_origin, absolute_point_origin<kind_of<isq::length>>>);
+
+static_assert(quantity_point<isq::length[m]>::reference == isq::length[m]);
+static_assert(quantity_point<isq::length[m]>::quantity_spec == isq::length);
+static_assert(quantity_point<isq::length[m]>::dimension == isq::dim_length);
+static_assert(quantity_point<isq::length[m]>::unit == si::metre);
+static_assert(is_of_type<quantity_point<isq::length[m]>::point_origin, absolute_point_origin<isq::length>>);
+static_assert(is_of_type<quantity_point<isq::length[m]>::absolute_point_origin, absolute_point_origin<isq::length>>);
+
+static_assert(quantity_point<isq::height[m], mean_sea_level>::reference == isq::height[m]);
+static_assert(quantity_point<isq::height[m], mean_sea_level>::quantity_spec == isq::height);
+static_assert(quantity_point<isq::height[m], mean_sea_level>::dimension == isq::dim_length);
+static_assert(quantity_point<isq::height[m], mean_sea_level>::unit == si::metre);
+static_assert(is_of_type<quantity_point<isq::height[m], mean_sea_level>::point_origin, struct mean_sea_level>);
+static_assert(is_of_type<quantity_point<isq::height[m], mean_sea_level>::absolute_point_origin, struct mean_sea_level>);
+
+static_assert(quantity_point<isq::height[m], ground_level>::reference == isq::height[m]);
+static_assert(quantity_point<isq::height[m], ground_level>::quantity_spec == isq::height);
+static_assert(quantity_point<isq::height[m], ground_level>::dimension == isq::dim_length);
+static_assert(quantity_point<isq::height[m], ground_level>::unit == si::metre);
+static_assert(
+  is_of_type<quantity_point<isq::height[m], ground_level>::point_origin, std::remove_const_t<decltype(ground_level)>>);
+static_assert(is_of_type<quantity_point<isq::height[m], ground_level>::absolute_point_origin, struct mean_sea_level>);
 
-static_assert(invalid_types<dim_length>);
 
+//////////////////
 // member types
+//////////////////
+
+static_assert(is_same_v<quantity_point<si::metre>::rep, double>);
+static_assert(is_same_v<quantity_point<si::metre>::quantity_type, quantity<si::metre>>);
+
+static_assert(is_same_v<quantity_point<si::metre, absolute_point_origin<isq::length>{}, int>::rep, int>);
+static_assert(is_same_v<quantity_point<si::metre, absolute_point_origin<isq::length>{}, int>::quantity_type,
+                        quantity<si::metre, int>>);
+
+static_assert(is_same_v<quantity_point<isq::length[m]>::rep, double>);
+static_assert(is_same_v<quantity_point<isq::length[m]>::quantity_type, quantity<isq::length[m]>>);
+
+static_assert(is_same_v<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>::rep, int>);
+static_assert(is_same_v<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>::quantity_type,
+                        quantity<isq::length[m], int>>);
+
+
+////////////////////////////
+// static member functions
+////////////////////////////
+
+static_assert(quantity_point<isq::length[m]>::zero().relative().number() == 0);
+static_assert(quantity_point<isq::length[m]>::min().relative().number() == std::numeric_limits<double>::lowest());
+static_assert(quantity_point<isq::length[m]>::max().relative().number() == std::numeric_limits<double>::max());
+static_assert(quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>::zero().relative().number() ==
+              0);
+static_assert(quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>::min().relative().number() ==
+              std::numeric_limits<int>::lowest());
+static_assert(quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>::max().relative().number() ==
+              std::numeric_limits<int>::max());
+
+
+//////////////////////////////
+// construction from a value
+//////////////////////////////
+
+// construction from a value is private
+static_assert(!std::constructible_from<quantity_point<isq::length[m]>, double>);
+static_assert(!std::convertible_to<double, quantity_point<isq::length[m]>>);
+
+static_assert(!std::constructible_from<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>, int>);
+static_assert(!std::convertible_to<int, quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+static_assert(!std::constructible_from<quantity_point<dimensionless[percent]>, double>);
+static_assert(!std::convertible_to<double, quantity_point<dimensionless[percent]>>);
 
-static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::rep, int>);
-static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, double>::rep, double>);
-static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::unit, metre>);
-static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, kilometre, int>::unit, kilometre>);
-static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::dimension, dim_length>);
-static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::origin, dynamic_origin<dim_length>>);
 static_assert(
-  is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::quantity_type, quantity<dim_length, metre, int>>);
+  !std::constructible_from<quantity_point<dimensionless[percent], absolute_point_origin<dimensionless>{}, int>, int>);
+static_assert(
+  !std::convertible_to<int, quantity_point<dimensionless[percent], absolute_point_origin<dimensionless>{}, int>>);
+static_assert(!std::constructible_from<quantity_point<dimensionless[one]>, double>);
+static_assert(!std::convertible_to<double, quantity_point<dimensionless[one]>>);
+static_assert(
+  !std::constructible_from<quantity_point<dimensionless[one], absolute_point_origin<dimensionless>{}, int>, int>);
+static_assert(
+  !std::convertible_to<int, quantity_point<dimensionless[one], absolute_point_origin<dimensionless>{}, int>>);
+
+
+/////////////////////////////////
+// construction from a quantity
+/////////////////////////////////
+
+static_assert(std::constructible_from<quantity_point<si::second>, quantity<si::second>>);
+static_assert(!std::convertible_to<quantity<si::second>, quantity_point<si::second>>);
 
-// constructors
+static_assert(std::constructible_from<quantity_point<isq::time[s]>, quantity<isq::time[s]>>);
+static_assert(!std::convertible_to<quantity<isq::time[s]>, quantity_point<isq::time[s]>>);
 
-static_assert(quantity_point(1).relative() == quantity(1));
-static_assert(!std::is_convertible_v<int, quantity_point<dynamic_origin<dim_one>, one, int>>);
+static_assert(std::constructible_from<quantity_point<si::second>, quantity<isq::time[s]>>);
+static_assert(!std::convertible_to<quantity<isq::time[s]>, quantity_point<si::second>>);
+
+static_assert(std::constructible_from<quantity_point<isq::time[s]>, quantity<si::second>>);
+static_assert(!std::convertible_to<quantity<si::second>, quantity_point<isq::time[s]>>);
+
+static_assert(std::constructible_from<quantity_point<isq::length[m]>, quantity<isq::distance[m]>>);
+static_assert(!std::convertible_to<quantity<isq::distance[m]>, quantity_point<isq::length[m]>>);
+
+static_assert(std::constructible_from<quantity_point<dimensionless[one]>, quantity<dimensionless[one]>>);
+static_assert(!std::convertible_to<quantity<dimensionless[one]>, quantity_point<dimensionless[one]>>);
+
+// different dimensions
+static_assert(!std::constructible_from<quantity_point<isq::distance[m]>, quantity<si::second>>);
+static_assert(!std::convertible_to<quantity<si::second>, quantity_point<isq::distance[m]>>);
+
+// non-convertible quantity_specs
+static_assert(!std::constructible_from<quantity_point<isq::distance[m]>, quantity<isq::length[m]>>);
+static_assert(!std::convertible_to<quantity<isq::length[m]>, quantity_point<isq::distance[m]>>);
+
+// quantity-like
+static_assert(std::constructible_from<quantity_point<isq::time[s]>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<isq::time[s]>>);
+
+
+///////////////////////////////////////
+// construction from a quantity point
+///////////////////////////////////////
+
+// same origins
+static_assert(std::constructible_from<quantity_point<si::metre>, quantity_point<si::metre>>);
+static_assert(std::convertible_to<quantity_point<si::metre>, quantity_point<si::metre>>);
+
+static_assert(std::constructible_from<quantity_point<isq::length[m]>, quantity_point<isq::length[m]>>);
+static_assert(std::convertible_to<quantity_point<isq::length[m]>, quantity_point<isq::length[m]>>);
+
+static_assert(std::constructible_from<quantity_point<si::metre>, quantity_point<isq::length[m]>>);
+static_assert(std::convertible_to<quantity_point<isq::length[m]>, quantity_point<si::metre>>);
+
+static_assert(std::constructible_from<quantity_point<isq::length[m]>, quantity_point<si::metre>>);
+static_assert(std::convertible_to<quantity_point<si::metre>, quantity_point<isq::length[m]>>);
+
+static_assert(std::constructible_from<quantity_point<isq::length[m]>, quantity_point<isq::distance[m]>>);
+static_assert(std::convertible_to<quantity_point<isq::distance[m]>, quantity_point<isq::length[m]>>);
+
+static_assert(std::constructible_from<quantity_point<dimensionless[one]>, quantity_point<dimensionless[one]>>);
+static_assert(std::convertible_to<quantity_point<dimensionless[one]>, quantity_point<dimensionless[one]>>);
+
+// different dimensions
+static_assert(!std::constructible_from<quantity_point<isq::distance[m]>, quantity_point<si::second>>);
+static_assert(!std::convertible_to<quantity_point<si::second>, quantity_point<isq::distance[m]>>);
+
+// non-convertible quantity_specs
+static_assert(!std::constructible_from<quantity_point<isq::distance[m]>, quantity_point<isq::length[m]>>);
+static_assert(!std::convertible_to<quantity_point<isq::length[m]>, quantity_point<isq::distance[m]>>);
+
+// implicit conversion from another quantity only if non-truncating
+// int -> double OK
+static_assert(std::constructible_from<quantity_point<isq::length[m]>,
+                                      quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(std::convertible_to<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>,
+                                  quantity_point<isq::length[m]>>);
+
+// truncating double -> int not allowed
+static_assert(!std::constructible_from<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>,
+                                       quantity_point<isq::length[m]>>);
+static_assert(!std::convertible_to<quantity_point<isq::length[m]>,
+                                   quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+// kilometre<int> -> metre<int> OK
+static_assert(std::constructible_from<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>,
+                                      quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>>);
+static_assert(std::convertible_to<quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>,
+                                  quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+// truncating metre<int> -> kilometre<int> not allowed
+static_assert(!std::constructible_from<quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>,
+                                       quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(!std::convertible_to<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>,
+                                   quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>>);
+
+// converting to double always OK
+static_assert(std::constructible_from<quantity_point<isq::length[m]>,
+                                      quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>>);
+static_assert(std::convertible_to<quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>,
+                                  quantity_point<isq::length[m]>>);
+static_assert(std::constructible_from<quantity_point<isq::length[km]>,
+                                      quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(std::convertible_to<quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>,
+                                  quantity_point<isq::length[km]>>);
+
+// same but not a default origin
+static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
+                                      quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(
+  std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
 
-static_assert(quantity_point(42s).relative() == 42 * s);
-static_assert(quantity_point(sys_seconds{42s}).relative() == 42 * s);
-static_assert(!std::is_convertible_v<std::chrono::seconds,
-                                     quantity_point<dynamic_origin<dim_time>, second, std::chrono::seconds::rep>>);
 static_assert(
-  !std::is_convertible_v<std::chrono::seconds,
-                         quantity_point<clock_origin<std::chrono::system_clock>, second, std::chrono::seconds::rep>>);
-static_assert(!std::is_convertible_v<sys_seconds, quantity_point<dynamic_origin<dim_time>, second, sys_seconds::rep>>);
-static_assert(!std::is_convertible_v<
-              sys_seconds, quantity_point<clock_origin<std::chrono::system_clock>, second, sys_seconds::rep>>);
-
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>().relative() == 0_q_m);
-constexpr quantity_point<dynamic_origin<dim_length>, metre, int> km{1000_q_m};
-static_assert(km.relative() == 1000_q_m);
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(km).relative() == km.relative());
-
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(1_q_m).relative() == 1_q_m);
+  std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
 static_assert(
-  !std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>, double>);  // truncating conversion
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(1.0_q_m).relative() == 1.0_q_m);
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(1_q_m).relative() == 1_q_m);
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, long double>(3.14_q_m).relative() == 3.14_q_m);
+  std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
 
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(km).relative() == 1000_q_m);
 static_assert(
-  !std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>,
-                           quantity_point<dynamic_origin<dim_length>, metre, double>>);  // truncating conversion
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(quantity_point(1000.0_q_m)).relative() ==
-              1000.0_q_m);
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(km).relative() == 1000.0_q_m);
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(quantity_point(1_q_km)).relative() == 1000_q_m);
-static_assert(!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>,
-                                       quantity_point<dynamic_origin<dim_time>, second, int>>);  // different dimensions
+  std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
 static_assert(
-  !std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, kilometre, int>,
-                           quantity_point<dynamic_origin<dim_length>, metre, int>>);  // truncating conversion
+  std::convertible_to<quantity_point<si::metre, mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
 
-static_assert(!std::is_constructible_v<quantity_point<sea_level_origin, kilometre, int>,
-                                       quantity_point<dynamic_origin<dim_length>, metre, int>>,
-              "non-equivalent origins");
-static_assert(!std::is_constructible_v<quantity_point<dynamic_origin<dim_time>, second, int>, sys_seconds>,
-              "non-equivalent origins, no implicit conversion from `clock_origin`");
+static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
+                                      quantity_point<special_height[m], mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<special_height[m], mean_sea_level>,
+                                  quantity_point<isq::height[m], mean_sea_level>>);
 
+static_assert(!std::constructible_from<quantity_point<special_height[m], mean_sea_level>,
+                                       quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::convertible_to<quantity_point<isq::height[m], mean_sea_level>,
+                                   quantity_point<special_height[m], mean_sea_level>>);
+
+// different origins
+static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[m]>>);
+static_assert(!std::convertible_to<quantity_point<isq::height[m]>, quantity_point<isq::height[m], mean_sea_level>>);
+
+// quantity-point-like
+static_assert(
+  std::constructible_from<quantity_point<isq::time[s], chrono_point_origin<std::chrono::system_clock>>, sys_seconds>);
+static_assert(
+  !std::convertible_to<sys_seconds, quantity_point<isq::time[s], chrono_point_origin<std::chrono::system_clock>>>);
+
+// incompatible origin
+static_assert(!std::constructible_from<quantity_point<isq::time[s]>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, quantity_point<isq::time[s]>>);
+
+
+//////////////////////////////////
+// obtaining a relative quantity
+//////////////////////////////////
+
+static_assert(quantity_point(42 * m).relative() == 42 * m);
+static_assert(quantity_point(isq::height(42 * m)).relative() == 42 * m);
+
+static_assert(quantity_point(1 * one).relative() == 1 * one);
+static_assert(quantity_point(dimensionless(1 * one)).relative() == 1 * one);
+
+static_assert(quantity_point<isq::height[m], mean_sea_level>(42 * m).relative() == 42 * m);
+static_assert(quantity_point<isq::height[m], ground_level>(42 * m).relative() == 42 * m);
+
+static_assert(quantity_point<isq::height[m], mean_sea_level>(quantity_point<isq::height[m], ground_level>(42 * m))
+                .relative() == 84 * m);
+static_assert(quantity_point<isq::height[m], ground_level>(quantity_point<isq::height[m], mean_sea_level>(84 * m))
+                .relative() == 42 * m);
+
+
+///////////////////////////////////
+// obtaining an absolute quantity
+///////////////////////////////////
+
+static_assert(quantity_point(42 * m).absolute() == 42 * m);
+static_assert(quantity_point(isq::height(42 * m)).absolute() == 42 * m);
+
+static_assert(quantity_point(1 * one).absolute() == 1 * one);
+static_assert(quantity_point(dimensionless(1 * one)).absolute() == 1 * one);
+
+static_assert(quantity_point<isq::height[m], mean_sea_level>(42 * m).absolute() == 42 * m);
+static_assert(quantity_point<isq::height[m], ground_level>(42 * m).absolute() == 84 * m);
+
+static_assert(quantity_point<isq::height[m], mean_sea_level>(quantity_point<isq::height[m], ground_level>(42 * m))
+                .absolute() == 84 * m);
+static_assert(quantity_point<isq::height[m], ground_level>(quantity_point<isq::height[m], mean_sea_level>(84 * m))
+                .absolute() == 84 * m);
+
+
+///////////////////////////////////
+// converting to a different unit
+///////////////////////////////////
+
+static_assert(quantity_point<isq::length[km]>(2. * km)[km].relative().number() == 2.);
+static_assert(quantity_point<isq::length[km]>(2. * km)[m].relative().number() == 2000.);
+static_assert(quantity_point<isq::length[m]>(2000. * m)[km].relative().number() == 2.);
+static_assert(
+  quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>(2 * km)[km].relative().number() == 2);
+static_assert(
+  quantity_point<isq::length[km], absolute_point_origin<isq::length>{}, int>(2 * km)[m].relative().number() == 2000);
+
+#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
+template<template<auto, auto, typename> typename QP>
+concept invalid_unit_conversion = requires {
+  requires !requires {
+    QP<isq::length[m], absolute_point_origin<isq::length>{}, int>(2000 * m)[km];
+  };  // truncating conversion
+  requires !requires { QP<isq::length[m], absolute_point_origin<isq::length>{}, int>(2 * m)[s]; };  // invalid unit
+};
+static_assert(invalid_unit_conversion<quantity_point>);
+#endif
+
+
+/////////
+// CTAD
+/////////
+
+static_assert(std::is_same_v<decltype(quantity_point{123 * m})::rep, int>);
+static_assert(std::is_same_v<decltype(quantity_point{123. * m})::rep, double>);
+static_assert(quantity_point{123. * m}.unit == si::metre);
+static_assert(quantity_point{123. * m}.quantity_spec == kind_of<isq::length>);
+static_assert(quantity_point{123. * h}.unit == si::hour);
+static_assert(quantity_point{123. * h}.quantity_spec == kind_of<isq::time>);
+
+using namespace std::chrono_literals;
+static_assert(std::is_same_v<decltype(quantity_point{sys_seconds{123s}})::rep, std::chrono::seconds::rep>);
+static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{sys_seconds{123s}}.point_origin)>,
+                             chrono_point_origin_<std::chrono::system_clock>>);
+static_assert(quantity_point{sys_seconds{24h}}.unit == si::second);
+static_assert(quantity_point{sys_seconds{24h}}.quantity_spec == kind_of<isq::time>);
+
+
+////////////////////////
 // assignment operator
+////////////////////////
 
 static_assert(([]() {
-                quantity_point<dynamic_origin<dim_length>, metre, int> l1(1_q_m), l2{};
+                quantity_point l1{1 * m}, l2{2 * m};
                 return l2 = l1;
               }())
-                .relative() == 1_q_m);
-
-// static member functions
+                .relative() == 1 * m);
+static_assert(([]() {
+                const quantity_point l1{1 * m};
+                quantity_point l2{2 * m};
+                return l2 = l1;
+              }())
+                .relative() == 1 * m);
+static_assert(([]() {
+                quantity_point l1{1 * m}, l2{2 * m};
+                return l2 = std::move(l1);
+              }())
+                .relative() == 1 * m);
 
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>::min().relative().number() ==
-              std::numeric_limits<int>::lowest());
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>::max().relative().number() ==
-              std::numeric_limits<int>::max());
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>::min().relative().number() ==
-              std::numeric_limits<double>::lowest());
-static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>::max().relative().number() ==
-              std::numeric_limits<double>::max());
 
-// unary member operators
+////////////////////
+// unary operators
+////////////////////
 
 static_assert([](auto v) {
   auto vv = v++;
   return std::pair(v, vv);
-}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m),
-                   quantity_point<dynamic_origin<dim_length>, metre, int>(1000_q_m)));
+}(quantity_point(123 * m)) == std::pair(quantity_point(124 * m), quantity_point(123 * m)));
 static_assert([](auto v) {
   auto vv = ++v;
   return std::pair(v, vv);
-}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m),
-                   quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m)));
+}(quantity_point(123 * m)) == std::pair(quantity_point(124 * m), quantity_point(124 * m)));
 static_assert([](auto v) {
   auto vv = v--;
   return std::pair(v, vv);
-}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m),
-                   quantity_point<dynamic_origin<dim_length>, metre, int>(1000_q_m)));
+}(quantity_point(123 * m)) == std::pair(quantity_point(122 * m), quantity_point(123 * m)));
 static_assert([](auto v) {
   auto vv = --v;
   return std::pair(v, vv);
-}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m),
-                   quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m)));
+}(quantity_point(123 * m)) == std::pair(quantity_point(122 * m), quantity_point(122 * m)));
 
-// compound assignment
-
-static_assert((quantity_point(1_q_m) += 1_q_m).relative().number() == 2);
-static_assert((quantity_point(2_q_m) -= 1_q_m).relative().number() == 1);
-
-// non-member arithmetic operators
-
-static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, metre, int>() + length<metre, double>()),
-                      quantity_point<dynamic_origin<dim_length>, metre, double>>);
-static_assert(compare<decltype(length<metre, int>() + quantity_point<dynamic_origin<dim_length>, metre, double>()),
-                      quantity_point<dynamic_origin<dim_length>, metre, double>>);
-static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, kilometre, int>() + length<metre, double>()),
-                      quantity_point<dynamic_origin<dim_length>, metre, double>>);
-static_assert(compare<decltype(length<kilometre, int>() + quantity_point<dynamic_origin<dim_length>, metre, double>()),
-                      quantity_point<dynamic_origin<dim_length>, metre, double>>);
-static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, metre, double>() - length<metre, int>()),
-                      quantity_point<dynamic_origin<dim_length>, metre, double>>);
-static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, kilometre, double>() - length<metre, int>()),
-                      quantity_point<dynamic_origin<dim_length>, metre, double>>);
-static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, metre, double>() -
-                               quantity_point<dynamic_origin<dim_length>, metre, int>()),
-                      length<metre, double>>);
-static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, kilometre, double>() -
-                               quantity_point<dynamic_origin<dim_length>, metre, int>()),
-                      length<metre, double>>);
-
-static_assert((1_q_m + km).relative().number() == 1001);
-static_assert((quantity_point(1_q_m) + 1_q_km).relative().number() == 1001);
-static_assert((km - 1_q_m).relative().number() == 999);
-static_assert((quantity_point(1_q_km) - quantity_point(1_q_m)).number() == 999);
-
-template<typename Int>
-concept invalid_subtraction =
-  requires(quantity_point<dynamic_origin<dim_length>, metre, Int> lhs,
-           quantity_point<sea_level_origin, metre, Int> rhs) { requires !requires { rhs - lhs; }; };
-static_assert(invalid_subtraction<int>);
-
-// comparators
-
-static_assert(quantity_point(2_q_m) + 1_q_m == quantity_point(3_q_m));
-static_assert(!(2_q_m + quantity_point(2_q_m) == quantity_point(3_q_m)));
-static_assert(quantity_point(2_q_m) + 2_q_m != quantity_point(3_q_m));
-static_assert(!(2_q_m + quantity_point(2_q_m) != quantity_point(4_q_m)));
-static_assert(quantity_point(2_q_m) > quantity_point(1_q_m));
-static_assert(!(quantity_point(1_q_m) > quantity_point(1_q_m)));
-static_assert(quantity_point(1_q_m) < quantity_point(2_q_m));
-static_assert(!(quantity_point(2_q_m) < quantity_point(2_q_m)));
-static_assert(quantity_point(2_q_m) >= quantity_point(1_q_m));
-static_assert(quantity_point(2_q_m) >= quantity_point(2_q_m));
-static_assert(!(quantity_point(2_q_m) >= quantity_point(3_q_m)));
-static_assert(quantity_point(1_q_m) <= quantity_point(2_q_m));
-static_assert(quantity_point(2_q_m) <= quantity_point(2_q_m));
-static_assert(!(quantity_point(3_q_m) <= quantity_point(2_q_m)));
-
-static_assert(quantity_point(3_q_m) == quantity_point(3.0_q_m));
-static_assert(quantity_point(3_q_m) != quantity_point(3.14_q_m));
-static_assert(quantity_point(2_q_m) > quantity_point(1.0_q_m));
-static_assert(quantity_point(1.0_q_m) < quantity_point(2_q_m));
-static_assert(quantity_point(2.0_q_m) >= quantity_point(1_q_m));
-static_assert(quantity_point(1_q_m) <= quantity_point(2.0_q_m));
-
-static_assert(quantity_point(1000_q_m) == quantity_point(1_q_km));
-static_assert(quantity_point(1001_q_m) != quantity_point(1_q_km));
-static_assert(quantity_point(1001_q_m) > quantity_point(1_q_km));
-static_assert(quantity_point(999_q_m) < quantity_point(1_q_km));
-static_assert(quantity_point(1000_q_m) >= quantity_point(1_q_km));
-static_assert(quantity_point(1000_q_m) <= quantity_point(1_q_km));
-
-template<typename Int>
-concept invalid_comparisons = requires(quantity_point<dynamic_origin<dim_length>, metre, Int> lhs,
-                                       quantity_point<sea_level_origin, metre, Int> rhs) {
-  requires !requires { lhs == rhs; };
-  requires !requires { lhs < rhs; };
-};
-static_assert(invalid_comparisons<int>);
-
-// alias units
-
-static_assert(quantity_point(2_q_l) + 2_q_ml == quantity_point(2002_q_ml));
-static_assert(2_q_l + quantity_point(2_q_ml) == quantity_point(2002_q_cm3));
-static_assert(quantity_point(2_q_l) + 2_q_cm3 == quantity_point(2002_q_ml));
-static_assert(2_q_dm3 + quantity_point(2_q_cm3) == quantity_point(2002_q_ml));
-
-// is_quantity_point
-
-static_assert(QuantityPoint<quantity_point<dynamic_origin<dim_length>, millimetre, int>>);
-
-// common_type
-
-static_assert(compare<std::common_type_t<quantity_point<dynamic_origin<dim_length>, metre, int>,
-                                         quantity_point<dynamic_origin<dim_length>, kilometre, int>>,
-                      quantity_point<dynamic_origin<dim_length>, metre, int>>);
-static_assert(compare<std::common_type_t<quantity_point<dynamic_origin<dim_length>, kilometre, long long>,
-                                         quantity_point<dynamic_origin<dim_length>, metre, int>>,
-                      quantity_point<dynamic_origin<dim_length>, metre, long long>>);
-static_assert(compare<std::common_type_t<quantity_point<dynamic_origin<dim_length>, kilometre, long long>,
-                                         quantity_point<dynamic_origin<dim_length>, millimetre, double>>,
-                      quantity_point<dynamic_origin<dim_length>, millimetre, double>>);
-
-// common_type
-
-using namespace units::isq::si::uscs::literals;
-
-static_assert(std::equality_comparable<decltype(quantity_point(1_q_m))>);
-static_assert(std::equality_comparable_with<decltype(quantity_point(1_q_m)), decltype(quantity_point(1_q_km))>);
-static_assert(quantity_point(0_q_m) == quantity_point(0_q_ft_us));
-static_assert(std::equality_comparable_with<decltype(quantity_point(1_q_m)), decltype(quantity_point(1_q_ft_us))>);
-
-// quantity_cast
-
-static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_point(2_q_km))
-                .relative()
-                .number() == 2000);
-static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, kilometre, int>>(quantity_point(2000_q_m))
-                .relative()
-                .number() == 2);
-static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_point(1.23_q_m))
-                .relative()
-                .number() == 1);
-static_assert(quantity_point_cast<length<metre, int>>(quantity_point(2_q_km)).relative().number() == 2000);
-static_assert(quantity_point_cast<length<kilometre, int>>(quantity_point(2000_q_m)).relative().number() == 2);
-static_assert(quantity_point_cast<length<metre, int>>(quantity_point(1.23_q_m)).relative().number() == 1);
-static_assert(quantity_point_cast<metre>(quantity_point(2_q_km)).relative().number() == 2000);
-static_assert(quantity_point_cast<kilometre>(quantity_point(2000_q_m)).relative().number() == 2);
-static_assert(quantity_point_cast<int>(quantity_point(1.23_q_m)).relative().number() == 1);
-static_assert(
-  quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().number() == 2);
 
-template<typename Int>
-concept invalid_cast = requires(Int i) {
-  requires !requires {
-    quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m));
-  };
-  requires !requires {
-    quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
-      quantity_point<sea_level_origin, metre, Int>(i * m));
-  };
+////////////////////////
+// compound assignment
+////////////////////////
+
+// same type
+static_assert((quantity_point(1 * m) += 1 * m).relative().number() == 2);
+static_assert((quantity_point(2 * m) -= 1 * m).relative().number() == 1);
+
+// different types
+static_assert((quantity_point(2.5 * m) += 3 * m).relative().number() == 5.5);
+static_assert((quantity_point(123 * m) += 1 * km).relative().number() == 1123);
+static_assert((quantity_point(5.5 * m) -= 3 * m).relative().number() == 2.5);
+static_assert((quantity_point(1123 * m) -= 1 * km).relative().number() == 123);
+
+
+template<template<auto, auto, typename> typename QP>
+concept invalid_compound_assignments = requires() {
+  // truncating not allowed
+  requires !requires(QP<isq::length[m], absolute_point_origin<isq::length>{}, int> l) { l += 2.5 * m; };
+  requires !requires(QP<isq::length[m], absolute_point_origin<isq::length>{}, int> l) { l -= 2.5 * m; };
+  requires !requires(QP<isq::length[km], absolute_point_origin<isq::length>{}, int> l) { l += 2 * isq::length[m]; };
+  requires !requires(QP<isq::length[km], absolute_point_origin<isq::length>{}, int> l) { l -= 2 * isq::length[m]; };
+
+  // only quantities can be added or subtracted
+  requires !requires(QP<isq::length[m], absolute_point_origin<isq::length>{}, int> l) { l += 2; };
+  requires !requires(QP<isq::length[m], absolute_point_origin<isq::length>{}, int> l) { l -= 2; };
+
+  // no unit constants
+  requires !requires(QP<isq::length[m], absolute_point_origin<isq::length>{}, int> l) { l += m; };
+  requires !requires(QP<isq::length[m], absolute_point_origin<isq::length>{}, int> l) { l -= m; };
 };
-static_assert(invalid_cast<int>);
-
-// time
+static_assert(invalid_compound_assignments<quantity_point>);
 
-static_assert(quantity_point{1_q_h} == quantity_point{3600_q_s});
 
-template<typename Metre>
-concept no_crossdimensional_equality = !requires { quantity_point(1_q_s) == quantity_point(length<Metre, int>(1)); };
+////////////////////
+// binary operators
+////////////////////
 
-static_assert(no_crossdimensional_equality<metre>);
+template<template<auto> typename QP>
+concept invalid_binary_operations = requires {
+  // can't add more generic quantity (violates point_origin quantity_spec)
+  requires !requires { QP<isq::height[m]>(1 * m) + isq::length(1 * m); };
+  requires !requires { isq::length(1 * m) + QP<isq::height[m]>(1 * m); };
 
-// length
+  // can't subtract more generic quantity (violates point_origin quantity_spec)
+  requires !requires { QP<isq::height[m]>(1 * m) - isq::length(1 * m); };
 
-static_assert(quantity_point(1_q_km) != quantity_point(1_q_m));
-static_assert(quantity_point(1_q_km) == quantity_point(1000_q_m));
-static_assert(quantity_point(1_q_km) + 1_q_m == quantity_point(1001_q_m));
-static_assert(1_q_km + quantity_point(1_q_m) == quantity_point(1001_q_m));
+  // quantity point can't be subtracted from a quantity
+  requires !requires { 1 * m - QP<si::metre>(1 * m); };
 
-template<class T>
-concept dimensional_analysis = requires(T t) { pow<2>(t); };
+  // no crossdimensional addition and subtraction
+  requires !requires { QP<si::metre>(1 * m) + 1 * s; };
+  requires !requires { QP<si::metre>(1 * m) - 1 * s; };
 
-static_assert(!dimensional_analysis<quantity_point<dynamic_origin<dim_length>, metre, int>>);
+  // unit constants
+  requires !requires { QP<si::metre>(1) + m; };
+  requires !requires { QP<si::metre>(1) - m; };
+  requires !requires { m + QP<si::metre>(1); };
+  requires !requires { m - QP<si::metre>(1); };
+};
+static_assert(invalid_binary_operations<quantity_point>);
+
+
+// same representation type
+static_assert(is_of_type<quantity_point(1 * m) + 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * m) + 1 * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * km) + 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+
+static_assert(is_of_type<quantity_point(1 * m) + isq::length(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * m) + isq::length(1 * km),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * km) + isq::length(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) + 1 * m,
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) + 1 * km,
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * km)) + 1 * m,
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) + isq::height(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) + isq::height(1 * km),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * km)) + isq::height(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+static_assert(is_of_type<1 * m + quantity_point(1 * m),
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<1 * m + quantity_point(1 * km),
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<1 * km + quantity_point(1 * m),
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+
+static_assert(is_of_type<1 * m + quantity_point(isq::length(1 * m)),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<1 * m + quantity_point(isq::length(1 * km)),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<1 * km + quantity_point(isq::length(1 * m)),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+static_assert(is_of_type<isq::length(1 * m) + quantity_point(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<isq::length(1 * m) + quantity_point(1 * km),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<isq::length(1 * km) + quantity_point(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+
+static_assert(is_of_type<isq::height(1 * m) + quantity_point(isq::length(1 * m)),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<isq::height(1 * m) + quantity_point(isq::length(1 * km)),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<isq::height(1 * km) + quantity_point(isq::length(1 * m)),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+static_assert(is_of_type<quantity_point(1 * m) - 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * km) - 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * m) - 1 * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+
+static_assert(is_of_type<quantity_point(1 * m) - isq::length(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * m) - isq::length(1 * km),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point(1 * km) - isq::length(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<kind_of<isq::length>>{}, int>>);
+
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) - 1 * m,
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) - 1 * km,
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * km)) - 1 * m,
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) - isq::height(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * m)) - isq::height(1 * km),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+static_assert(is_of_type<quantity_point(isq::length(1 * km)) - isq::height(1 * m),
+                         quantity_point<isq::length[m], absolute_point_origin<isq::length>{}, int>>);
+
+// check for integral types promotion
+static_assert(
+  is_same_v<decltype((quantity_point{std::uint8_t(0) * m} + std::uint8_t(0) * m).relative().number()), int&&>);
+static_assert(
+  is_same_v<decltype((std::uint8_t(0) * m + quantity_point{std::uint8_t(0) * m}).relative().number()), int&&>);
+static_assert(
+  is_same_v<decltype((quantity_point{std::uint8_t(0) * m} - std::uint8_t(0) * m).relative().number()), int&&>);
+static_assert((quantity_point{std::uint8_t(128) * m} + std::uint8_t(128) * m).relative().number() ==
+              std::uint8_t(128) + std::uint8_t(128));
+static_assert((std::uint8_t(128) * m + quantity_point{std::uint8_t(128) * m}).relative().number() ==
+              std::uint8_t(128) + std::uint8_t(128));
+static_assert((quantity_point{std::uint8_t(0) * m} - std::uint8_t(1) * m).relative().number() ==
+              std::uint8_t(0) - std::uint8_t(1));
+
+// different representation types
+static_assert(is_of_type<quantity_point{1. * m} + 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1. * m + quantity_point{1 * m},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1 * m} + 1. * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1 * m + quantity_point{1. * km},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1 * km} + 1. * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1 * km + quantity_point{1. * m},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+
+static_assert(is_of_type<quantity_point{1 * m} - 1. * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1. * km} - 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1. * m} - 1 * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+
+// different units
+static_assert(is_of_type<quantity_point{1 * m} + 1 * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<1 * m + quantity_point{1 * km},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point{1. * m} + 1 * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1. * m + quantity_point{1 * km},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1 * m} + 1. * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1 * m + quantity_point{1. * km},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1. * m} + 1. * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1. * m + quantity_point{1. * km},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+
+static_assert(is_of_type<quantity_point{1 * km} + 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<1 * km + quantity_point{1 * m},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point{1. * km} + 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1. * km + quantity_point{1 * m},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1 * km} + 1. * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1 * km + quantity_point{1. * m},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1. * km} + 1. * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<1. * km + quantity_point{1. * m},
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+
+static_assert(is_of_type<quantity_point{1 * m} - 1 * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point{1. * m} - 1 * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1 * m} - 1. * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1. * m} - 1. * km,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+
+static_assert(is_of_type<quantity_point{1 * km} - 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, int>>);
+static_assert(is_of_type<quantity_point{1. * km} - 1 * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1 * km} - 1. * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+static_assert(is_of_type<quantity_point{1. * km} - 1. * m,
+                         quantity_point<si::metre, absolute_point_origin<kind_of<isq::length>>{}, double>>);
+
+static_assert((quantity_point{1 * m} + 1 * m).relative().number() == 2);
+static_assert((1 * m + quantity_point{1 * m}).relative().number() == 2);
+static_assert((quantity_point{1 * m} + 1 * km).relative().number() == 1001);
+static_assert((1 * m + quantity_point{1 * km}).relative().number() == 1001);
+static_assert((quantity_point{1 * km} + 1 * m).relative().number() == 1001);
+static_assert((1 * km + quantity_point{1 * m}).relative().number() == 1001);
+static_assert((quantity_point{2 * m} - 1 * m).relative().number() == 1);
+static_assert((quantity_point{1 * km} - 1 * m).relative().number() == 999);
+
+static_assert((quantity_point{1.5 * m} + 1 * m).relative().number() == 2.5);
+static_assert((1.5 * m + quantity_point{1 * m}).relative().number() == 2.5);
+static_assert((quantity_point{1.5 * m} + 1 * km).relative().number() == 1001.5);
+static_assert((1.5 * m + quantity_point{1 * km}).relative().number() == 1001.5);
+static_assert((quantity_point{1.5 * km} + 1 * m).relative().number() == 1501);
+static_assert((1.5 * km + quantity_point{1 * m}).relative().number() == 1501);
+static_assert((quantity_point{2.5 * m} - 1 * m).relative().number() == 1.5);
+static_assert((quantity_point{1.5 * km} - 1 * m).relative().number() == 1499);
+
+static_assert((quantity_point{1 * m} + 1.5 * m).relative().number() == 2.5);
+static_assert((1 * m + quantity_point{1.5 * m}).relative().number() == 2.5);
+static_assert((quantity_point{1 * m} + 1.5 * km).relative().number() == 1501);
+static_assert((1 * m + quantity_point{1.5 * km}).relative().number() == 1501);
+static_assert((quantity_point{1 * km} + 1.5 * m).relative().number() == 1001.5);
+static_assert((1 * km + quantity_point{1.5 * m}).relative().number() == 1001.5);
+static_assert((quantity_point{2 * m} - 1.5 * m).relative().number() == 0.5);
+static_assert((quantity_point{1 * km} - 1.5 * m).relative().number() == 998.5);
+
+// commutativity and associativity
+static_assert((quantity_point{10 * isq::length[si::metre] / (2 * isq::time[s])} + 5 * isq::speed[m / s]).relative() ==
+              10 * isq::speed[m / s]);
+static_assert((10 * isq::length[si::metre] / (2 * isq::time[s]) + quantity_point{5 * isq::speed[m / s]}).relative() ==
+              10 * isq::speed[m / s]);
+static_assert((quantity_point{5 * isq::speed[m / s]} + 10 * isq::length[m] / (2 * isq::time[s])).relative() ==
+              10 * isq::speed[m / s]);
+static_assert((5 * isq::speed[m / s] + quantity_point{10 * isq::length[m] / (2 * isq::time[s])}).relative() ==
+              10 * isq::speed[m / s]);
+static_assert((quantity_point{10 * isq::length[m] / (2 * isq::time[s])} - 5 * isq::speed[m / s]).relative() ==
+              0 * isq::speed[m / s]);
+static_assert((quantity_point{5 * isq::speed[m / s]} - 10 * isq::length[m] / (2 * isq::time[s])).relative() ==
+              0 * isq::speed[m / s]);
+
+// NOTE: quantity_spec of the origin is not "upgraded" to a better type
+static_assert(is_of_type<quantity_point{10 * isq::length[m] / (2 * isq::time[s])} + 5 * isq::speed[m / s],
+                         quantity_point<isq::speed[m / s], absolute_point_origin<isq::length / isq::time>{}, int>>);
+static_assert(is_of_type<10 * isq::length[m] / (2 * isq::time[s]) + quantity_point{5 * isq::speed[m / s]},
+                         quantity_point<isq::speed[m / s], absolute_point_origin<isq::speed>{}, int>>);
+static_assert(is_of_type<quantity_point{5 * isq::speed[m / s]} + 10 * isq::length[m] / (2 * isq::time[s]),
+                         quantity_point<isq::speed[m / s], absolute_point_origin<isq::speed>{}, int>>);
+static_assert(is_of_type<5 * isq::speed[m / s] + quantity_point{10 * isq::length[m] / (2 * isq::time[s])},
+                         quantity_point<isq::speed[m / s], absolute_point_origin<isq::length / isq::time>{}, int>>);
+static_assert(is_of_type<quantity_point{10 * isq::length[m] / (2 * isq::time[s])} - 5 * isq::speed[m / s],
+                         quantity_point<isq::speed[m / s], absolute_point_origin<isq::length / isq::time>{}, int>>);
+static_assert(is_of_type<quantity_point{5 * isq::speed[m / s]} - 10 * isq::length[m] / (2 * isq::time[s]),
+                         quantity_point<isq::speed[m / s], absolute_point_origin<isq::speed>{}, int>>);
+
+// NOTE: 1 / isq::time[s] works for quantities but not for quantity_point (origin can't be weakened)
+static_assert((quantity_point{10 / (2 * isq::period_duration[s])} + 5 * isq::frequency[Hz]).relative() ==
+              10 * isq::frequency[Hz]);
+static_assert((10 / (2 * isq::period_duration[s]) + quantity_point{5 * isq::frequency[Hz]}).relative() ==
+              10 * isq::frequency[Hz]);
+static_assert((quantity_point{5 * isq::frequency[Hz]} + 10 / (2 * isq::period_duration[s])).relative() ==
+              10 * isq::frequency[Hz]);
+static_assert((5 * isq::frequency[Hz] + quantity_point{10 / (2 * isq::period_duration[s])}).relative() ==
+              10 * isq::frequency[Hz]);
+static_assert((quantity_point{10 / (2 * isq::period_duration[s])} - 5 * isq::frequency[Hz]).relative() ==
+              0 * isq::frequency[Hz]);
+static_assert((quantity_point{5 * isq::frequency[Hz]} - 10 / (2 * isq::period_duration[s])).relative() ==
+              0 * isq::frequency[Hz]);
+
+// NOTE: quantity_spec of the origin is not "upgraded" to a better type
+static_assert(is_of_type<quantity_point{10 / (2 * isq::period_duration[s])} + 5 * isq::frequency[Hz],
+                         quantity_point<isq::frequency[Hz], absolute_point_origin<1 / isq::period_duration>{}, int>>);
+static_assert(is_of_type<10 / (2 * isq::period_duration[s]) + quantity_point{5 * isq::frequency[Hz]},
+                         quantity_point<isq::frequency[Hz], absolute_point_origin<isq::frequency>{}, int>>);
+static_assert(is_of_type<quantity_point{5 * isq::frequency[Hz]} + 10 / (2 * isq::period_duration[s]),
+                         quantity_point<isq::frequency[Hz], absolute_point_origin<isq::frequency>{}, int>>);
+static_assert(is_of_type<5 * isq::frequency[Hz] + quantity_point{10 / (2 * isq::period_duration[s])},
+                         quantity_point<isq::frequency[Hz], absolute_point_origin<1 / isq::period_duration>{}, int>>);
+static_assert(is_of_type<quantity_point{10 / (2 * isq::period_duration[s])} - 5 * isq::frequency[Hz],
+                         quantity_point<isq::frequency[Hz], absolute_point_origin<1 / isq::period_duration>{}, int>>);
+static_assert(is_of_type<quantity_point{5 * isq::frequency[Hz]} - 10 / (2 * isq::period_duration[s]),
+                         quantity_point<isq::frequency[Hz], absolute_point_origin<isq::frequency>{}, int>>);
+
+// Different named dimensions
+template<typename... Ts>
+consteval bool invalid_addition(Ts... ts)
+{
+  return !requires { (... + ts); };
+}
+
+template<typename... Ts>
+consteval bool invalid_subtraction(Ts... ts)
+{
+  return !requires { (... - ts); };
+}
+
+static_assert(invalid_addition(quantity_point{5 * activity[Bq]}, 5 * isq::frequency[Hz]));
+static_assert(invalid_addition(5 * activity[Bq], quantity_point{5 * isq::frequency[Hz]}));
+static_assert(invalid_subtraction(quantity_point{5 * activity[Bq]}, 5 * isq::frequency[Hz]));
+
+static_assert(invalid_addition(quantity_point{5 * activity[Bq]}, 10 / (2 * isq::time[s]), 5 * isq::frequency[Hz]));
+static_assert(invalid_addition(5 * activity[Bq], quantity_point{10 / (2 * isq::time[s])}, 5 * isq::frequency[Hz]));
+static_assert(invalid_addition(5 * activity[Bq], 10 / (2 * isq::time[s]), quantity_point{5 * isq::frequency[Hz]}));
+static_assert(invalid_subtraction(quantity_point{5 * activity[Bq]}, 10 / (2 * isq::time[s]), 5 * isq::frequency[Hz]));
 
 }  // namespace