diff --git a/test/metabench/make_dimension/dimension_concepts_all.h b/test/metabench/make_dimension/dimension_concepts_all.h
index 0207f274..2833a82c 100644
--- a/test/metabench/make_dimension/dimension_concepts_all.h
+++ b/test/metabench/make_dimension/dimension_concepts_all.h
@@ -157,7 +157,7 @@ namespace units {
     template<Exponent E1, Exponent... ERest>
     struct dim_consolidate<dimension<E1, ERest...>> {
       using rest = dim_consolidate_t<dimension<ERest...>>;
-      using type = conditional<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
+      using type = conditional<is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
     };
 
     template<const base_dimension& D, std::intmax_t Num1, std::intmax_t Den1, std::intmax_t Num2, std::intmax_t Den2, Exponent... ERest>
diff --git a/test/metabench/make_dimension/dimension_concepts_iface.h b/test/metabench/make_dimension/dimension_concepts_iface.h
index a1acbf82..3142bd2a 100644
--- a/test/metabench/make_dimension/dimension_concepts_iface.h
+++ b/test/metabench/make_dimension/dimension_concepts_iface.h
@@ -157,7 +157,7 @@ namespace units {
     template<typename E1, typename... ERest>
     struct dim_consolidate<dimension<E1, ERest...>> {
       using rest = dim_consolidate_t<dimension<ERest...>>;
-      using type = conditional<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
+      using type = conditional<is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
     };
 
     template<const base_dimension& D, std::intmax_t Num1, std::intmax_t Den1, std::intmax_t Num2, std::intmax_t Den2, typename... ERest>
diff --git a/test/metabench/make_dimension/dimension_no_concepts.h b/test/metabench/make_dimension/dimension_no_concepts.h
index dfbf90c2..f8b0de38 100644
--- a/test/metabench/make_dimension/dimension_no_concepts.h
+++ b/test/metabench/make_dimension/dimension_no_concepts.h
@@ -128,7 +128,7 @@ namespace units {
     template<typename E1, typename... ERest>
     struct dim_consolidate<dimension<E1, ERest...>> {
       using rest = dim_consolidate_t<dimension<ERest...>>;
-      using type = conditional<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
+      using type = conditional<is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
     };
 
     template<const base_dimension& D, std::intmax_t Num1, std::intmax_t Den1, std::intmax_t Num2, std::intmax_t Den2, typename... ERest>
diff --git a/test/unit_test/static/chrono_test.cpp b/test/unit_test/static/chrono_test.cpp
index 39d4da58..7186300b 100644
--- a/test/unit_test/static/chrono_test.cpp
+++ b/test/unit_test/static/chrono_test.cpp
@@ -43,8 +43,8 @@ static_assert(!std::constructible_from<si::time<si::hour, std::chrono::seconds::
 static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour, std::chrono::seconds::rep>>);
 
 // CTAD
-static_assert(std::is_same_v<decltype(quantity{1s}), si::time<si::second, std::chrono::seconds::rep>>);
-static_assert(std::is_same_v<decltype(quantity{1h}), si::time<si::hour, std::chrono::hours::rep>>);
+static_assert(is_same_v<decltype(quantity{1s}), si::time<si::second, std::chrono::seconds::rep>>);
+static_assert(is_same_v<decltype(quantity{1h}), si::time<si::hour, std::chrono::hours::rep>>);
 
 // operators
 static_assert(quantity{1s} + 1_q_s == 2_q_s);
diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp
index db3d938c..49783aa0 100644
--- a/test/unit_test/static/quantity_test.cpp
+++ b/test/unit_test/static/quantity_test.cpp
@@ -231,12 +231,12 @@ static_assert(length<kilometre>(1500_q_m).count() == 1.5);
 // CTAD
 /////////
 
-static_assert(std::is_same_v<decltype(quantity{length<metre, int>(123)}), length<metre, int>>);
-static_assert(std::is_same_v<decltype(quantity{speed<metre_per_second>(123)}), speed<metre_per_second>>);
-// static_assert(std::is_same_v<decltype(length{length<metre, int>(123)}), length<metre, int>>);   // TODO gcc ICE
-static_assert(std::is_same_v<decltype(quantity{123_q_m}), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(quantity{1}), dimensionless<one, int>>);
-static_assert(std::is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
+static_assert(is_same_v<decltype(quantity{length<metre, int>(123)}), length<metre, int>>);
+static_assert(is_same_v<decltype(quantity{speed<metre_per_second>(123)}), speed<metre_per_second>>);
+// static_assert(is_same_v<decltype(length{length<metre, int>(123)}), length<metre, int>>);   // TODO gcc ICE
+static_assert(is_same_v<decltype(quantity{123_q_m}), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(quantity{1}), dimensionless<one, int>>);
+static_assert(is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
 
 
 ////////////////////////
@@ -331,17 +331,17 @@ concept invalid_binary_operations = requires {
 static_assert(invalid_binary_operations<metre>);
 
 // same representation type
-static_assert(std::is_same_v<decltype(1_q_m + 1_q_m), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m - 1_q_m), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m * 1), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m * quantity{1}), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1 * 1_q_m), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(quantity{1} * 1_q_m), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m / 1), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m / quantity{1}), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m % 1), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m % quantity{1}), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_m % 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m + 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m - 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m * 1), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m * quantity{1}), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1 * 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(quantity{1} * 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m / 1), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m / quantity{1}), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m % 1), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m % quantity{1}), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m % 1_q_m), length<metre, std::int64_t>>);
 static_assert(compare<decltype(1_q_m * dimensionless<percent, std::int64_t>(1)), length<centimetre, std::int64_t>>);
 static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) * 1_q_m), length<centimetre, std::int64_t>>);
 static_assert(compare<decltype(1_q_m / dimensionless<percent, std::int64_t>(1)), length<hectometre, std::int64_t>>);
