| //===----------------------------------------------------------------------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // <functional> | |
| // template<class R, class T> constexpr unspecified mem_fn(R T::*) noexcept; // constexpr in C++20 | |
| #include <functional> | |
| #include <cassert> | |
| #include <utility> | |
| #include <type_traits> | |
| #include "test_macros.h" | |
| struct A { | |
| double data_; | |
| TEST_CONSTEXPR_CXX14 char test0() { return 'a'; } | |
| TEST_CONSTEXPR_CXX14 char test1(int) { return 'b'; } | |
| TEST_CONSTEXPR_CXX14 char test2(int, double) { return 'c'; } | |
| TEST_CONSTEXPR_CXX14 char test0_nothrow() TEST_NOEXCEPT { return 'd'; } | |
| TEST_CONSTEXPR_CXX14 char test1_nothrow(int) TEST_NOEXCEPT { return 'e'; } | |
| TEST_CONSTEXPR_CXX14 char test2_nothrow(int, double) TEST_NOEXCEPT { return 'f'; } | |
| TEST_CONSTEXPR char test_c0() const { return 'a'; } | |
| TEST_CONSTEXPR char test_c1(int) const { return 'b'; } | |
| TEST_CONSTEXPR char test_c2(int, double) const { return 'c'; } | |
| TEST_CONSTEXPR char test_c0_nothrow() const TEST_NOEXCEPT { return 'd'; } | |
| TEST_CONSTEXPR char test_c1_nothrow(int) const TEST_NOEXCEPT { return 'e'; } | |
| TEST_CONSTEXPR char test_c2_nothrow(int, double) const TEST_NOEXCEPT { return 'f'; } | |
| char test_v0() volatile { return 'a'; } | |
| char test_v1(int) volatile { return 'b'; } | |
| char test_v2(int, double) volatile { return 'c'; } | |
| char test_v0_nothrow() volatile TEST_NOEXCEPT { return 'd'; } | |
| char test_v1_nothrow(int) volatile TEST_NOEXCEPT { return 'e'; } | |
| char test_v2_nothrow(int, double) volatile TEST_NOEXCEPT { return 'f'; } | |
| char test_cv0() const volatile { return 'a'; } | |
| char test_cv1(int) const volatile { return 'b'; } | |
| char test_cv2(int, double) const volatile { return 'c'; } | |
| char test_cv0_nothrow() const volatile TEST_NOEXCEPT { return 'd'; } | |
| char test_cv1_nothrow(int) const volatile TEST_NOEXCEPT { return 'e'; } | |
| char test_cv2_nothrow(int, double) const volatile TEST_NOEXCEPT { return 'f'; } | |
| }; | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_data(F f) { | |
| A a = {0.0}; | |
| f(a) = 5; | |
| assert(a.data_ == 5); | |
| A* ap = &a; | |
| f(ap) = 6; | |
| assert(a.data_ == 6); | |
| const A* cap = ap; | |
| assert(f(cap) == f(ap)); | |
| const F& cf = f; | |
| assert(cf(ap) == f(ap)); | |
| #if TEST_STD_VER >= 11 | |
| static_assert(noexcept(f(a)), ""); | |
| static_assert(noexcept(f(ap)), ""); | |
| static_assert(noexcept(f(cap)), ""); | |
| static_assert(noexcept(cf(ap)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'a'); | |
| A* ap = &a; | |
| assert(f(ap) == 'a'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'a'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a)), ""); | |
| static_assert(!noexcept(f(ap)), ""); | |
| static_assert(!noexcept(cf(ap)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'b'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'b'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'b'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0)), ""); | |
| static_assert(!noexcept(f(ap, 1)), ""); | |
| static_assert(!noexcept(cf(ap, 2)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'c'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'c'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'c'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(!noexcept(f(ap, 1, 2)), ""); | |
| static_assert(!noexcept(cf(ap, 2, 3.5)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_noexcept_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'd'); | |
| A* ap = &a; | |
| assert(f(ap) == 'd'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'd'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a)), ""); | |
| static_assert(noexcept(f(ap)), ""); | |
| static_assert(noexcept(cf(ap)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_noexcept_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'e'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'e'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'e'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0)), ""); | |
| static_assert(noexcept(f(ap, 1)), ""); | |
| static_assert(noexcept(cf(ap, 2)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_noexcept_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'f'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'f'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'f'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(noexcept(f(ap, 1, 2)), ""); | |
| static_assert(noexcept(cf(ap, 2, 3.5)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_const_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'a'); | |
| A* ap = &a; | |
| assert(f(ap) == 'a'); | |
| const A* cap = &a; | |
| assert(f(cap) == 'a'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'a'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a)), ""); | |
| static_assert(!noexcept(f(ap)), ""); | |
| static_assert(!noexcept(f(cap)), ""); | |
| static_assert(!noexcept(cf(ap)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_const_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'b'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'b'); | |
| const A* cap = &a; | |
| assert(f(cap, 2) == 'b'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'b'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0)), ""); | |
| static_assert(!noexcept(f(ap, 1)), ""); | |
| static_assert(!noexcept(f(cap, 2)), ""); | |
| static_assert(!noexcept(cf(ap, 3)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_const_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'c'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'c'); | |
| const A* cap = &a; | |
| assert(f(cap, 2, 3.5) == 'c'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'c'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(!noexcept(f(ap, 1, 2)), ""); | |
| static_assert(!noexcept(f(cap, 2, 3.5)), ""); | |
| static_assert(!noexcept(cf(ap, 3, 17.29)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_const_noexcept_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'd'); | |
| A* ap = &a; | |
| assert(f(ap) == 'd'); | |
| const A* cap = &a; | |
| assert(f(cap) == 'd'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'd'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a)), ""); | |
| static_assert(noexcept(f(ap)), ""); | |
| static_assert(noexcept(f(cap)), ""); | |
| static_assert(noexcept(cf(ap)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_const_noexcept_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'e'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'e'); | |
| const A* cap = &a; | |
| assert(f(cap, 2) == 'e'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'e'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0)), ""); | |
| static_assert(noexcept(f(ap, 1)), ""); | |
| static_assert(noexcept(f(cap, 2)), ""); | |
| static_assert(noexcept(cf(ap, 3)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| TEST_CONSTEXPR_CXX20 bool test_const_noexcept_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'f'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'f'); | |
| const A* cap = &a; | |
| assert(f(cap, 2, 3.5) == 'f'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'f'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(noexcept(f(ap, 1, 2)), ""); | |
| static_assert(noexcept(f(cap, 2, 3.5)), ""); | |
| static_assert(noexcept(cf(ap, 3, 17.29)), ""); | |
| #endif | |
| return true; | |
| } | |
| template <class F> | |
| void test_volatile_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'a'); | |
| A* ap = &a; | |
| assert(f(ap) == 'a'); | |
| volatile A* cap = &a; | |
| assert(f(cap) == 'a'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'a'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a)), ""); | |
| static_assert(!noexcept(f(ap)), ""); | |
| static_assert(!noexcept(f(cap)), ""); | |
| static_assert(!noexcept(cf(ap)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_volatile_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'b'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'b'); | |
| volatile A* cap = &a; | |
| assert(f(cap, 2) == 'b'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'b'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0)), ""); | |
| static_assert(!noexcept(f(ap, 1)), ""); | |
| static_assert(!noexcept(f(cap, 2)), ""); | |
| static_assert(!noexcept(cf(ap, 3)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_volatile_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'c'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'c'); | |
| volatile A* cap = &a; | |
| assert(f(cap, 2, 3.5) == 'c'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'c'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(!noexcept(f(ap, 1, 2)), ""); | |
| static_assert(!noexcept(f(cap, 2, 3.5)), ""); | |
| static_assert(!noexcept(cf(ap, 3, 17.29)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_volatile_noexcept_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'd'); | |
| A* ap = &a; | |
| assert(f(ap) == 'd'); | |
| volatile A* cap = &a; | |
| assert(f(cap) == 'd'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'd'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a)), ""); | |
| static_assert(noexcept(f(ap)), ""); | |
| static_assert(noexcept(f(cap)), ""); | |
| static_assert(noexcept(cf(ap)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_volatile_noexcept_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'e'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'e'); | |
| volatile A* cap = &a; | |
| assert(f(cap, 2) == 'e'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'e'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0)), ""); | |
| static_assert(noexcept(f(ap, 1)), ""); | |
| static_assert(noexcept(f(cap, 2)), ""); | |
| static_assert(noexcept(cf(ap, 3)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_volatile_noexcept_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'f'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'f'); | |
| volatile A* cap = &a; | |
| assert(f(cap, 2, 3.5) == 'f'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'f'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(noexcept(f(ap, 1, 2)), ""); | |
| static_assert(noexcept(f(cap, 2, 3.5)), ""); | |
| static_assert(noexcept(cf(ap, 3, 17.29)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_const_volatile_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'a'); | |
| A* ap = &a; | |
| assert(f(ap) == 'a'); | |
| const volatile A* cap = &a; | |
| assert(f(cap) == 'a'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'a'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a)), ""); | |
| static_assert(!noexcept(f(ap)), ""); | |
| static_assert(!noexcept(f(cap)), ""); | |
| static_assert(!noexcept(cf(ap)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_const_volatile_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'b'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'b'); | |
| const volatile A* cap = &a; | |
| assert(f(cap, 2) == 'b'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'b'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0)), ""); | |
| static_assert(!noexcept(f(ap, 1)), ""); | |
| static_assert(!noexcept(f(cap, 2)), ""); | |
| static_assert(!noexcept(cf(ap, 3)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_const_volatile_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'c'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'c'); | |
| const volatile A* cap = &a; | |
| assert(f(cap, 2, 3.5) == 'c'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'c'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(!noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(!noexcept(f(ap, 1, 2)), ""); | |
| static_assert(!noexcept(f(cap, 2, 3.5)), ""); | |
| static_assert(!noexcept(cf(ap, 3, 17.29)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_const_volatile_noexcept_fun0(F f) { | |
| A a = {}; | |
| assert(f(a) == 'd'); | |
| A* ap = &a; | |
| assert(f(ap) == 'd'); | |
| const volatile A* cap = &a; | |
| assert(f(cap) == 'd'); | |
| const F& cf = f; | |
| assert(cf(ap) == 'd'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a)), ""); | |
| static_assert(noexcept(f(ap)), ""); | |
| static_assert(noexcept(f(cap)), ""); | |
| static_assert(noexcept(cf(ap)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_const_volatile_noexcept_fun1(F f) { | |
| A a = {}; | |
| assert(f(a, 1) == 'e'); | |
| A* ap = &a; | |
| assert(f(ap, 2) == 'e'); | |
| const volatile A* cap = &a; | |
| assert(f(cap, 2) == 'e'); | |
| const F& cf = f; | |
| assert(cf(ap, 2) == 'e'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0)), ""); | |
| static_assert(noexcept(f(ap, 1)), ""); | |
| static_assert(noexcept(f(cap, 2)), ""); | |
| static_assert(noexcept(cf(ap, 3)), ""); | |
| #endif | |
| } | |
| template <class F> | |
| void test_const_volatile_noexcept_fun2(F f) { | |
| A a = {}; | |
| assert(f(a, 1, 2) == 'f'); | |
| A* ap = &a; | |
| assert(f(ap, 2, 3.5) == 'f'); | |
| const volatile A* cap = &a; | |
| assert(f(cap, 2, 3.5) == 'f'); | |
| const F& cf = f; | |
| assert(cf(ap, 2, 3.5) == 'f'); | |
| #if TEST_STD_VER >= 17 | |
| static_assert(noexcept(f(a, 0, 0.0)), ""); | |
| static_assert(noexcept(f(ap, 1, 2)), ""); | |
| static_assert(noexcept(f(cap, 2, 3.5)), ""); | |
| static_assert(noexcept(cf(ap, 3, 17.29)), ""); | |
| #endif | |
| } | |
| #if TEST_STD_VER >= 11 | |
| template <class V, class Func, class... Args> | |
| struct is_callable_impl : std::false_type {}; | |
| template <class Func, class... Args> | |
| struct is_callable_impl<decltype((void)std::declval<Func>()(std::declval<Args>()...)), Func, Args...> : std::true_type { | |
| }; | |
| template <class Func, class... Args> | |
| struct is_callable : is_callable_impl<void, Func, Args...>::type {}; | |
| template <class F> | |
| void test_sfinae_data(F) { | |
| static_assert(is_callable<F, A>::value, ""); | |
| static_assert(is_callable<F, const A>::value, ""); | |
| static_assert(is_callable<F, A&>::value, ""); | |
| static_assert(is_callable<F, const A&>::value, ""); | |
| static_assert(is_callable<F, A*>::value, ""); | |
| static_assert(is_callable<F, const A*>::value, ""); | |
| static_assert(!is_callable<F, A, char>::value, ""); | |
| static_assert(!is_callable<F, const A, char>::value, ""); | |
| static_assert(!is_callable<F, A&, char>::value, ""); | |
| static_assert(!is_callable<F, const A&, char>::value, ""); | |
| static_assert(!is_callable<F, A*, char>::value, ""); | |
| static_assert(!is_callable<F, const A*, char>::value, ""); | |
| } | |
| template <class F> | |
| void test_sfinae_fun0(F) { | |
| static_assert(is_callable<F, A>::value, ""); | |
| static_assert(is_callable<F, A&>::value, ""); | |
| static_assert(is_callable<F, A*>::value, ""); | |
| static_assert(!is_callable<F, const A>::value, ""); | |
| static_assert(!is_callable<F, const A&>::value, ""); | |
| static_assert(!is_callable<F, const A*>::value, ""); | |
| static_assert(!is_callable<F, volatile A>::value, ""); | |
| static_assert(!is_callable<F, volatile A&>::value, ""); | |
| static_assert(!is_callable<F, volatile A*>::value, ""); | |
| static_assert(!is_callable<F, const volatile A>::value, ""); | |
| static_assert(!is_callable<F, const volatile A&>::value, ""); | |
| static_assert(!is_callable<F, const volatile A*>::value, ""); | |
| static_assert(!is_callable<F, A, int>::value, ""); | |
| static_assert(!is_callable<F, A&, int>::value, ""); | |
| static_assert(!is_callable<F, A*, int>::value, ""); | |
| } | |
| template <class F> | |
| void test_sfinae_fun1(F) { | |
| static_assert(is_callable<F, A, int>::value, ""); | |
| static_assert(is_callable<F, A&, int>::value, ""); | |
| static_assert(is_callable<F, A*, int>::value, ""); | |
| static_assert(!is_callable<F, A>::value, ""); | |
| static_assert(!is_callable<F, A&>::value, ""); | |
| static_assert(!is_callable<F, A*>::value, ""); | |
| } | |
| template <class F> | |
| void test_sfinae_const_fun0(F) { | |
| static_assert(is_callable<F, A>::value, ""); | |
| static_assert(is_callable<F, A&>::value, ""); | |
| static_assert(is_callable<F, A*>::value, ""); | |
| static_assert(is_callable<F, const A>::value, ""); | |
| static_assert(is_callable<F, const A&>::value, ""); | |
| static_assert(is_callable<F, const A*>::value, ""); | |
| static_assert(!is_callable<F, volatile A>::value, ""); | |
| static_assert(!is_callable<F, volatile A&>::value, ""); | |
| static_assert(!is_callable<F, volatile A*>::value, ""); | |
| static_assert(!is_callable<F, const volatile A>::value, ""); | |
| static_assert(!is_callable<F, const volatile A&>::value, ""); | |
| static_assert(!is_callable<F, const volatile A*>::value, ""); | |
| } | |
| template <class F> | |
| void test_sfinae_volatile_fun0(F) { | |
| static_assert(is_callable<F, A>::value, ""); | |
| static_assert(is_callable<F, A&>::value, ""); | |
| static_assert(is_callable<F, A*>::value, ""); | |
| static_assert(!is_callable<F, const A>::value, ""); | |
| static_assert(!is_callable<F, const A&>::value, ""); | |
| static_assert(!is_callable<F, const A*>::value, ""); | |
| static_assert(is_callable<F, volatile A>::value, ""); | |
| static_assert(is_callable<F, volatile A&>::value, ""); | |
| static_assert(is_callable<F, volatile A*>::value, ""); | |
| static_assert(!is_callable<F, const volatile A>::value, ""); | |
| static_assert(!is_callable<F, const volatile A&>::value, ""); | |
| static_assert(!is_callable<F, const volatile A*>::value, ""); | |
| } | |
| template <class F> | |
| void test_sfinae_const_volatile_fun0(F) { | |
| static_assert(is_callable<F, A>::value, ""); | |
| static_assert(is_callable<F, A&>::value, ""); | |
| static_assert(is_callable<F, A*>::value, ""); | |
| static_assert(is_callable<F, const A>::value, ""); | |
| static_assert(is_callable<F, const A&>::value, ""); | |
| static_assert(is_callable<F, const A*>::value, ""); | |
| static_assert(is_callable<F, volatile A>::value, ""); | |
| static_assert(is_callable<F, volatile A&>::value, ""); | |
| static_assert(is_callable<F, volatile A*>::value, ""); | |
| static_assert(is_callable<F, const volatile A>::value, ""); | |
| static_assert(is_callable<F, const volatile A&>::value, ""); | |
| static_assert(is_callable<F, const volatile A*>::value, ""); | |
| } | |
| #endif | |
| int main(int, char**) { | |
| test_data(std::mem_fn(&A::data_)); | |
| test_fun0(std::mem_fn(&A::test0)); | |
| test_fun1(std::mem_fn(&A::test1)); | |
| test_fun2(std::mem_fn(&A::test2)); | |
| test_noexcept_fun0(std::mem_fn(&A::test0_nothrow)); | |
| test_noexcept_fun1(std::mem_fn(&A::test1_nothrow)); | |
| test_noexcept_fun2(std::mem_fn(&A::test2_nothrow)); | |
| test_const_fun0(std::mem_fn(&A::test_c0)); | |
| test_const_fun1(std::mem_fn(&A::test_c1)); | |
| test_const_fun2(std::mem_fn(&A::test_c2)); | |
| test_const_noexcept_fun0(std::mem_fn(&A::test_c0_nothrow)); | |
| test_const_noexcept_fun1(std::mem_fn(&A::test_c1_nothrow)); | |
| test_const_noexcept_fun2(std::mem_fn(&A::test_c2_nothrow)); | |
| test_volatile_fun0(std::mem_fn(&A::test_v0)); | |
| test_volatile_fun1(std::mem_fn(&A::test_v1)); | |
| test_volatile_fun2(std::mem_fn(&A::test_v2)); | |
| test_volatile_noexcept_fun0(std::mem_fn(&A::test_v0_nothrow)); | |
| test_volatile_noexcept_fun1(std::mem_fn(&A::test_v1_nothrow)); | |
| test_volatile_noexcept_fun2(std::mem_fn(&A::test_v2_nothrow)); | |
| test_const_volatile_fun0(std::mem_fn(&A::test_cv0)); | |
| test_const_volatile_fun1(std::mem_fn(&A::test_cv1)); | |
| test_const_volatile_fun2(std::mem_fn(&A::test_cv2)); | |
| test_const_volatile_noexcept_fun0(std::mem_fn(&A::test_cv0_nothrow)); | |
| test_const_volatile_noexcept_fun1(std::mem_fn(&A::test_cv1_nothrow)); | |
| test_const_volatile_noexcept_fun2(std::mem_fn(&A::test_cv2_nothrow)); | |
| #if TEST_STD_VER >= 11 | |
| // LWG2489 | |
| static_assert((noexcept(std::mem_fn(&A::data_))), ""); | |
| static_assert((noexcept(std::mem_fn(&A::test0))), ""); | |
| static_assert((noexcept(std::mem_fn(&A::test0_nothrow))), ""); | |
| test_sfinae_data(std::mem_fn(&A::data_)); | |
| test_sfinae_fun0(std::mem_fn(&A::test0)); | |
| test_sfinae_fun0(std::mem_fn(&A::test0_nothrow)); | |
| test_sfinae_const_fun0(std::mem_fn(&A::test_c0)); | |
| test_sfinae_const_fun0(std::mem_fn(&A::test_c0_nothrow)); | |
| test_sfinae_volatile_fun0(std::mem_fn(&A::test_v0)); | |
| test_sfinae_volatile_fun0(std::mem_fn(&A::test_v0_nothrow)); | |
| test_sfinae_const_volatile_fun0(std::mem_fn(&A::test_cv0)); | |
| test_sfinae_const_volatile_fun0(std::mem_fn(&A::test_cv0_nothrow)); | |
| test_sfinae_fun1(std::mem_fn(&A::test1)); | |
| test_sfinae_fun1(std::mem_fn(&A::test1_nothrow)); | |
| #endif | |
| #if TEST_STD_VER >= 20 | |
| static_assert(test_data(std::mem_fn(&A::data_))); | |
| static_assert(test_fun0(std::mem_fn(&A::test0))); | |
| static_assert(test_fun1(std::mem_fn(&A::test1))); | |
| static_assert(test_fun2(std::mem_fn(&A::test2))); | |
| static_assert(test_const_fun0(std::mem_fn(&A::test_c0))); | |
| static_assert(test_const_fun1(std::mem_fn(&A::test_c1))); | |
| static_assert(test_const_fun2(std::mem_fn(&A::test_c2))); | |
| static_assert(test_noexcept_fun0(std::mem_fn(&A::test0_nothrow))); | |
| static_assert(test_noexcept_fun1(std::mem_fn(&A::test1_nothrow))); | |
| static_assert(test_noexcept_fun2(std::mem_fn(&A::test2_nothrow))); | |
| static_assert(test_const_noexcept_fun0(std::mem_fn(&A::test_c0_nothrow))); | |
| static_assert(test_const_noexcept_fun1(std::mem_fn(&A::test_c1_nothrow))); | |
| static_assert(test_const_noexcept_fun2(std::mem_fn(&A::test_c2_nothrow))); | |
| #endif | |
| return 0; | |
| } |