From 7a580d0a72e54b8ffe5c257323029afdbc7fab9b Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 22 Jun 2016 01:10:14 +0000
Subject: [PATCH] Don't use C++17 terse static assert. Patch from
 STL@microsoft.com

llvm-svn: 273353
---
 .../func.invoke/invoke.pass.cpp               |  10 +-
 .../func.not_fn/not_fn.pass.cpp               |  58 +++++-----
 .../meta/meta.rel/is_callable.pass.cpp        | 102 +++++++++---------
 .../meta.rel/is_nothrow_callable.pass.cpp     |  40 +++----
 .../is_nothrow_swappable.pass.cpp             |   6 +-
 .../is_nothrow_swappable_with.pass.cpp        |  10 +-
 .../meta.unary.prop/is_swappable.pass.cpp     |   4 +-
 .../is_swappable_with.pass.cpp                |  10 +-
 8 files changed, 120 insertions(+), 120 deletions(-)

diff --git a/libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp b/libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
index 89867a566e07..d1ae6b7809ce 100644
--- a/libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
@@ -327,17 +327,17 @@ void noexcept_test() {
     {
         NoThrowCallable obj; ((void)obj); // suppress unused warning
         CopyThrows arg; ((void)arg); // suppress unused warning
-        static_assert(noexcept(std::invoke(obj)));
-        static_assert(!noexcept(std::invoke(obj, arg)));
-        static_assert(noexcept(std::invoke(obj, std::move(arg))));
+        static_assert(noexcept(std::invoke(obj)), "");
+        static_assert(!noexcept(std::invoke(obj, arg)), "");
+        static_assert(noexcept(std::invoke(obj, std::move(arg))), "");
     }
     {
         ThrowsCallable obj; ((void)obj); // suppress unused warning
-        static_assert(!noexcept(std::invoke(obj)));
+        static_assert(!noexcept(std::invoke(obj)), "");
     }
     {
         MemberObj obj{42}; ((void)obj); // suppress unused warning.
-        static_assert(noexcept(std::invoke(&MemberObj::x, obj)));
+        static_assert(noexcept(std::invoke(&MemberObj::x, obj)), "");
     }
 }
 
diff --git a/libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp b/libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
index 42ab466e41ae..948399570944 100644
--- a/libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
@@ -250,10 +250,10 @@ void constructor_tests()
         using T = MoveOnlyCallable<bool>;
         T value(true);
         using RetT = decltype(std::not_fn(std::move(value)));
-        static_assert(std::is_move_constructible<RetT>::value);
-        static_assert(!std::is_copy_constructible<RetT>::value);
-        static_assert(!std::is_move_assignable<RetT>::value);
-        static_assert(!std::is_copy_assignable<RetT>::value);
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(!std::is_copy_constructible<RetT>::value, "");
+        static_assert(!std::is_move_assignable<RetT>::value, "");
+        static_assert(!std::is_copy_assignable<RetT>::value, "");
         auto ret = std::not_fn(std::move(value));
         // test it was moved from
         assert(value.value == false);
@@ -271,10 +271,10 @@ void constructor_tests()
         using T = CopyCallable<bool>;
         T value(false);
         using RetT = decltype(std::not_fn(value));
-        static_assert(std::is_move_constructible<RetT>::value);
-        static_assert(std::is_copy_constructible<RetT>::value);
-        static_assert(!std::is_move_assignable<RetT>::value);
-        static_assert(!std::is_copy_assignable<RetT>::value);
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(std::is_copy_constructible<RetT>::value, "");
+        static_assert(!std::is_move_assignable<RetT>::value, "");
+        static_assert(!std::is_copy_assignable<RetT>::value, "");
         auto ret = std::not_fn(value);
         // test that value is unchanged (copied not moved)
         assert(value.value == false);
@@ -292,10 +292,10 @@ void constructor_tests()
         T value(true);
         T value2(false);
         using RetT = decltype(std::not_fn(value));
-        static_assert(std::is_move_constructible<RetT>::value);
-        static_assert(std::is_copy_constructible<RetT>::value);
-        static_assert(std::is_move_assignable<RetT>::value);
-        static_assert(std::is_copy_assignable<RetT>::value);
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(std::is_copy_constructible<RetT>::value, "");
+        static_assert(std::is_move_assignable<RetT>::value, "");
+        static_assert(std::is_copy_assignable<RetT>::value, "");
         auto ret = std::not_fn(value);
         assert(ret() == false);
         auto ret2 = std::not_fn(value2);
