From 6458cd343c2e85d332b46a20d456706f61f5f97a Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Fri, 26 May 2023 17:05:33 +0200
Subject: [PATCH] ci: pre-commit related changes

---
 test/unit_test/static/CMakeLists.txt          |   2 +-
 .../static/custom_rep_test_min_expl.cpp       |  66 +++---
 test/unit_test/static/fps_test.cpp            |   3 +-
 test/unit_test/static/magnitude_test.cpp      |  16 +-
 test/unit_test/static/quantity_kind_test.cpp  | 218 +++++++++---------
 .../static/quantity_point_kind_test.cpp       | 190 ++++++++-------
 test/unit_test/static/quantity_point_test.cpp |  51 ++--
 7 files changed, 266 insertions(+), 280 deletions(-)

diff --git a/test/unit_test/static/CMakeLists.txt b/test/unit_test/static/CMakeLists.txt
index 434da241..78ab6732 100644
--- a/test/unit_test/static/CMakeLists.txt
+++ b/test/unit_test/static/CMakeLists.txt
@@ -30,7 +30,7 @@ add_library(unit_tests_static_truncating quantity_test.cpp)
 
 target_link_libraries(unit_tests_static_truncating PRIVATE mp-units::mp-units)
 target_compile_options(
-unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
+    unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
 )
 add_library(
     unit_tests_static
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 37a511f2..689c9666 100644
--- a/test/unit_test/static/custom_rep_test_min_expl.cpp
+++ b/test/unit_test/static/custom_rep_test_min_expl.cpp
@@ -51,7 +51,7 @@ public:
   // construction from std::int64_t
   constexpr explicit min_expl(std::intmax_t v) noexcept
     requires(Mode != 2)
-  : value_(v)
+      : value_(v)
   {
   }
 
@@ -187,42 +187,42 @@ 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) {
-                                      requires !requires { +lhs; };
-                                      requires !requires { -lhs; };
-                                      requires !requires { ++lhs; };
-                                      requires !requires { lhs++; };
-                                      requires !requires { --lhs; };
-                                      requires !requires { lhs--; };
+  requires !requires { +lhs; };
+  requires !requires { -lhs; };
+  requires !requires { ++lhs; };
+  requires !requires { 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(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(length<metre, Rep> rhs) { lhs += rhs; };
+  requires !requires(length<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(length<metre, Rep> rhs) { lhs + rhs; };
-                                      requires !requires(length<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(length<metre, Rep> rhs) { lhs + rhs; };
+  requires !requires(length<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(length<metre, int> rhs) { lhs + rhs; };
-                                      requires !requires(length<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(length<metre, int> rhs) { lhs + rhs; };
+  requires !requires(length<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(std::ostream os) { os << lhs; };
-                                    };
+  requires !requires(std::ostream os) { os << lhs; };
+};
 static_assert(invalid_member_operations<min_expl<>>);
 
 // equality
diff --git a/test/unit_test/static/fps_test.cpp b/test/unit_test/static/fps_test.cpp
index 774971e7..b0ca5d71 100644
--- a/test/unit_test/static/fps_test.cpp
+++ b/test/unit_test/static/fps_test.cpp
@@ -100,7 +100,6 @@ static_assert(1_q_ft_pdl_per_s * 10_q_s == 10_q_ft_pdl);
 static_assert(10_q_ft_pdl / 1_q_ft_pdl_per_s == 10_q_s);
 
 static_assert(detail::unit_text<dim_power, foot_poundal_per_second>() == basic_symbol_text("ft⋅pdl/s", "ft pdl/s"));
-static_assert(detail::unit_text<dim_power, foot_pound_force_per_second>() ==
-              basic_symbol_text("ft⋅lbf/s", "ft lbf/s"));
+static_assert(detail::unit_text<dim_power, foot_pound_force_per_second>() == basic_symbol_text("ft⋅lbf/s", "ft lbf/s"));
 
 }  // namespace
diff --git a/test/unit_test/static/magnitude_test.cpp b/test/unit_test/static/magnitude_test.cpp
index 946a1743..eaf2cc17 100644
--- a/test/unit_test/static/magnitude_test.cpp
+++ b/test/unit_test/static/magnitude_test.cpp
@@ -85,14 +85,14 @@ static_assert(is_named_magnitude<mag_2_>);
 // power_v
 template<template<auto, int, int...> typename P>
 concept invalid_power_v = requires {
-                            requires !requires { typename P<123, 0>; };
-                            requires !requires { typename P<123, 0, 2>; };
-                            requires !requires { typename P<123, 1, 0>; };
-                            requires !requires { typename P<123, 0, 0>; };
-                            requires !requires { typename P<123, 1>; };
-                            requires !requires { typename P<123, 1, 1>; };
-                            requires !requires { typename P<123, 5, 5>; };
-                          };
+  requires !requires { typename P<123, 0>; };
+  requires !requires { typename P<123, 0, 2>; };
+  requires !requires { typename P<123, 1, 0>; };
+  requires !requires { typename P<123, 0, 0>; };
+  requires !requires { typename P<123, 1>; };
+  requires !requires { typename P<123, 1, 1>; };
+  requires !requires { typename P<123, 5, 5>; };
+};
 static_assert(invalid_power_v<power_v>);
 
 // get_base
diff --git a/test/unit_test/static/quantity_kind_test.cpp b/test/unit_test/static/quantity_kind_test.cpp
index 1bc7ffc7..d8f427de 100644
--- a/test/unit_test/static/quantity_kind_test.cpp
+++ b/test/unit_test/static/quantity_kind_test.cpp
@@ -110,17 +110,16 @@ static_assert(sizeof(width<metre, double>) == sizeof(double));
 static_assert(sizeof(height<metre, short>) == sizeof(short));
 
 template<typename Width>
-concept invalid_types =
-  requires {
-    requires !requires { typename quantity_kind<Width, second, int>; };           // unit of a different dimension
-    requires !requires { typename quantity_kind<Width, metre, length<metre>>; };  // quantity used as Rep
-    requires !requires {                                                          // quantity point used as Rep
-                typename quantity_kind<Width, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
-              };
-    requires !requires { typename quantity_kind<Width, metre, width<metre>>; };  // quantity kind used as Rep
-    requires !requires { typename quantity_kind<metre, Width, double>; };        // reordered arguments
-    requires !requires { typename quantity_kind<metre, double, Width>; };        // reordered arguments
+concept invalid_types = requires {
+  requires !requires { typename quantity_kind<Width, second, int>; };           // unit of a different dimension
+  requires !requires { typename quantity_kind<Width, metre, length<metre>>; };  // quantity used as Rep
+  requires !requires {                                                          // quantity point used as Rep
+    typename quantity_kind<Width, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
   };
+  requires !requires { typename quantity_kind<Width, metre, width<metre>>; };  // quantity kind used as Rep
+  requires !requires { typename quantity_kind<metre, Width, double>; };        // reordered arguments
+  requires !requires { typename quantity_kind<metre, double, Width>; };        // reordered arguments
+};
 static_assert(invalid_types<width_kind>);
 
 static_assert(std::is_trivially_default_constructible_v<width<metre>>);
@@ -437,45 +436,44 @@ static_assert(same((-width<metre, short>(short{1} * m)).common(), int{-1} * m));
 
 template<typename K, typename U, typename Qx>
 concept invalid_compound_assignments_ = requires(quantity_kind<K, U, int> w, Qx q) {
-                                          requires !requires { w += q; };
-                                          requires !requires { w -= q; };
-                                          requires !requires { w *= q; };
-                                          requires !requires { w /= q; };
-                                          requires !requires { w %= q; };
-                                        };
+  requires !requires { w += q; };
+  requires !requires { w -= q; };
+  requires !requires { w *= q; };
+  requires !requires { w /= q; };
+  requires !requires { w %= q; };
+};
 template<typename Width>
-concept invalid_compound_assignments =
-  requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
-    requires !requires { w += 1; };
-    requires !requires { w -= 1; };
-    requires !requires { w *= 1 * (km / m); };
-    requires !requires { w /= 1 * (km / m); };
-    requires !requires { w %= 1 * (km / m); };
-    requires !requires { w += m; };
-    requires !requires { w -= m; };
-    requires !requires { w *= m; };
-    requires !requires { w /= m; };
-    requires !requires { w %= m; };
-    requires !requires {
-                w *= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
-              };
-    requires !requires {
-                w /= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
-              };
-    requires !requires {
-                w %= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
-              };
-    requires !requires { w %= 1.0; };
-    requires !requires { w %= quantity(1.0); };
-    requires !requires { w %= 1.0 * (w / w); };
-    requires !requires { w %= 1.0 * w; };
-    requires !requires { w %= h / h; };
-    requires invalid_compound_assignments_<Width, metre, length<metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, height<metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, horizontal_area<square_metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, std::chrono::seconds>;
+concept invalid_compound_assignments = requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
+  requires !requires { w += 1; };
+  requires !requires { w -= 1; };
+  requires !requires { w *= 1 * (km / m); };
+  requires !requires { w /= 1 * (km / m); };
+  requires !requires { w %= 1 * (km / m); };
+  requires !requires { w += m; };
+  requires !requires { w -= m; };
+  requires !requires { w *= m; };
+  requires !requires { w /= m; };
+  requires !requires { w %= m; };
+  requires !requires {
+    w *= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
   };
+  requires !requires {
+    w /= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
+  };
+  requires !requires {
+    w %= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
+  };
+  requires !requires { w %= 1.0; };
+  requires !requires { w %= quantity(1.0); };
+  requires !requires { w %= 1.0 * (w / w); };
+  requires !requires { w %= 1.0 * w; };
+  requires !requires { w %= h / h; };
+  requires invalid_compound_assignments_<Width, metre, length<metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, height<metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, horizontal_area<square_metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, std::chrono::seconds>;
+};
 static_assert(invalid_compound_assignments<width_kind>);
 static_assert(invalid_compound_assignments_<time_kind, second, std::chrono::seconds>);
 
@@ -728,24 +726,24 @@ static_assert(std::equality_comparable_with<width<cgs::centimetre, int>, width<m
 static_assert(std::equality_comparable_with<width<metre>, width<cgs::centimetre>>);
 template<typename Width>
 concept invalid_equality = requires(quantity_kind<Width, metre, int> w) {
-                             requires !requires { w == 1; };
-                             requires !requires { w != 1.0; };
-                             requires !requires { w == 1 * m; };
-                             requires !requires { w != 1.0 * cgs_cm; };
-                             requires !requires { w == 1 * km; };
-                             requires !requires { w != m; };
-                             requires !requires { w == km; };
-                             requires !requires { w != quantity(1); };
-                             requires !requires { w == dimensionless<percent>(1.0); };
-                             requires !requires { w != height<metre, int>(1 * m); };
-                             requires !requires { w == height<kilometre, double>(1.0 * km); };
-                             requires !requires { w != horizontal_area<square_metre, int>(1 * (m * m)); };
-                             requires !requires { w == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-                             requires !requires { w != quantity_point(1 * m); };
-                             requires !requires { w == quantity_point(1.0 * mm); };
-                             requires !requires { w != quantity_point(quantity(1)); };
-                             requires !requires { w == quantity_point(dimensionless<percent>(1.0)); };
-                           };
+  requires !requires { w == 1; };
+  requires !requires { w != 1.0; };
+  requires !requires { w == 1 * m; };
+  requires !requires { w != 1.0 * cgs_cm; };
+  requires !requires { w == 1 * km; };
+  requires !requires { w != m; };
+  requires !requires { w == km; };
+  requires !requires { w != quantity(1); };
+  requires !requires { w == dimensionless<percent>(1.0); };
+  requires !requires { w != height<metre, int>(1 * m); };
+  requires !requires { w == height<kilometre, double>(1.0 * km); };
+  requires !requires { w != horizontal_area<square_metre, int>(1 * (m * m)); };
+  requires !requires { w == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { w != quantity_point(1 * m); };
+  requires !requires { w == quantity_point(1.0 * mm); };
+  requires !requires { w != quantity_point(quantity(1)); };
+  requires !requires { w == quantity_point(dimensionless<percent>(1.0)); };
+};
 static_assert(invalid_equality<width_kind>);
 
 static_assert(width<metre, int>(1 * m) < width<metre, int>(2 * m));
@@ -760,22 +758,22 @@ static_assert(std::three_way_comparable_with<width<cgs::centimetre, int>, width<
 static_assert(std::three_way_comparable_with<width<metre>, width<cgs::centimetre>>);
 template<typename Width>
 concept invalid_relational = requires(quantity_kind<Width, metre, int> w) {
-                               requires !requires { w < 1; };
-                               requires !requires { w <= 1.0; };
-                               requires !requires { w >= 1 * m; };
-                               requires !requires { w > 1.0 * cgs_cm; };
-                               requires !requires { w <=> 1 * km; };
-                               requires !requires { w < quantity(1); };
-                               requires !requires { w <= dimensionless<percent>(1.0); };
-                               requires !requires { w >= height<metre, int>(1 * m); };
-                               requires !requires { w > height<kilometre, double>(1.0 * km); };
-                               requires !requires { w <=> horizontal_area<square_metre, int>(1 * (m * m)); };
-                               requires !requires { w < rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-                               requires !requires { w <= quantity_point(1 * m); };
-                               requires !requires { w >= quantity_point(1.0 * mm); };
-                               requires !requires { w > quantity_point(quantity(1)); };
-                               requires !requires { w <=> quantity_point(dimensionless<percent>(1.0)); };
-                             };
+  requires !requires { w < 1; };
+  requires !requires { w <= 1.0; };
+  requires !requires { w >= 1 * m; };
+  requires !requires { w > 1.0 * cgs_cm; };
+  requires !requires { w <=> 1 * km; };
+  requires !requires { w < quantity(1); };
+  requires !requires { w <= dimensionless<percent>(1.0); };
+  requires !requires { w >= height<metre, int>(1 * m); };
+  requires !requires { w > height<kilometre, double>(1.0 * km); };
+  requires !requires { w <=> horizontal_area<square_metre, int>(1 * (m * m)); };
+  requires !requires { w < rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { w <= quantity_point(1 * m); };
+  requires !requires { w >= quantity_point(1.0 * mm); };
+  requires !requires { w > quantity_point(quantity(1)); };
+  requires !requires { w <=> quantity_point(dimensionless<percent>(1.0)); };
+};
 static_assert(invalid_relational<width_kind>);
 
 
@@ -814,37 +812,35 @@ static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<metre, doub
 static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<cgs::centimetre, int>(1 * cgs_cm)), width<cgs::centimetre, int>(1 * cgs_cm)));
 // clang-format on
 template<typename Width>
-concept invalid_cast =
-  requires {
-    requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires {
-                quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires {
-                quantity_kind_cast<rate_of_climb<metre_per_second, int>>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires { quantity_kind_cast<apple>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<horizontal_area_kind>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<rate_of_climb_kind>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<apple, one>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires {
-                quantity_kind_cast<horizontal_area_kind, square_metre>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires {
-                quantity_kind_cast<rate_of_climb_kind, metre_per_second>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires { quantity_kind_cast<dimensionless<one>>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires {
-                quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(
-                  quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires {
-                quantity_kind_cast<quantity_point<dynamic_origin<dimension_one>, one, int>>(
-                  quantity_kind<Width, metre, int>(1 * m));
-              };
+concept invalid_cast = requires {
+  requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires {
+    quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m));
   };
+  requires !requires {
+    quantity_kind_cast<rate_of_climb<metre_per_second, int>>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires { quantity_kind_cast<apple>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<horizontal_area_kind>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<rate_of_climb_kind>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<apple, one>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires {
+    quantity_kind_cast<horizontal_area_kind, square_metre>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires {
+    quantity_kind_cast<rate_of_climb_kind, metre_per_second>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires { quantity_kind_cast<dimensionless<one>>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires {
+    quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires {
+    quantity_kind_cast<quantity_point<dynamic_origin<dimension_one>, one, int>>(
+      quantity_kind<Width, metre, int>(1 * m));
+  };
+};
 static_assert(invalid_cast<width_kind>);
 
 
diff --git a/test/unit_test/static/quantity_point_kind_test.cpp b/test/unit_test/static/quantity_point_kind_test.cpp
index 9a234a29..07de439b 100644
--- a/test/unit_test/static/quantity_point_kind_test.cpp
+++ b/test/unit_test/static/quantity_point_kind_test.cpp
@@ -150,21 +150,20 @@ static_assert(sizeof(abscissa<metre, double>) == sizeof(double));
 static_assert(sizeof(ordinate<metre, short>) == sizeof(short));
 
 template<typename Width, typename Abscissa>
-concept invalid_types =
-  requires {
-    requires !requires { typename quantity_point_kind<Width, metre, int>; };      // width_kind is not a point kind
-    requires !requires { typename quantity_point_kind<Abscissa, second, int>; };  // unit of a different dimension
-    requires !requires { typename quantity_point_kind<Abscissa, metre, length<metre>>; };  // quantity used as Rep
-    requires !requires {
-                typename quantity_point_kind<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
-              };                                                                          // quantity point used as Rep
-    requires !requires { typename quantity_point_kind<Abscissa, metre, width<metre>>; };  // quantity kind used as Rep
-    requires !requires {
-                typename quantity_point_kind<Abscissa, metre, abscissa<metre>>;
-              };                                                                    // quantity point kind used as Rep
-    requires !requires { typename quantity_point_kind<metre, Abscissa, double>; };  // reordered arguments
-    requires !requires { typename quantity_point_kind<metre, double, Abscissa>; };  // reordered arguments
-  };
+concept invalid_types = requires {
+  requires !requires { typename quantity_point_kind<Width, metre, int>; };      // width_kind is not a point kind
+  requires !requires { typename quantity_point_kind<Abscissa, second, int>; };  // unit of a different dimension
+  requires !requires { typename quantity_point_kind<Abscissa, metre, length<metre>>; };  // quantity used as Rep
+  requires !requires {
+    typename quantity_point_kind<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
+  };                                                                                    // quantity point used as Rep
+  requires !requires { typename quantity_point_kind<Abscissa, metre, width<metre>>; };  // quantity kind used as Rep
+  requires !requires {
+    typename quantity_point_kind<Abscissa, metre, abscissa<metre>>;
+  };                                                                              // quantity point kind used as Rep
+  requires !requires { typename quantity_point_kind<metre, Abscissa, double>; };  // reordered arguments
+  requires !requires { typename quantity_point_kind<metre, double, Abscissa>; };  // reordered arguments
+};
 static_assert(invalid_types<width_kind, abscissa_kind>);
 
 static_assert(std::is_trivially_default_constructible_v<abscissa<metre>>);
@@ -474,20 +473,19 @@ static_assert([]() {
 
 template<typename PK, typename U, typename Qx>
 concept invalid_compound_assignments_ = requires(quantity_point_kind<PK, U, int> x, Qx q) {
-                                          requires !requires { x += q; };
-                                          requires !requires { x -= q; };
-                                        };
+  requires !requires { x += q; };
+  requires !requires { x -= q; };
+};
 template<typename Abscissa>
-concept invalid_compound_assignments =
-  requires(quantity_point_kind<Abscissa, metre, int> x) {
-    requires !requires { x += 1; };
-    requires !requires { x -= 1; };
-    requires invalid_compound_assignments_<Abscissa, metre, length<metre, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, height<metre, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, rate_of_climb<metre_per_second, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, std::chrono::seconds>;
-  };
+concept invalid_compound_assignments = requires(quantity_point_kind<Abscissa, metre, int> x) {
+  requires !requires { x += 1; };
+  requires !requires { x -= 1; };
+  requires invalid_compound_assignments_<Abscissa, metre, length<metre, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, height<metre, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, rate_of_climb<metre_per_second, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, std::chrono::seconds>;
+};
 static_assert(invalid_compound_assignments<abscissa_kind>);
 static_assert(invalid_compound_assignments_<time_point_kind, second, std::chrono::seconds>);
 #if __cpp_lib_chrono >= 201907L
@@ -564,26 +562,26 @@ static_assert(std::equality_comparable_with<abscissa<metre>, abscissa<cgs::centi
 // clang-format on
 template<typename Int>
 concept invalid_equality = requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
-                             requires !requires { x == 1; };
-                             requires !requires { x != 1.0; };
-                             requires !requires { x == 1 * m; };
-                             requires !requires { x != 1.0 * cgs_cm; };
-                             requires !requires { x == 1 * km; };
-                             requires !requires { x != quantity(1); };
-                             requires !requires { x == dimensionless<percent>(1.0); };
-                             requires !requires { x != width<metre, int>(1 * m); };
-                             requires !requires { x == width<kilometre, double>(1.0 * km); };
-                             requires !requires { x != height<metre, int>(1 * m); };
-                             requires !requires { x == height<kilometre, double>(1.0 * km); };
-                             requires !requires { x == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-                             requires !requires { x != quantity_point(1 * m); };
-                             requires !requires { x == quantity_point(1.0 * mm); };
-                             requires !requires { x != quantity_point(quantity(1)); };
-                             requires !requires { x == quantity_point(dimensionless<percent>(1.0)); };
-                             requires !requires { x != quantity_point_kind(cgs_width<metre, int>(1 * m)); };
-                             requires !requires { x == ordinate<metre, int>(1 * m); };
-                             requires !requires { screen_si_width<metre, Int>{} != screen_si_cgs_width<metre, Int>{}; };
-                           };
+  requires !requires { x == 1; };
+  requires !requires { x != 1.0; };
+  requires !requires { x == 1 * m; };
+  requires !requires { x != 1.0 * cgs_cm; };
+  requires !requires { x == 1 * km; };
+  requires !requires { x != quantity(1); };
+  requires !requires { x == dimensionless<percent>(1.0); };
+  requires !requires { x != width<metre, int>(1 * m); };
+  requires !requires { x == width<kilometre, double>(1.0 * km); };
+  requires !requires { x != height<metre, int>(1 * m); };
+  requires !requires { x == height<kilometre, double>(1.0 * km); };
+  requires !requires { x == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { x != quantity_point(1 * m); };
+  requires !requires { x == quantity_point(1.0 * mm); };
+  requires !requires { x != quantity_point(quantity(1)); };
+  requires !requires { x == quantity_point(dimensionless<percent>(1.0)); };
+  requires !requires { x != quantity_point_kind(cgs_width<metre, int>(1 * m)); };
+  requires !requires { x == ordinate<metre, int>(1 * m); };
+  requires !requires { screen_si_width<metre, Int>{} != screen_si_cgs_width<metre, Int>{}; };
+};
 static_assert(invalid_equality<int>);
 
 // clang-format off
@@ -599,28 +597,27 @@ static_assert(std::three_way_comparable_with<abscissa<cgs::centimetre, int>, abs
 static_assert(std::three_way_comparable_with<abscissa<metre>, abscissa<cgs::centimetre>>);
 // clang-format on
 template<typename Int>
-concept invalid_relational =
-  requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
-    requires !requires { x < 1; };
-    requires !requires { x <= 1.0; };
-    requires !requires { x >= 1 * m; };
-    requires !requires { x > 1.0 * cgs_cm; };
-    requires !requires { x <=> 1 * km; };
-    requires !requires { x < quantity(1); };
-    requires !requires { x <= dimensionless<percent>(1.0); };
-    requires !requires { x >= width<metre, int>(1 * m); };
-    requires !requires { x > width<kilometre, double>(1.0 * km); };
-    requires !requires { x <=> height<metre, int>(1 * m); };
-    requires !requires { x < height<kilometre, double>(1.0 * km); };
-    requires !requires { x <= rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-    requires !requires { x >= quantity_point(1 * m); };
-    requires !requires { x > quantity_point(1.0 * mm); };
-    requires !requires { x <=> quantity_point(quantity(1)); };
-    requires !requires { x < quantity_point(dimensionless<percent>(1.0)); };
-    requires !requires { x <= quantity_point_kind(cgs_width<metre, int>(1 * m)); };
-    requires !requires { x >= ordinate<metre, int>(1 * m); };
-    requires !requires { screen_si_width<metre, Int>{} > screen_si_cgs_width<metre, Int>{}; };
-  };
+concept invalid_relational = requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
+  requires !requires { x < 1; };
+  requires !requires { x <= 1.0; };
+  requires !requires { x >= 1 * m; };
+  requires !requires { x > 1.0 * cgs_cm; };
+  requires !requires { x <=> 1 * km; };
+  requires !requires { x < quantity(1); };
+  requires !requires { x <= dimensionless<percent>(1.0); };
+  requires !requires { x >= width<metre, int>(1 * m); };
+  requires !requires { x > width<kilometre, double>(1.0 * km); };
+  requires !requires { x <=> height<metre, int>(1 * m); };
+  requires !requires { x < height<kilometre, double>(1.0 * km); };
+  requires !requires { x <= rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { x >= quantity_point(1 * m); };
+  requires !requires { x > quantity_point(1.0 * mm); };
+  requires !requires { x <=> quantity_point(quantity(1)); };
+  requires !requires { x < quantity_point(dimensionless<percent>(1.0)); };
+  requires !requires { x <= quantity_point_kind(cgs_width<metre, int>(1 * m)); };
+  requires !requires { x >= ordinate<metre, int>(1 * m); };
+  requires !requires { screen_si_width<metre, Int>{} > screen_si_cgs_width<metre, Int>{}; };
+};
 static_assert(invalid_relational<int>);
 
 
@@ -672,35 +669,32 @@ static_assert(comp(quantity_point_kind_cast<length<centimetre, int>>(abscissa<cg
 static_assert(same(quantity_point_kind_cast<screen_si_cgs_width<metre, int>>(screen_si_width<metre, int>(1 * m)), screen_si_cgs_width<metre, int>(1 * m)));
 // clang-format on
 template<typename Int>
-concept invalid_cast =
-  requires(Int i) {
-    requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<rate_of_climb_kind>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<apple, one>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<width_kind, metre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<width_kind, kilometre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<height_kind, metre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<height_kind, kilometre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<cgs_width_kind, cgs::centimetre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<rate_of_climb_kind, metre_per_second>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<dimensionless<one>>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
-    requires !requires {
-                quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
-                  abscissa<metre, Int>(i * m));
-              };
-    requires !requires {
-                quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(
-                  abscissa<metre, Int>(i * m));
-              };
-    requires !requires {
-                quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
-                  screen_si_width<metre, Int>(i * m));
-              };
+concept invalid_cast = requires(Int i) {
+  requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<rate_of_climb_kind>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<apple, one>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<width_kind, metre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<width_kind, kilometre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<height_kind, metre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<height_kind, kilometre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<cgs_width_kind, cgs::centimetre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<rate_of_climb_kind, metre_per_second>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<dimensionless<one>>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
+  requires !requires {
+    quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(abscissa<metre, Int>(i * m));
   };
+  requires !requires {
+    quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(abscissa<metre, Int>(i * m));
+  };
+  requires !requires {
+    quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
+      screen_si_width<metre, Int>(i * m));
+  };
+};
 static_assert(invalid_cast<int>);
 
 
diff --git a/test/unit_test/static/quantity_point_test.cpp b/test/unit_test/static/quantity_point_test.cpp
index 8eb42c4c..cd57a32d 100644
--- a/test/unit_test/static/quantity_point_test.cpp
+++ b/test/unit_test/static/quantity_point_test.cpp
@@ -46,22 +46,20 @@ struct sea_level_origin : point_origin<dim_length> {};
 // class invariants
 
 template<typename DimLength>
-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>; };
+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>; };
+};
 
 static_assert(invalid_types<dim_length>);
 
@@ -237,9 +235,9 @@ 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; };
-                              };
+  requires !requires { lhs == rhs; };
+  requires !requires { lhs < rhs; };
+};
 static_assert(invalid_comparisons<int>);
 
 // alias units
@@ -295,16 +293,15 @@ 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));
-              };
+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));
+  };
+};
 static_assert(invalid_cast<int>);
 
 // time