@@ -353,14 +353,14 @@ static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64
 static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s), frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>);
 
 // different representation types
-static_assert(std::is_same_v<decltype(1_q_m + 1._q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_m - 1._q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_m * 1.L), length<metre, long double>>);  // TODO should we address fundamental types implicit truncating conversions with concepts?
-static_assert(std::is_same_v<decltype(1 * 1._q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_m * quantity{1.L}), length<metre, long double>>);  // TODO should we address fundamental types implicit truncating conversions with concepts?
-static_assert(std::is_same_v<decltype(quantity{1} * 1._q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_m / 1.L), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_m / quantity{1.L}), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m + 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m - 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m * 1.L), length<metre, long double>>);  // TODO should we address fundamental types implicit truncating conversions with concepts?
+static_assert(is_same_v<decltype(1 * 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m * quantity{1.L}), length<metre, long double>>);  // TODO should we address fundamental types implicit truncating conversions with concepts?
+static_assert(is_same_v<decltype(quantity{1} * 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m / 1.L), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m / quantity{1.L}), length<metre, long double>>);
 static_assert(compare<decltype(1_q_m * dimensionless<percent, long double>(1)), length<centimetre, long double>>);
 static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) * 1._q_m), length<centimetre, long double>>);
 static_assert(compare<decltype(1_q_m * 1._q_m), area<square_metre, long double>>);
@@ -374,14 +374,14 @@ static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::i
 static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<centimetre, std::int64_t>>);
 static_assert(compare<decltype(1_q_m % length<metre, short>(1)), length<metre, std::int64_t>>);
 
-static_assert(std::is_same_v<decltype(1._q_m + 1_q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_m - 1_q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_m * 1), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1.L * 1_q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_m * quantity{1}), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(quantity{1.L} * 1_q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_m / 1), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_m / quantity{1}), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m + 1_q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m - 1_q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m * 1), length<metre, long double>>);
+static_assert(is_same_v<decltype(1.L * 1_q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m * quantity{1}), length<metre, long double>>);
+static_assert(is_same_v<decltype(quantity{1.L} * 1_q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m / 1), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m / quantity{1}), length<metre, long double>>);
 static_assert(compare<decltype(1._q_m * dimensionless<percent, std::int64_t>(1)), length<centimetre, long double>>);
 static_assert(compare<decltype(dimensionless<percent, long double>(1) * 1_q_m), length<centimetre, long double>>);
 static_assert(compare<decltype(1._q_m / dimensionless<percent, std::int64_t>(1)), length<hectometre, long double>>);
@@ -392,28 +392,28 @@ static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long dou
 static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s), frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
 
 // different units
-static_assert(std::is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1._q_m + 1_q_km), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_m + 1._q_km), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_m + 1._q_km), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1._q_m + 1_q_km), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m + 1._q_km), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m + 1._q_km), length<metre, long double>>);
 
-static_assert(std::is_same_v<decltype(1_q_km + 1_q_m), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1._q_km + 1_q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_km + 1._q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_km + 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_km + 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1._q_km + 1_q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_km + 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_km + 1._q_m), length<metre, long double>>);
 
