STL_MSFT created this revision.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
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.
http://reviews.llvm.org/D21350
Files:
test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
test/std/utilities/meta/meta.rel/is_callable.pass.cpp
test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
@@ -66,13 +66,13 @@
}
{
// 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&>, "");
}
}
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
@@ -71,7 +71,7 @@
}
{
// 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>, "");
}
}
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
@@ -68,14 +68,14 @@
}
{
// 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&&>, "");
}
}
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
@@ -63,7 +63,7 @@
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 @@
}
{
// 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>, "");
}
}
Index: test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
+++ test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
@@ -58,16 +58,16 @@
{
// 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 @@
{
// 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();
}
Index: test/std/utilities/meta/meta.rel/is_callable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rel/is_callable.pass.cpp
+++ test/std/utilities/meta/meta.rel/is_callable.pass.cpp
@@ -46,95 +46,95 @@
// 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
@@ -146,15 +146,15 @@
{
// 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)>, "");
}
}
Index: test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
+++ test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
@@ -250,10 +250,10 @@
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 @@
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 @@
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 @@
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 @@
{
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 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, "");
}
}
Index: test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
+++ test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
@@ -327,17 +327,17 @@
{
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)), "");
}
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
