Index: uspace/lib/cpp/include/__bits/test/test.hpp
===================================================================
--- uspace/lib/cpp/include/__bits/test/test.hpp	(revision 496025422a5094d2ef79f0488ae2caf8015aaf02)
+++ uspace/lib/cpp/include/__bits/test/test.hpp	(revision d504700202ed70c0ffbf69eb0f4a6fb1546b8866)
@@ -57,4 +57,9 @@
             bool ok_{true};
             bool report_{true};
+
+            void test(const char* tname, bool expr)
+            {
+                test_eq(tname, expr, true);
+            }
 
             template<class... Args>
Index: uspace/lib/cpp/src/__bits/test/memory.cpp
===================================================================
--- uspace/lib/cpp/src/__bits/test/memory.cpp	(revision 496025422a5094d2ef79f0488ae2caf8015aaf02)
+++ uspace/lib/cpp/src/__bits/test/memory.cpp	(revision d504700202ed70c0ffbf69eb0f4a6fb1546b8866)
@@ -212,14 +212,44 @@
          * so we get all the defaults here.
          */
-        static_assert(std::is_same_v<typename dummy_traits1::pointer, int*>);
-        static_assert(std::is_same_v<typename dummy_traits1::const_pointer, const int*>);
-        static_assert(std::is_same_v<typename dummy_traits1::void_pointer, void*>);
-        static_assert(std::is_same_v<typename dummy_traits1::const_void_pointer, const void*>);
-        static_assert(std::is_same_v<typename dummy_traits1::difference_type, ptrdiff_t>);
-        static_assert(std::is_same_v<typename dummy_traits1::size_type, std::make_unsigned_t<ptrdiff_t>>);
-        static_assert(std::is_same_v<typename dummy_traits1::propagate_on_container_copy_assignment, std::false_type>);
-        static_assert(std::is_same_v<typename dummy_traits1::propagate_on_container_move_assignment, std::false_type>);
-        static_assert(std::is_same_v<typename dummy_traits1::propagate_on_container_swap, std::false_type>);
-        static_assert(std::is_same_v<typename dummy_traits1::is_always_equal, typename std::is_empty<aux::dummy_allocator1>::type>);
+        test(
+            "allocator traits default for pointer",
+            std::is_same_v<typename dummy_traits1::pointer, int*>
+        );
+        test(
+            "allocator traits default for const_pointer",
+            std::is_same_v<typename dummy_traits1::const_pointer, const int*>
+        );
+        test(
+            "allocator traits default for void_pointer",
+            std::is_same_v<typename dummy_traits1::void_pointer, void*>
+        );
+        test(
+            "allocator traits default for const_void_pointer",
+            std::is_same_v<typename dummy_traits1::const_void_pointer, const void*>
+        );
+        test(
+            "allocator traits default for difference_type",
+            std::is_same_v<typename dummy_traits1::difference_type, ptrdiff_t>
+        );
+        test(
+            "allocator traits default for size_type",
+            std::is_same_v<typename dummy_traits1::size_type, std::make_unsigned_t<ptrdiff_t>>
+        );
+        test(
+            "allocator traits default for copy propagate",
+            std::is_same_v<typename dummy_traits1::propagate_on_container_copy_assignment, std::false_type>
+        );
+        test(
+            "allocator traits default for move propagate",
+            std::is_same_v<typename dummy_traits1::propagate_on_container_move_assignment, std::false_type>
+        );
+        test(
+            "allocator traits default for swap propagate",
+            std::is_same_v<typename dummy_traits1::propagate_on_container_swap, std::false_type>
+        );
+        test(
+            "allocator traits default for is_always_equal",
+            std::is_same_v<typename dummy_traits1::is_always_equal, typename std::is_empty<aux::dummy_allocator1>::type>
+        );
 
         /**
@@ -227,14 +257,44 @@
          * the the traits just use identity.
          */