-static_assert(std::is_same_v<decltype(1_q_m - 1_q_km), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1._q_m - 1_q_km), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_m - 1._q_km), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_m - 1._q_km), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m - 1_q_km), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1._q_m - 1_q_km), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_m - 1._q_km), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_m - 1._q_km), length<metre, long double>>);
 
-static_assert(std::is_same_v<decltype(1_q_km - 1_q_m), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1._q_km - 1_q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1_q_km - 1._q_m), length<metre, long double>>);
-static_assert(std::is_same_v<decltype(1._q_km - 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_km - 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1._q_km - 1_q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1_q_km - 1._q_m), length<metre, long double>>);
+static_assert(is_same_v<decltype(1._q_km - 1._q_m), length<metre, long double>>);
 
-static_assert(std::is_same_v<decltype(1_q_m % 1_q_km), length<metre, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_km % 1_q_m), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_m % 1_q_km), length<metre, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_km % 1_q_m), length<metre, std::int64_t>>);
 
 // different dimensions
 static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>);
@@ -687,13 +687,13 @@ static_assert(quantity_cast<dim_speed, kilometre_per_hour>(2000.0_q_m / 3600.0_q
 
 #if UNITS_DOWNCAST_MODE == 0
 
-static_assert(std::is_same_v<decltype(10_q_m / 5_q_s), quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>, scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<ratio(1, 1, -3), metre>, std::int64_t>>);
+static_assert(is_same_v<decltype(10_q_m / 5_q_s), quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>, scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<ratio(1, 1, -3), metre>, std::int64_t>>);
 
 #else
 
-static_assert(std::is_same_v<decltype(10_q_m / 5_q_s), speed<metre_per_second, std::int64_t>>);
-static_assert(std::is_same_v<decltype(1_q_mm + 1_q_km), length<millimetre, std::int64_t>>);
+static_assert(is_same_v<decltype(10_q_m / 5_q_s), speed<metre_per_second, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<millimetre, std::int64_t>>);
 
 #endif
 
diff --git a/test/unit_test/static/unit_constants.cpp b/test/unit_test/static/unit_constants.cpp
index 876b0cd1..84e9dfbd 100644
--- a/test/unit_test/static/unit_constants.cpp
+++ b/test/unit_test/static/unit_constants.cpp
@@ -59,7 +59,7 @@ static_assert(2 * m / s == 2_q_m_per_s);
 static_assert(2 / s * m == 2_q_m_per_s);
 static_assert(2 * (m / s) == 2_q_m_per_s);
 static_assert(2 * ::m_per_s == 2_q_m_per_s);
-static_assert(std::is_same_v<decltype(::m_per_s)::rep, decltype(m)::rep>);
+static_assert(is_same_v<decltype(::m_per_s)::rep, decltype(m)::rep>);
 
 static_assert(120 * km / (2 * h) == 60_q_km_per_h);
 static_assert(120 * km / 2 / h == 60_q_km_per_h);
@@ -68,9 +68,9 @@ static_assert([] {
   const auto duration{2};
   return length * km / (duration * h);
 }() == 60_q_km_per_h);
-static_assert(std::is_same_v<decltype(std::int64_t{120} * km / (2 * h)), decltype(60_q_km_per_h)>);
-static_assert(std::is_same_v<decltype(std::int64_t{120} * km / 2 / h), decltype(60_q_km_per_h)>);
-static_assert(std::is_same_v<decltype(120.L * km / 2 / h), decltype(60._q_km_per_h)>);
+static_assert(is_same_v<decltype(std::int64_t{120} * km / (2 * h)), decltype(60_q_km_per_h)>);
+static_assert(is_same_v<decltype(std::int64_t{120} * km / 2 / h), decltype(60_q_km_per_h)>);
+static_assert(is_same_v<decltype(120.L * km / 2 / h), decltype(60._q_km_per_h)>);
 
 static_assert(1. / 4 * m2 == 1._q_m2 / 4);
 
@@ -79,7 +79,7 @@ static_assert([] {
   signed s = 2;  // hides  ^
   Length auto v = 20 * m / s;
   /*      */ v0 = 10 * m / ::s;
-  return !std::is_same_v<decltype(v0), decltype(v)>;
+  return !is_same_v<decltype(v0), decltype(v)>;
 }());
 
 int main() {}