@@ -309,10 +309,10 @@ void constructor_tests()
         T value(true);
         T value2(false);
         using RetT = decltype(std::not_fn(std::move(value)));
-        static_assert(std::is_move_constructible<RetT>::value);
-        static_assert(!std::is_copy_constructible<RetT>::value);
-        static_assert(std::is_move_assignable<RetT>::value);
-        static_assert(!std::is_copy_assignable<RetT>::value);
+        static_assert(std::is_move_constructible<RetT>::value, "");
+        static_assert(!std::is_copy_constructible<RetT>::value, "");
+        static_assert(std::is_move_assignable<RetT>::value, "");
+        static_assert(!std::is_copy_assignable<RetT>::value, "");
         auto ret = std::not_fn(std::move(value));
         assert(ret() == false);
         auto ret2 = std::not_fn(std::move(value2));
@@ -328,21 +328,21 @@ void return_type_tests()
     {
         using T = CopyCallable<bool>;
         auto ret = std::not_fn(T{false});
-        static_assert(is_same<decltype(ret()), bool>::value);
-        static_assert(is_same<decltype(ret("abc")), bool>::value);
+        static_assert(is_same<decltype(ret()), bool>::value, "");
+        static_assert(is_same<decltype(ret("abc")), bool>::value, "");
         assert(ret() == true);
     }
     {
         using T = CopyCallable<ExplicitBool>;
         auto ret = std::not_fn(T{true});
-        static_assert(is_same<decltype(ret()), bool>::value);
-        static_assert(is_same<decltype(ret(std::string("abc"))), bool>::value);
+        static_assert(is_same<decltype(ret()), bool>::value, "");
+        static_assert(is_same<decltype(ret(std::string("abc"))), bool>::value, "");
         assert(ret() == false);
     }
     {
         using T = CopyCallable<EvilBool>;
         auto ret = std::not_fn(T{false});
-        static_assert(is_same<decltype(ret()), EvilBool>::value);
+        static_assert(is_same<decltype(ret()), EvilBool>::value, "");
         EvilBool::bang_called = 0;
         auto value_ret = ret();
         assert(EvilBool::bang_called == 1);
@@ -420,26 +420,26 @@ void throws_in_constructor_test()
 void call_operator_sfinae_test() {
     { // wrong number of arguments
         using T = decltype(std::not_fn(returns_true));
-        static_assert(std::is_callable<T()>::value); // callable only with no args
-        static_assert(!std::is_callable<T(bool)>::value);
+        static_assert(std::is_callable<T()>::value, ""); // callable only with no args
+        static_assert(!std::is_callable<T(bool)>::value, "");
     }
     { // violates const correctness (member function pointer)
         using T = decltype(std::not_fn(&MemFunCallable::return_value_nc));
-        static_assert(std::is_callable<T(MemFunCallable&)>::value);
-        static_assert(!std::is_callable<T(const MemFunCallable&)>::value);
+        static_assert(std::is_callable<T(MemFunCallable&)>::value, "");
+        static_assert(!std::is_callable<T(const MemFunCallable&)>::value, "");
     }
     { // violates const correctness (call object)
         using Obj = CopyCallable<bool>;
         using NCT = decltype(std::not_fn(Obj{true}));
         using CT = const NCT;
-        static_assert(std::is_callable<NCT()>::value);
-        static_assert(!std::is_callable<CT()>::value);
+        static_assert(std::is_callable<NCT()>::value, "");
+        static_assert(!std::is_callable<CT()>::value, "");
     }
     { // returns bad type with no operator!
         auto fn = [](auto x) { return x; };
         using T = decltype(std::not_fn(fn));
-        static_assert(std::is_callable<T(bool)>::value);
-        static_assert(!std::is_callable<T(std::string)>::value);
+        static_assert(std::is_callable<T(bool)>::value, "");
+        static_assert(!std::is_callable<T(std::string)>::value, "");
     }
 }
 
diff --git a/libcxx/test/std/utilities/meta/meta.rel/is_callable.pass.cpp b/libcxx/test/std/utilities/meta/meta.rel/is_callable.pass.cpp
index 328b818aa600..4c85f440b0bf 100644
--- a/libcxx/test/std/utilities/meta/meta.rel/is_callable.pass.cpp
+++ b/libcxx/test/std/utilities/meta/meta.rel/is_callable.pass.cpp
@@ -46,24 +46,24 @@ int main()
         // INVOKE bullet 1, 2 and 3
         {
             // Bullet 1
-            static_assert(std::is_callable<Fn(Tag&, int)>::value);
-            static_assert(std::is_callable<Fn(DerFromTag&, int)>::value);
-            static_assert(std::is_callable<RFn(Tag&&, int)>::value);
-            static_assert(!std::is_callable<RFn(Tag&, int)>::value);
-            static_assert(!std::is_callable<Fn(Tag&)>::value);
-            static_assert(!std::is_callable<Fn(Tag const&, int)>::value);
+            static_assert(std::is_callable<Fn(Tag&, int)>::value, "");
+            static_assert(std::is_callable<Fn(DerFromTag&, int)>::value, "");
+            static_assert(std::is_callable<RFn(Tag&&, int)>::value, "");
+            static_assert(!std::is_callable<RFn(Tag&, int)>::value, "");
+            static_assert(!std::is_callable<Fn(Tag&)>::value, "");
+            static_assert(!std::is_callable<Fn(Tag const&, int)>::value, "");
         }
         {
             // Bullet 2
             using T = std::reference_wrapper<Tag>;
             using DT = std::reference_wrapper<DerFromTag>;
             using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_callable<Fn(T&, int)>::value);
-            static_assert(std::is_callable<Fn(DT&, int)>::value);
-            static_assert(std::is_callable<Fn(const T&, int)>::value);
-            static_assert(std::is_callable<Fn(T&&, int)>::value);
-            static_assert(!std::is_callable<Fn(CT&, int)>::value);
-            static_assert(!std::is_callable<RFn(T, int)>::value);
+            static_assert(std::is_callable<Fn(T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
+            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
+            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
+            static_assert(!std::is_callable<RFn(T, int)>::value, "");
         }
         {
             // Bullet 3
@@ -71,36 +71,36 @@ int main()
             using DT = DerFromTag*;
             using CT = const Tag*;
             using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_callable<Fn(T&, int)>::value);
-            static_assert(std::is_callable<Fn(DT&, int)>::value);
-            static_assert(std::is_callable<Fn(const T&, int)>::value);
-            static_assert(std::is_callable<Fn(T&&, int)>::value);
-            static_assert(std::is_callable<Fn(ST, int)>::value);
-            static_assert(!std::is_callable<Fn(CT&, int)>::value);
-            static_assert(!std::is_callable<RFn(T, int)>::value);
+            static_assert(std::is_callable<Fn(T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
+            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
+            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
+            static_assert(std::is_callable<Fn(ST, int)>::value, "");
+            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
+            static_assert(!std::is_callable<RFn(T, int)>::value, "");
         }
     }
     {
         // Bullets 4, 5 and 6
         using Fn = int (Tag::*);
-        static_assert(!std::is_callable<Fn()>::value);
+        static_assert(!std::is_callable<Fn()>::value, "");
         {
             // Bullet 4
-            static_assert(std::is_callable<Fn(Tag&)>::value);
-            static_assert(std::is_callable<Fn(DerFromTag&)>::value);
-            static_assert(std::is_callable<Fn(Tag&&)>::value);
-            static_assert(std::is_callable<Fn(Tag const&)>::value);
+            static_assert(std::is_callable<Fn(Tag&)>::value, "");
+            static_assert(std::is_callable<Fn(DerFromTag&)>::value, "");
+            static_assert(std::is_callable<Fn(Tag&&)>::value, "");
+            static_assert(std::is_callable<Fn(Tag const&)>::value, "");
         }
         {
             // Bullet 5
             using T = std::reference_wrapper<Tag>;
             using DT = std::reference_wrapper<DerFromTag>;
             using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_callable<Fn(T&)>::value);
-            static_assert(std::is_callable<Fn(DT&)>::value);
-            static_assert(std::is_callable<Fn(const T&)>::value);
-            static_assert(std::is_callable<Fn(T&&)>::value);
-            static_assert(std::is_callable<Fn(CT&)>::value);
+            static_assert(std::is_callable<Fn(T&)>::value, "");
+            static_assert(std::is_callable<Fn(DT&)>::value, "");
+            static_assert(std::is_callable<Fn(const T&)>::value, "");
+            static_assert(std::is_callable<Fn(T&&)>::value, "");
+            static_assert(std::is_callable<Fn(CT&)>::value, "");
         }
         {
             // Bullet 6
@@ -108,12 +108,12 @@ int main()
             using DT = DerFromTag*;
             using CT = const Tag*;
             using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_callable<Fn(T&)>::value);
-            static_assert(std::is_callable<Fn(DT&)>::value);
-            static_assert(std::is_callable<Fn(const T&)>::value);
-            static_assert(std::is_callable<Fn(T&&)>::value);
-            static_assert(std::is_callable<Fn(ST)>::value);
-            static_assert(std::is_callable<Fn(CT&)>::value);
+            static_assert(std::is_callable<Fn(T&)>::value, "");
+            static_assert(std::is_callable<Fn(DT&)>::value, "");
+            static_assert(std::is_callable<Fn(const T&)>::value, "");
+            static_assert(std::is_callable<Fn(T&&)>::value, "");
+            static_assert(std::is_callable<Fn(ST)>::value, "");
+            static_assert(std::is_callable<Fn(CT&)>::value, "");
         }
     }
     {
@@ -121,20 +121,20 @@ int main()
         {
             // Function pointer
             using Fp = void(*)(Tag&, int);
-            static_assert(std::is_callable<Fp(Tag&, int)>::value);
-            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value);
-            static_assert(!std::is_callable<Fp(const Tag&, int)>::value);
-            static_assert(!std::is_callable<Fp()>::value);
-            static_assert(!std::is_callable<Fp(Tag&)>::value);
+            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
+            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp()>::value, "");
+            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
         }
         {
             // Function reference
             using Fp = void(&)(Tag&, int);
-            static_assert(std::is_callable<Fp(Tag&, int)>::value);
-            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value);
-            static_assert(!std::is_callable<Fp(const Tag&, int)>::value);
-            static_assert(!std::is_callable<Fp()>::value);
-            static_assert(!std::is_callable<Fp(Tag&)>::value);
+            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
+            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
+            static_assert(!std::is_callable<Fp()>::value, "");
+            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
         }
         {
             // Function object
@@ -146,15 +146,15 @@ int main()
     {
         // Check that the conversion to the return type is properly checked
         using Fn = int(*)();
-        static_assert(std::is_callable<Fn(), Implicit>::value);
-        static_assert(std::is_callable<Fn(), double>::value);
-        static_assert(std::is_callable<Fn(), const volatile void>::value);
-        static_assert(!std::is_callable<Fn(), Explicit>::value);
+        static_assert(std::is_callable<Fn(), Implicit>::value, "");
+        static_assert(std::is_callable<Fn(), double>::value, "");
+        static_assert(std::is_callable<Fn(), const volatile void>::value, "");
+        static_assert(!std::is_callable<Fn(), Explicit>::value, "");
     }
     {
         // Check for is_callable_v
         using Fn = void(*)();
-        static_assert(std::is_callable_v<Fn()>);
-        static_assert(!std::is_callable_v<Fn(int)>);
+        static_assert(std::is_callable_v<Fn()>, "");
+        static_assert(!std::is_callable_v<Fn(int)>, "");
     }
 }