-        static_assert(std::is_same_v<typename dummy_traits2::pointer, char*>);
-        static_assert(std::is_same_v<typename dummy_traits2::const_pointer, const void*>);
-        static_assert(std::is_same_v<typename dummy_traits2::void_pointer, bool*>);
-        static_assert(std::is_same_v<typename dummy_traits2::const_void_pointer, volatile bool*>);
-        static_assert(std::is_same_v<typename dummy_traits2::difference_type, short>);
-        static_assert(std::is_same_v<typename dummy_traits2::size_type, long>);
-        static_assert(std::is_same_v<typename dummy_traits2::propagate_on_container_copy_assignment, std::true_type>);
-        static_assert(std::is_same_v<typename dummy_traits2::propagate_on_container_move_assignment, std::true_type>);
-        static_assert(std::is_same_v<typename dummy_traits2::propagate_on_container_swap, std::true_type>);
-        static_assert(std::is_same_v<typename dummy_traits2::is_always_equal, std::true_type>);
+        test(
+            "allocator traits given pointer",
+            std::is_same_v<typename dummy_traits2::pointer, char*>
+        );
+        test(
+            "allocator traits given const_pointer",
+            std::is_same_v<typename dummy_traits2::const_pointer, const void*>
+        );
+        test(
+            "allocator traits given void_pointer",
+            std::is_same_v<typename dummy_traits2::void_pointer, bool*>
+        );
+        test(
+            "allocator traits given const_void_pointer",
+            std::is_same_v<typename dummy_traits2::const_void_pointer, volatile bool*>
+        );
+        test(
+            "allocator traits given difference_type",
+            std::is_same_v<typename dummy_traits2::difference_type, short>
+        );
+        test(
+            "allocator traits given size_type",
+            std::is_same_v<typename dummy_traits2::size_type, long>
+        );
+        test(
+            "allocator traits given copy propagate",
+            std::is_same_v<typename dummy_traits2::propagate_on_container_copy_assignment, std::true_type>
+        );
+        test(
+            "allocator traits given move propagate",
+            std::is_same_v<typename dummy_traits2::propagate_on_container_move_assignment, std::true_type>
+        );
+        test(
+            "allocator traits given swap propagate",
+            std::is_same_v<typename dummy_traits2::propagate_on_container_swap, std::true_type>
+        );
+        test(
+            "allocator traits given is_always_equal",
+            std::is_same_v<typename dummy_traits2::is_always_equal, std::true_type>
+        );
     }
 
@@ -245,21 +305,58 @@
         using int_traits    = std::pointer_traits<int*>;
 
-        static_assert(std::is_same_v<typename dummy_traits1::pointer, aux::dummy_pointer1>);
-        static_assert(std::is_same_v<typename dummy_traits1::element_type, int>);
-        static_assert(std::is_same_v<typename dummy_traits1::difference_type, bool>);
-        static_assert(std::is_same_v<typename dummy_traits1::template rebind<long>, unsigned>);
+        test(
+            "pointer traits pointer pt1",
+            std::is_same_v<typename dummy_traits1::pointer, aux::dummy_pointer1>
+        );
+        test(
+            "pointer traits element_type pt1",
+            std::is_same_v<typename dummy_traits1::element_type, int>
+        );
+        test(
+            "pointer traits difference_type pt1",
+            std::is_same_v<typename dummy_traits1::difference_type, bool>
+        );
+        test(
+            "pointer traits rebind pt1",
+            std::is_same_v<typename dummy_traits1::template rebind<long>, unsigned>
+        );
+
+        test(
+            "pointer traits pointer pt2",
+            std::is_same_v<typename dummy_traits2::pointer, aux::dummy_pointer2<int, char>>
+        );
+        test(
+            "pointer traits element_type pt2",
+            std::is_same_v<typename dummy_traits2::element_type, signed char>
+        );
+        test(
+            "pointer traits difference_type pt2",
+            std::is_same_v<typename dummy_traits2::difference_type, unsigned char>
+        );
+        test(
+            "pointer traits rebind pt2",
+            std::is_same_v<typename dummy_traits2::template rebind<long>, aux::dummy_pointer2<long, char>>
+        );
+
+        test(
+            "pointer traits pointer pt3",
+            std::is_same_v<typename int_traits::pointer, int*>
+        );
+        test(
+            "pointer traits element_type pt3",
+            std::is_same_v<typename int_traits::element_type, int>
+        );
+        test(
+            "pointer traits difference_type pt3",
+            std::is_same_v<typename int_traits::difference_type, ptrdiff_t>
+        );
+        test(
+            "pointer traits rebind pt3",
+            std::is_same_v<typename int_traits::rebind<char>, char*>
+        );
 
         int x{10};
         test_eq("pointer_traits<Ptr>::pointer_to", dummy_traits1::pointer_to(x).tag, 10);
         test_eq("pointer_traits<T*>::pointer_to", int_traits::pointer_to(x), &x);
-
-        static_assert(std::is_same_v<typename dummy_traits2::pointer, aux::dummy_pointer2<int, char>>);
-        static_assert(std::is_same_v<typename dummy_traits2::element_type, signed char>);
-        static_assert(std::is_same_v<typename dummy_traits2::difference_type, unsigned char>);
-
-        static_assert(std::is_same_v<typename int_traits::pointer, int*>);
-        static_assert(std::is_same_v<typename int_traits::element_type, int>);
-        static_assert(std::is_same_v<typename int_traits::difference_type, ptrdiff_t>);
-        static_assert(std::is_same_v<typename int_traits::rebind<char>, char*>);
     }
 }