diff --git a/test/static/unit_test.cpp b/test/static/unit_test.cpp
index 3a24086f..82022380 100644
--- a/test/static/unit_test.cpp
+++ b/test/static/unit_test.cpp
@@ -121,15 +121,12 @@ static_assert(!PrefixableUnit<MP_UNITS_NONCONST_TYPE(kilometre)>);
 static_assert(is_of_type<metre, metre_>);
 static_assert(is_of_type<get_canonical_unit(metre).reference_unit, metre_>);
 static_assert(get_canonical_unit(metre).mag == mag<1>);
-static_assert(interconvertible(metre, metre));
-static_assert(!interconvertible(metre, second));
 static_assert(metre == metre);
 static_assert(metre != second);
 
 static_assert(is_of_type<degree_Celsius, degree_Celsius_>);
 static_assert(is_of_type<get_canonical_unit(degree_Celsius).reference_unit, kelvin_>);
 static_assert(get_canonical_unit(degree_Celsius).mag == mag<1>);
-static_assert(interconvertible(degree_Celsius, kelvin));
 static_assert(degree_Celsius != kelvin);
 static_assert(equivalent(degree_Celsius, kelvin));
 
@@ -140,31 +137,23 @@ static_assert(get_canonical_unit(radian).mag == mag<1>);
 static_assert(is_of_type<degree, degree_>);
 static_assert(is_of_type<get_canonical_unit(degree).reference_unit, one_>);
 static_assert(get_canonical_unit(degree).mag == mag<π> / mag<180>);
-static_assert(interconvertible(radian, degree));
 static_assert(radian != degree);
-static_assert(interconvertible(one, radian));
-static_assert(interconvertible(radian, one));
 static_assert(radian != one);
 
 static_assert(is_of_type<steradian, steradian_>);
 static_assert(is_of_type<get_canonical_unit(steradian).reference_unit, one_>);
 static_assert(get_canonical_unit(steradian).mag == mag<1>);
-static_assert(!interconvertible(radian, steradian));
 static_assert(radian != steradian);
 
 static_assert(is_of_type<minute, minute_>);
 static_assert(is_of_type<get_canonical_unit(minute).reference_unit, second_>);
 static_assert(get_canonical_unit(minute).mag == mag<60>);
-static_assert(interconvertible(minute, second));
 static_assert(minute != second);
 
 static_assert(is_of_type<hour, hour_>);
 static_assert(is_of_type<get_canonical_unit(hour).reference_unit, second_>);
 static_assert(get_canonical_unit(hour).mag == mag<3600>);
-static_assert(interconvertible(hour, second));
 
-static_assert(interconvertible(hour, minute));
-static_assert(interconvertible(hour, hour));
 static_assert(hour != second);
 static_assert(hour != minute);
 static_assert(hour == hour);
@@ -173,14 +162,12 @@ static_assert(is_of_type<newton, newton_>);
 static_assert(
   is_of_type<get_canonical_unit(newton).reference_unit, derived_unit<gram_, metre_, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(newton).mag == mag<1000>);  // !!! (because of kilogram)
-static_assert(interconvertible(newton, newton));
 static_assert(newton == newton);
 
 static_assert(is_of_type<joule, joule_>);
 static_assert(
   is_of_type<get_canonical_unit(joule).reference_unit, derived_unit<gram_, power<metre_, 2>, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(joule).mag == mag<1000>);  // !!! (because of kilogram)
-static_assert(interconvertible(joule, joule));
 static_assert(joule == joule);
 static_assert(joule != newton);
 
@@ -191,8 +178,6 @@ static_assert(is_of_type<standard_gravity, standard_gravity_>);
 static_assert(
   is_of_type<get_canonical_unit(standard_gravity).reference_unit, derived_unit<metre_, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(standard_gravity).mag == mag_ratio<980'665, 100'000>);
-static_assert(interconvertible(standard_gravity, standard_gravity));
-static_assert(interconvertible(standard_gravity, metre / square(second)));
 static_assert(standard_gravity == standard_gravity);
 static_assert(standard_gravity != metre / square(second));  // magnitude is different
 static_assert(standard_gravity._symbol_ == symbol_text{u8"g₀", "g_0"});
@@ -201,7 +186,6 @@ static_assert(standard_gravity._symbol_ == symbol_text{u8"g₀", "g_0"});
 static_assert(is_of_type<kilometre, MP_UNITS_NONCONST_TYPE(kilo<metre>)>);
 static_assert(is_of_type<get_canonical_unit(kilometre).reference_unit, metre_>);
 static_assert(get_canonical_unit(kilometre).mag == mag<1000>);
-static_assert(interconvertible(kilometre, metre));
 static_assert(kilometre != metre);
 static_assert(kilometre._symbol_ == "km");
 
@@ -209,7 +193,6 @@ static_assert(is_of_type<kilojoule, MP_UNITS_NONCONST_TYPE(kilo<joule>)>);
 static_assert(is_of_type<get_canonical_unit(kilojoule).reference_unit,
                          derived_unit<gram_, power<metre_, 2>, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(kilojoule).mag == mag<1'000'000>);
-static_assert(interconvertible(kilojoule, joule));
 static_assert(kilojoule != joule);
 static_assert(kilojoule._symbol_ == "kJ");
 
@@ -452,11 +435,9 @@ static_assert(equivalent(kilo<metre> * milli<metre>, si::deca<metre>* si::deci<m
 // comparisons of equivalent units (named vs unnamed/derived)
 static_assert(one / second != hertz);
 static_assert(equivalent(one / second, hertz));
-static_assert(interconvertible(one / second, hertz));
 
 // comparisons of equivalent units of different quantities
 static_assert(hertz != becquerel);
-static_assert(!interconvertible(hertz, becquerel));
 
 // comparisons of scaled units
 static_assert(kilo<metre> == kilometre);
@@ -464,23 +445,16 @@ static_assert(mag<1000> * metre != kilo<metre>);
 static_assert(equivalent(mag<1000> * metre, kilo<metre>));
 static_assert(mag<1000> * metre != kilometre);
 static_assert(equivalent(mag<1000> * metre, kilometre));
-static_assert(interconvertible(kilo<metre>, kilometre));
-static_assert(interconvertible(mag<1000> * metre, kilo<metre>));
-static_assert(interconvertible(mag<1000> * metre, kilometre));
 
 static_assert(mag<60> * metre / second != metre / (mag_ratio<1, 60> * second));
 static_assert(equivalent(mag<60> * metre / second, metre / (mag_ratio<1, 60> * second)));
 
 static_assert(metre != kilometre);
-static_assert(interconvertible(metre, kilometre));
 static_assert(mag<100> * metre != kilometre);
-static_assert(interconvertible(mag<100> * metre, kilometre));
 static_assert(milli<metre> != kilometre);
-static_assert(interconvertible(milli<metre>, kilometre));
 
-// comparisons of non-interconvertible units
+// comparisons of non-compatible units
 static_assert(metre != metre * metre);
-static_assert(!interconvertible(metre, metre* metre));
 
 // one
 static_assert(is_of_type<metre / metre, one_>);