diff --git a/libcxx/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp b/libcxx/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
index 5cadc0bf8cbf..eefa6d1f22b1 100644
--- a/libcxx/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
+++ b/libcxx/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
@@ -58,16 +58,16 @@ void test_noexcept_function_pointers()
     {
         // Check that PMF's and function pointers *work*. is_nothrow_callable will always
         // return false because 'noexcept' is not part of the function type.
-        static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>());
-        static_assert(throws_callable<decltype(&Dummy::bar)()>());
+        static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>(), "");
+        static_assert(throws_callable<decltype(&Dummy::bar)()>(), "");
     }
 #else
     {
         // Check that PMF's and function pointers actually work and that
         // is_nothrow_callable returns true for noexcept PMF's and function
         // pointers.
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value);
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value);
+        static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value, "");
+        static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value, "");
     }
 #endif
 }
@@ -77,39 +77,39 @@ int main()
     {
         // Check that the conversion to the return type is properly checked
         using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable<Fn(), Implicit>::value);
-        static_assert(std::is_nothrow_callable<Fn(), double>::value);
-        static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value);
-        static_assert(throws_callable<Fn(), ThrowsImplicit>());
-        static_assert(!std::is_nothrow_callable<Fn(), Explicit>());
+        static_assert(std::is_nothrow_callable<Fn(), Implicit>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(), double>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value, "");
+        static_assert(throws_callable<Fn(), ThrowsImplicit>(), "");
+        static_assert(!std::is_nothrow_callable<Fn(), Explicit>(), "");
     }
     {
         // Check that the conversion to the parameters is properly checked
         using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
-        static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value);
-        static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value);
-        static_assert(throws_callable<Fn(int, int)>());
-        static_assert(!std::is_nothrow_callable<Fn()>::value);
+        static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value, "");
+        static_assert(throws_callable<Fn(int, int)>(), "");
+        static_assert(!std::is_nothrow_callable<Fn()>::value, "");
     }
     {
         // Check that the noexcept-ness of function objects is checked.
         using Fn = CallObject<true, void>;
         using Fn2 = CallObject<false, void>;
-        static_assert(std::is_nothrow_callable<Fn()>::value);
-        static_assert(throws_callable<Fn2()>());
+        static_assert(std::is_nothrow_callable<Fn()>::value, "");
+        static_assert(throws_callable<Fn2()>(), "");
     }
     {
         // Check that PMD derefs are noexcept
         using Fn = int (Tag::*);
-        static_assert(std::is_nothrow_callable<Fn(Tag&)>::value);
-        static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value);
-        static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>());
+        static_assert(std::is_nothrow_callable<Fn(Tag&)>::value, "");
+        static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value, "");
+        static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>(), "");
     }
     {
         // Check for is_nothrow_callable_v
         using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable_v<Fn()>);
