[clang-format]

test/static/chrono_test.cpp

@@ -63,7 +63,8 @@ static_assert(std::constructible_from<quantity<(isq::time[si::hour]), std::chron
 static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
 static_assert(std::constructible_from<quantity<(isq::time[si::second]), std::chrono::hours::rep>, std::chrono::hours>);
 static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::second]), std::chrono::hours::rep>>);
-static_assert(!std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::seconds::rep>, std::chrono::seconds>);
+static_assert(
+  !std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::seconds::rep>, std::chrono::seconds>);
 static_assert(!std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::hour]), std::chrono::seconds::rep>>);
 static_assert(
   std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
@@ -76,7 +77,8 @@ static_assert(std::convertible_to<sys_days, time_point<(si::day), std::chrono::s
 static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_days::rep>, sys_days>);
 static_assert(!std::constructible_from<time_point<(si::second), std::chrono::steady_clock, sys_days::rep>, sys_days>);
 static_assert(std::convertible_to<sys_days, time_point<(si::second), std::chrono::system_clock, sys_days::rep>>);
-static_assert(!std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+static_assert(
+  !std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
 static_assert(!std::convertible_to<sys_seconds, time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>>);
 
 // construction - different rep type (integral to a floating-point)

test/static/custom_rep_test_min_impl.cpp

@@ -102,7 +102,8 @@ static_assert(creates_quantity<min_impl<double>, percent>);
 static_assert(std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
 static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
 
-static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
+static_assert(
+  std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
 static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
 
 static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<int>>>);
@@ -122,8 +123,8 @@ static_assert(std::convertible_to<quantity<(si::metre), double>, quantity<(si::m
 static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
 static_assert(std::convertible_to<quantity<(si::metre), int>, quantity<(si::metre), min_impl<double>>>);
 
-static_assert(
-  !std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), double>>);  // narrowing conversion
+static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>,
+                                       quantity<(si::metre), double>>);  // narrowing conversion
 static_assert(!std::convertible_to<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
 
 // min_impl<T> -> T
@@ -136,8 +137,8 @@ static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quant
 static_assert(std::constructible_from<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
 static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), double>>);
 
-static_assert(
-  !std::constructible_from<quantity<(si::metre), int>, quantity<(si::metre), min_impl<double>>>);  // narrowing conversion
+static_assert(!std::constructible_from<quantity<(si::metre), int>,
+                                       quantity<(si::metre), min_impl<double>>>);  // narrowing conversion
 static_assert(!std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
 
 

test/static/quantity_point_test.cpp

@@ -236,7 +236,8 @@ 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, zeroth_point_origin_<kind_of<isq::length>>>);
-static_assert(is_of_type<quantity_point<(si::metre)>::absolute_point_origin, zeroth_point_origin_<kind_of<isq::length>>>);
+static_assert(
+  is_of_type<quantity_point<(si::metre)>::absolute_point_origin, zeroth_point_origin_<kind_of<isq::length>>>);
 
 static_assert(quantity_point<isq::height[m]>::reference == isq::height[m]);
 static_assert(quantity_point<isq::height[m]>::quantity_spec == isq::height);
@@ -257,7 +258,8 @@ static_assert(quantity_point<isq::height[m], mean_sea_level>::quantity_spec == i
 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(
+  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);
@@ -288,8 +290,9 @@ static_assert(quantity_point<isq::thermodynamic_temperature[si::kelvin], si::abs
 static_assert(quantity_point<isq::thermodynamic_temperature[si::kelvin], si::absolute_zero>::dimension ==
               isq::dim_thermodynamic_temperature);
 static_assert(quantity_point<isq::thermodynamic_temperature[si::kelvin], si::absolute_zero>::unit == si::kelvin);
-static_assert(is_of_type<quantity_point<(isq::thermodynamic_temperature[si::kelvin]), (si::absolute_zero)>::point_origin,
-                         struct si::absolute_zero>);
+static_assert(
+  is_of_type<quantity_point<(isq::thermodynamic_temperature[si::kelvin]), (si::absolute_zero)>::point_origin,
+             struct si::absolute_zero>);
 static_assert(
   is_of_type<quantity_point<(isq::thermodynamic_temperature[si::kelvin]), (si::absolute_zero)>::absolute_point_origin,
              struct si::absolute_zero>);
@@ -303,8 +306,9 @@ static_assert(quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_
 static_assert(quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_zero>::unit == si::kelvin);
 static_assert(is_of_type<quantity_point<(isq::Celsius_temperature[si::kelvin]), (si::absolute_zero)>::point_origin,
                          struct si::absolute_zero>);
-static_assert(is_of_type<quantity_point<(isq::Celsius_temperature[si::kelvin]), (si::absolute_zero)>::absolute_point_origin,
-                         struct si::absolute_zero>);
+static_assert(
+  is_of_type<quantity_point<(isq::Celsius_temperature[si::kelvin]), (si::absolute_zero)>::absolute_point_origin,
+             struct si::absolute_zero>);
 
 static_assert(quantity_point<si::degree_Celsius, si::ice_point>::reference == si::degree_Celsius);
 static_assert(quantity_point<si::degree_Celsius, si::ice_point>::quantity_spec ==
@@ -545,7 +549,8 @@ static_assert(std::convertible_to<quantity_point<(si::metre)>, quantity_point<(i
 
 static_assert(
   std::constructible_from<quantity_point<(isq::length[m]) / isq::time[s]>, quantity_point<(isq::speed[m / s])>>);
-static_assert(std::convertible_to<quantity_point<(isq::speed[m / s])>, quantity_point<(isq::length[m]) / isq::time[s]>>);
+static_assert(
+  std::convertible_to<quantity_point<(isq::speed[m / s])>, quantity_point<(isq::length[m]) / isq::time[s]>>);
 
 static_assert(std::constructible_from<quantity_point<m / s>, quantity_point<(isq::speed[m / s])>>);
 static_assert(std::convertible_to<quantity_point<(isq::speed[m / s])>, quantity_point<m / s>>);
@@ -577,12 +582,14 @@ static_assert(!std::convertible_to<quantity_point<(isq::height[m])>, quantity_po
 // mixed origins
 static_assert(!std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre)>>);
 static_assert(!std::convertible_to<quantity_point<(si::metre)>, quantity_point<(si::metre), mean_sea_level>>);
-static_assert(!std::constructible_from<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>>);
 
 static_assert(!std::constructible_from<quantity_point<(si::metre)>, quantity_point<(si::metre), mean_sea_level>>);
 static_assert(!std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre)>>);
-static_assert(!std::constructible_from<quantity_point<(isq::height[m])>, quantity_point<(isq::height[m]), mean_sea_level>>);
+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])>>);
 
 // same explicit origins
@@ -593,26 +600,26 @@ static_assert(
 
 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(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
 static_assert(std::constructible_from<quantity_point<(isq::height[km]), 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[km]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
+                                  quantity_point<(isq::height[km]), mean_sea_level>>);
 
 static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
                                       quantity_point<(isq::height[km]), mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<(isq::height[km]), mean_sea_level>, quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[km]), mean_sea_level>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(
-  std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(si::metre), 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<(si::metre), mean_sea_level>>);
 
-static_assert(
-  std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity_point<(si::metre), mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(si::metre), mean_sea_level>>);
 static_assert(
   std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
@@ -623,20 +630,21 @@ static_assert(std::convertible_to<quantity_point<special_height[m], mean_sea_lev
 
 static_assert(
   std::constructible_from<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), ground_level>>);
-static_assert(std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), ground_level>>);
-
 static_assert(
-  std::constructible_from<quantity_point<(isq::height[m]), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
+  std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), ground_level>>);
+
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), ground_level>,
+                                      quantity_point<(isq::height[m]), ground_level>>);
 static_assert(
   std::convertible_to<quantity_point<(isq::height[m]), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
 
 static_assert(std::constructible_from<quantity_point<(isq::height[km]), ground_level>,
                                       quantity_point<(isq::height[m]), mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<(isq::height[m]), ground_level>, quantity_point<(isq::height[km]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), ground_level>,
+                                  quantity_point<(isq::height[km]), mean_sea_level>>);
 
-static_assert(
-  std::constructible_from<quantity_point<(isq::height[m]), ground_level>, quantity_point<(isq::height[km]), ground_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), ground_level>,
+                                      quantity_point<(isq::height[km]), ground_level>>);
 static_assert(
   std::convertible_to<quantity_point<(isq::height[km]), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
 
@@ -657,11 +665,13 @@ static_assert(
 
 static_assert(
   std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre), ground_level>>);
-static_assert(std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), mean_sea_level>>);
+static_assert(
+  std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), mean_sea_level>>);
 
 static_assert(
   std::constructible_from<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), mean_sea_level>>);
-static_assert(std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre), ground_level>>);
+static_assert(
+  std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre), ground_level>>);
 
 static_assert(
   std::constructible_from<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), other_ground_level>>);
