[libcxx] [test] Avoid C++17 terse static_assert.

[STL_MSFT]

Summary

TOTALLY OPTIONAL, feel free to reject this, I won't mind.

Newly-added libcxx tests for C++17 features have been using C++17 terse static_asserts occasionally. This is problematic for MSVC at the moment, since the compiler doesn't yet support the terse form. Changing the tests to always use the original recipe static_assert instead of extra crispy allows them to pass when we have the corresponding library support.

MSVC will be gaining support for the terse form soon, which will make this a non-issue for me, but I wanted to send out this change just in case you thought it was a worthwhile improvement in consistency.

[EricWF]

I'm really happy to accept this patch. I was trying to run some of these tests against GCC 5.3 last week and it didn't support this form of static assert yet.
I'm secretly sad that we have to roll it back though :-( It's so much nicer.

[EricWF]

r273353.

test/std/utilities/function.objects/func.invoke/invoke.pass.cpp

 struct MemberObj {
   int x;
 };
 
 void noexcept_test() {
     {
         NoThrowCallable obj;
         CopyThrows arg;
-        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;
-        static_assert(!noexcept(std::invoke(obj)));
+        static_assert(!noexcept(std::invoke(obj)), "");
     }
     {
         MemberObj obj{42};
-        static_assert(noexcept(std::invoke(&MemberObj::x, obj)));
+        static_assert(noexcept(std::invoke(&MemberObj::x, obj)), "");
     }
 }
 
 int main() {
     bullet_one_two_tests();
     bullet_three_four_tests();
     bullet_five_tests();
     noexcept_test();
 }

test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

 
 
 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);
         // test that ret() negates the original value 'true'
         assert(ret() == false);
         assert(ret(0, 0.0, "blah") == false);
         // Move ret and test that it was moved from and that ret2 got the
         // original value.
         auto ret2 = std::move(ret);
         assert(ret() == true);
         assert(ret2() == false);
         assert(ret2(42) == false);
     }
     {
         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);
         // test 'ret' has the original value
         assert(ret() == true);
         assert(ret(42, 100) == true);
         // move from 'ret' and check that 'ret2' has the original value.
         auto ret2 = std::move(ret);
         assert(ret() == false);
         assert(ret2() == true);
         assert(ret2("abc") == true);
     }
     {
         using T = CopyAssignableWrapper;
         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);
         assert(ret2() == true);
         ret = ret2;
         assert(ret() == true);
         assert(ret2() == true);
     }
     {
         using T = MoveAssignableWrapper;
         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));
         assert(ret2() == true);
         ret = std::move(ret2);
         assert(ret() == true);
     }
 }
 
 void return_type_tests()
 {
     using std::is_same;
     {
         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);
         assert(value_ret.value == true);
         ret();
         assert(EvilBool::bang_called == 2);
     }
 }
struct ThrowsOnCopy {
         }
     }
 #endif
 }
 
 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, "");
     }
 }
 
 void call_operator_forwarding_test()
 {
     using Fn = ForwardingCallObject;
     auto obj = std::not_fn(Fn{});
     const auto& c_obj = obj;

test/std/utilities/meta/meta.rel/is_callable.pass.cpp

 int main()
 {
     {
         using Fn = int(Tag::*)(int);
         using RFn = int(Tag::*)(int) &&;
         // 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
             using T = Tag*;
             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
             using T = Tag*;
             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, "");
         }
     }
     {
         // INVOKE bullet 7
         {
             // 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
             using Fn = NotCallableWithInt;
             static_assert(std::is_callable<Fn(Tag)>::value, "");
             static_assert(!std::is_callable<Fn(int)>::value, "");
         }
     }
     {
         // 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)>, "");
     }
 }

test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp

 // once implementations have caught up.
 void test_noexcept_function_pointers()
 {
     struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
 #if !defined(__cpp_noexcept_function_type)
     {
         // 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
 }
 
 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();
 }

test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp

using namespace MyNS;
         static_assert(!std::is_nothrow_swappable<M&&>::value, "");
     }
     {
         // Test that it correctly deduces the noexcept of swap.
         static_assert(std::is_nothrow_swappable<A>::value, "");
         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
         static_assert(!std::is_nothrow_swappable<const A>::value, "");
     }
     {
         // test non-referenceable types
         static_assert(!std::is_nothrow_swappable<void>::value, "");
         static_assert(!std::is_nothrow_swappable<int() const>::value, "");
         static_assert(!std::is_nothrow_swappable<int(int, ...) const &>::value, "");
     }
     {
         // 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>, "");
     }
 }

test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp

using namespace MyNS;
         // 'swap(B, A)' are valid.
         static_assert(std::is_nothrow_swappable_with<A&, B&>::value, "");
         static_assert(!std::is_nothrow_swappable_with<A&, C&>::value &&
                       std::is_swappable_with<A&, C&>::value, "");
         static_assert(!std::is_nothrow_swappable_with<D&, C&>::value, "");
     }
     {
         // 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&&>, "");
     }
 }

test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp

int main()
     {
         // test non-referencable types
         static_assert(!std::is_swappable<void>::value, "");
         static_assert(!std::is_swappable<int() const>::value, "");
         static_assert(!std::is_swappable<int() &>::value, "");
     }
     {
         // 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>, "");
     }
 }

test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp

using namespace MyNS;
         // test that heterogeneous swap is allowed only if both 'swap(A, B)' and
         // 'swap(B, A)' are valid.
         static_assert(std::is_swappable_with<A&, B&>::value, "");
         static_assert(!std::is_swappable_with<A&, C&>::value, "");
         static_assert(!std::is_swappable_with<D&, C&>::value, "");
     }
     {
         // 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&>, "");
     }
 }