-        static_assert(!std::is_nothrow_callable_v<Fn(int)>);
+        static_assert(std::is_nothrow_callable_v<Fn()>, "");
+        static_assert(!std::is_nothrow_callable_v<Fn(int)>, "");
     }
     test_noexcept_function_pointers();
 }
diff --git a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
index f2442f71d40c..7510b4e7293c 100644
--- a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
+++ b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
@@ -63,7 +63,7 @@ int main()
         static_assert(!std::is_nothrow_swappable<B>::value
                       && std::is_swappable<B>::value, "");
         static_assert(!std::is_nothrow_swappable<ThrowingMove>::value
-                      && std::is_swappable<ThrowingMove>::value);
+                      && std::is_swappable<ThrowingMove>::value, "");
     }
     {
         // Test that it doesn't drop the qualifiers
@@ -77,7 +77,7 @@ int main()
     }
     {
         // test for presence of is_nothrow_swappable_v
-        static_assert(std::is_nothrow_swappable_v<int>);
-        static_assert(!std::is_nothrow_swappable_v<void>);
+        static_assert(std::is_nothrow_swappable_v<int>, "");
+        static_assert(!std::is_nothrow_swappable_v<void>, "");
     }
 }
diff --git a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
index 54c0a0403988..e85b4279b26d 100644
--- a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
+++ b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
@@ -68,14 +68,14 @@ int main()
     }
     {
         // test we guard against cv void inputs as required.
-        static_assert(!std::is_nothrow_swappable_with_v<void, int>);
-        static_assert(!std::is_nothrow_swappable_with_v<int, void>);
-        static_assert(!std::is_nothrow_swappable_with_v<const void, const volatile void>);
+        static_assert(!std::is_nothrow_swappable_with_v<void, int>, "");
+        static_assert(!std::is_nothrow_swappable_with_v<int, void>, "");
+        static_assert(!std::is_nothrow_swappable_with_v<const void, const volatile void>, "");
 
     }
     {
         // test for presense of is_nothrow_swappable_with_v
-        static_assert(std::is_nothrow_swappable_with_v<int&, int&>);
-        static_assert(!std::is_nothrow_swappable_with_v<int&&, int&&>);
+        static_assert(std::is_nothrow_swappable_with_v<int&, int&>, "");
+        static_assert(!std::is_nothrow_swappable_with_v<int&&, int&&>, "");
     }
 }