@@ -684,25 +694,25 @@ static_assert(
 
 static_assert(std::constructible_from<quantity_point<(isq::length[m]), zeroth_length>,
                                       quantity_point<(isq::height[m]), zeroth_length>>);
-static_assert(
-  std::convertible_to<quantity_point<(isq::height[m]), zeroth_length>, quantity_point<(isq::length[m]), zeroth_length>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), zeroth_length>,
+                                  quantity_point<(isq::length[m]), zeroth_length>>);
 
 // quantity_specs with common_quantity_spec
 static_assert(!std::constructible_from<quantity_point<(isq::width[m]), zeroth_length>,
                                        quantity_point<(isq::height[m]), zeroth_length>>);
-static_assert(
-  !std::convertible_to<quantity_point<(isq::height[m]), zeroth_length>, quantity_point<(isq::width[m]), zeroth_length>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), zeroth_length>,
+                                   quantity_point<(isq::width[m]), zeroth_length>>);
 
 static_assert(!std::constructible_from<quantity_point<(isq::height[m]), zeroth_length>,
                                        quantity_point<(isq::width[m]), zeroth_length>>);
-static_assert(
-  !std::convertible_to<quantity_point<(isq::width[m]), zeroth_length>, quantity_point<(isq::height[m]), zeroth_length>>);
+static_assert(!std::convertible_to<quantity_point<(isq::width[m]), zeroth_length>,
+                                   quantity_point<(isq::height[m]), zeroth_length>>);
 
 // different dimensions