diff --git a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
index 43a0a4fe46b1..b2a05d944437 100644
--- a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
+++ b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
@@ -71,7 +71,7 @@ int main()
     }
     {
         // test for presense of is_swappable_v
-        static_assert(std::is_swappable_v<int>);
-        static_assert(!std::is_swappable_v<M>);
+        static_assert(std::is_swappable_v<int>, "");
+        static_assert(!std::is_swappable_v<M>, "");
     }
 }
diff --git a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
index 9d470c156dc2..f557e25b72c7 100644
--- a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
+++ b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
@@ -66,13 +66,13 @@ int main()
     }
     {
         // test that cv void  is guarded against as required.
-        static_assert(!std::is_swappable_with_v<void, int>);
-        static_assert(!std::is_swappable_with_v<int, void>);
-        static_assert(!std::is_swappable_with_v<const void, const volatile void>);
+        static_assert(!std::is_swappable_with_v<void, int>, "");
+        static_assert(!std::is_swappable_with_v<int, void>, "");
+        static_assert(!std::is_swappable_with_v<const void, const volatile void>, "");
     }
     {
         // test for presence of is_swappable_with_v
-        static_assert(std::is_swappable_with_v<int&, int&>);
-        static_assert(!std::is_swappable_with_v<D&, C&>);
+        static_assert(std::is_swappable_with_v<int&, int&>, "");
+        static_assert(!std::is_swappable_with_v<D&, C&>, "");
     }
 }