-static_assert(
-  !std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity_point<(si::kelvin), (si::ice_point)>>);
-static_assert(
-  !std::convertible_to<quantity_point<(si::kelvin), (si::ice_point)>, quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                       quantity_point<(si::kelvin), (si::ice_point)>>);
+static_assert(!std::convertible_to<quantity_point<(si::kelvin), (si::ice_point)>,
+                                   quantity_point<(isq::height[m]), mean_sea_level>>);
 
 // non-convertible quantity_specs
 static_assert(!std::constructible_from<quantity_point<special_height[m], mean_sea_level>,
@@ -748,16 +758,16 @@ static_assert(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_leve
 // 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(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(
-  std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(si::metre), 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<(si::metre), mean_sea_level>>);
 
-static_assert(
-  std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity_point<(si::metre), mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(si::metre), mean_sea_level>>);
 static_assert(
   std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
@@ -793,8 +803,8 @@ 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]), chrono_point_origin<std::chrono::steady_clock>>, sys_seconds>);
+static_assert(!std::constructible_from<quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::steady_clock>>,
+                                       sys_seconds>);
 static_assert(
   !std::convertible_to<sys_seconds, quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::steady_clock>>>);
 #endif
@@ -832,9 +842,11 @@ static_assert(quantity_point<(isq::height[m]), mean_sea_level>(tower_peak + 42 *
 
 static_assert(quantity_point<(isq::height[m]), ground_level>(mean_sea_level + 84 * m).quantity_from(ground_level) ==
               42 * m);
-static_assert(quantity_point<(isq::height[m]), ground_level>(tower_peak + 42 * m).quantity_from(ground_level) == 84 * m);
+static_assert(quantity_point<(isq::height[m]), ground_level>(tower_peak + 42 * m).quantity_from(ground_level) ==
+              84 * m);
 
-static_assert(quantity_point<(isq::height[m]), tower_peak>(mean_sea_level + 42 * m).quantity_from(tower_peak) == -42 * m);
+static_assert(quantity_point<(isq::height[m]), tower_peak>(mean_sea_level + 42 * m).quantity_from(tower_peak) ==
+              -42 * m);
 static_assert(quantity_point<(isq::height[m]), tower_peak>(ground_level + 84 * m).quantity_from(tower_peak) == 42 * m);
 
 static_assert((mean_sea_level + 42 * m).point_for(mean_sea_level).quantity_from(mean_sea_level) == 42 * m);
@@ -1642,8 +1654,8 @@ static_assert(is_of_type<(zero_Hz + 5 * isq::frequency[Hz]) - (zero_Hz + 10 / (2
 
 static_assert((quantity_point{10 / (2 * isq::period_duration[s])} + 5 * isq::frequency[Hz]).quantity_from_zero() ==
               10 * isq::frequency[Hz]);
-static_assert((10 / (2 * isq::period_duration[s]) + (zero_Hz + 5 * isq::frequency[Hz]))
-                .quantity_from_zero() == 10 * isq::frequency[Hz]);
+static_assert((10 / (2 * isq::period_duration[s]) + (zero_Hz + 5 * isq::frequency[Hz])).quantity_from_zero() ==
+              10 * isq::frequency[Hz]);
 static_assert((quantity_point{5 * isq::frequency[Hz]} + 10 / (2 * isq::period_duration[s])).quantity_from_zero() ==
               10 * isq::frequency[Hz]);
 static_assert((5 * isq::frequency[Hz] + quantity_point{10 / (2 * isq::period_duration[s])}).quantity_from_zero() ==

test/static/quantity_test.cpp

@@ -173,8 +173,9 @@ static_assert(!std::constructible_from<quantity<(isq::length[m])>, quantity<(isq
 static_assert(!std::convertible_to<quantity<(isq::speed[m / s])>, quantity<(isq::length[m])>>);
 
 // implicit conversion from another quantity only if non-truncating
-static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m]), int>>);  // int -> double OK
-static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[m])>>);      // int -> double OK
+static_assert(
+  std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m]), int>>);          // int -> double OK
+static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[m])>>);  // int -> double OK
 
 static_assert(!std::constructible_from<quantity<(isq::length[m]), int>,
                                        quantity<(isq::length[m])>>);  // truncating double -> int not allowed
@@ -188,7 +189,7 @@ static_assert(std::convertible_to<quantity<(isq::length[km]), int>,
 
 static_assert(!std::constructible_from<quantity<(isq::length[km]), int>,
                                        quantity<(isq::length[m]), int>>);  // truncating metre<int> ->
-                                                                         // kilometre<int> not allowed
+                                                                           // kilometre<int> not allowed
 static_assert(
   !std::convertible_to<quantity<(isq::length[m]), int>,
                        quantity<(isq::length[km]), int>>);  // truncating metre<int> -> kilometre<int> not allowed
@@ -355,8 +356,8 @@ static_assert(quantity{123}.quantity_spec == kind_of<dimensionless>);
 #if MP_UNITS_HOSTED
 using namespace std::chrono_literals;
 static_assert(std::is_same_v<decltype(quantity{123s})::rep, std::chrono::seconds::rep>);
-//return type for "s" is not specified. is double for msvc
-//static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
+// return type for "s" is not specified. is double for msvc
+// static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
 static_assert(quantity{24h}.unit == si::hour);
 static_assert(quantity{24h}.quantity_spec == kind_of<isq::time>);
 #endif
@@ -455,7 +456,7 @@ static_assert((std::uint8_t{255}* m %= 257 * m).numerical_value_in(m) != [] {
 #if !(defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 18 && defined MP_UNITS_MODULES)
 // next two lines trigger conversions warnings
 // (warning disabled in CMake for this file)
-static_assert(((22 * m) *= 33.33).numerical_value_in(m) ==733);
+static_assert(((22 * m) *= 33.33).numerical_value_in(m) == 733);
 static_assert(((22 * m) /= 3.33).numerical_value_in(m) == 6);
 static_assert(((22 * m) *= 33.33 * one).numerical_value_in(m) == 733);
 static_assert(((22 * m) /= 3.33 * one).numerical_value_in(m) == 6);
@@ -850,14 +851,17 @@ static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<si::
 static_assert(std::equality_comparable_with<quantity<(si::metre), int>, quantity<si::kilo<(si::metre)>, int>>);
 static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre)>>);
 static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre), int>>);
-static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<si::kilo<(si::metre)>, int>>);
+static_assert(
+  std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<si::kilo<(si::metre)>, int>>);
 static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre)>>);
 static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre), int>>);
-static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::kilo<(si::metre)>), int>>);
-static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)])>>);
-static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)]), int>>);
 static_assert(
-  std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::kilo<(si::metre)>)]), int>>);
+  std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::kilo<(si::metre)>), int>>);
+static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)])>>);
+static_assert(
+  std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)]), int>>);
+static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>,
+                                            quantity<(isq::height[(si::kilo<(si::metre)>)]), int>>);
 
 template<auto M>
 concept no_crossdimensional_equality = requires {
@@ -1054,11 +1058,12 @@ static_assert(QuantityOf<quantity<m / s>, isq::position_vector / isq::duration>)
 static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, isq::position_vector / isq::duration>);
 static_assert(QuantityOf<quantity<(isq::velocity)[m / s], int>, isq::position_vector / isq::duration>);
 
-static_assert(QuantityOf<decltype(10 * m), (isq::height)>);                        // kind of
+static_assert(QuantityOf<decltype(10 * m), (isq::height)>);                          // kind of
 static_assert(QuantityOf<decltype(10 * kind_of<(isq::length)>[m]), (isq::height)>);  // kind of
 static_assert(!QuantityOf<decltype(10 * (isq::length[m])), (isq::height)>);          // different kinds
 static_assert(!QuantityOf<decltype(10 * (isq::width[m])), (isq::height)>);           // different kinds
 static_assert(QuantityOf<decltype(10 * (isq::speed[m / s])), (isq::speed)>);
-static_assert(QuantityOf<decltype(20 * (isq::length[m]) / (2 * isq::time[s])), (isq::speed)>);  // derived unnamed quantity
+static_assert(
+  QuantityOf<decltype(20 * (isq::length[m]) / (2 * isq::time[s])), (isq::speed)>);  // derived unnamed quantity
 
 }  // namespace