1*a061d4d5SA. Jiang //===----------------------------------------------------------------------===// 2*a061d4d5SA. Jiang // 3*a061d4d5SA. Jiang // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4*a061d4d5SA. Jiang // See https://llvm.org/LICENSE.txt for license information. 5*a061d4d5SA. Jiang // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6*a061d4d5SA. Jiang // 7*a061d4d5SA. Jiang //===----------------------------------------------------------------------===// 8*a061d4d5SA. Jiang 9*a061d4d5SA. Jiang // <functional> 10*a061d4d5SA. Jiang 11*a061d4d5SA. Jiang // template<class R, class T> constexpr unspecified mem_fn(R T::*) noexcept; // constexpr in C++20 12*a061d4d5SA. Jiang 13*a061d4d5SA. Jiang #include <functional> 14*a061d4d5SA. Jiang #include <cassert> 15*a061d4d5SA. Jiang #include <utility> 16*a061d4d5SA. Jiang #include <type_traits> 17*a061d4d5SA. Jiang 18*a061d4d5SA. Jiang #include "test_macros.h" 19*a061d4d5SA. Jiang 20*a061d4d5SA. Jiang struct A { 21*a061d4d5SA. Jiang double data_; 22*a061d4d5SA. Jiang 23*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX14 char test0() { return 'a'; } 24*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX14 char test1(int) { return 'b'; } 25*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX14 char test2(int, double) { return 'c'; } 26*a061d4d5SA. Jiang 27*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX14 char test0_nothrow() TEST_NOEXCEPT { return 'd'; } 28*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX14 char test1_nothrow(int) TEST_NOEXCEPT { return 'e'; } 29*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX14 char test2_nothrow(int, double) TEST_NOEXCEPT { return 'f'; } 30*a061d4d5SA. Jiang 31*a061d4d5SA. Jiang TEST_CONSTEXPR char test_c0() const { return 'a'; } 32*a061d4d5SA. Jiang TEST_CONSTEXPR char test_c1(int) const { return 'b'; } 33*a061d4d5SA. Jiang TEST_CONSTEXPR char test_c2(int, double) const { return 'c'; } 34*a061d4d5SA. Jiang 35*a061d4d5SA. Jiang TEST_CONSTEXPR char test_c0_nothrow() const TEST_NOEXCEPT { return 'd'; } 36*a061d4d5SA. Jiang TEST_CONSTEXPR char test_c1_nothrow(int) const TEST_NOEXCEPT { return 'e'; } 37*a061d4d5SA. Jiang TEST_CONSTEXPR char test_c2_nothrow(int, double) const TEST_NOEXCEPT { return 'f'; } 38*a061d4d5SA. Jiang 39*a061d4d5SA. Jiang char test_v0() volatile { return 'a'; } 40*a061d4d5SA. Jiang char test_v1(int) volatile { return 'b'; } 41*a061d4d5SA. Jiang char test_v2(int, double) volatile { return 'c'; } 42*a061d4d5SA. Jiang 43*a061d4d5SA. Jiang char test_v0_nothrow() volatile TEST_NOEXCEPT { return 'd'; } 44*a061d4d5SA. Jiang char test_v1_nothrow(int) volatile TEST_NOEXCEPT { return 'e'; } 45*a061d4d5SA. Jiang char test_v2_nothrow(int, double) volatile TEST_NOEXCEPT { return 'f'; } 46*a061d4d5SA. Jiang 47*a061d4d5SA. Jiang char test_cv0() const volatile { return 'a'; } 48*a061d4d5SA. Jiang char test_cv1(int) const volatile { return 'b'; } 49*a061d4d5SA. Jiang char test_cv2(int, double) const volatile { return 'c'; } 50*a061d4d5SA. Jiang 51*a061d4d5SA. Jiang char test_cv0_nothrow() const volatile TEST_NOEXCEPT { return 'd'; } 52*a061d4d5SA. Jiang char test_cv1_nothrow(int) const volatile TEST_NOEXCEPT { return 'e'; } 53*a061d4d5SA. Jiang char test_cv2_nothrow(int, double) const volatile TEST_NOEXCEPT { return 'f'; } 54*a061d4d5SA. Jiang }; 55*a061d4d5SA. Jiang 56*a061d4d5SA. Jiang template <class F> 57*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_data(F f) { 58*a061d4d5SA. Jiang A a = {0.0}; 59*a061d4d5SA. Jiang f(a) = 5; 60*a061d4d5SA. Jiang assert(a.data_ == 5); 61*a061d4d5SA. Jiang A* ap = &a; 62*a061d4d5SA. Jiang f(ap) = 6; 63*a061d4d5SA. Jiang assert(a.data_ == 6); 64*a061d4d5SA. Jiang const A* cap = ap; 65*a061d4d5SA. Jiang assert(f(cap) == f(ap)); 66*a061d4d5SA. Jiang const F& cf = f; 67*a061d4d5SA. Jiang assert(cf(ap) == f(ap)); 68*a061d4d5SA. Jiang 69*a061d4d5SA. Jiang #if TEST_STD_VER >= 11 70*a061d4d5SA. Jiang static_assert(noexcept(f(a)), ""); 71*a061d4d5SA. Jiang static_assert(noexcept(f(ap)), ""); 72*a061d4d5SA. Jiang static_assert(noexcept(f(cap)), ""); 73*a061d4d5SA. Jiang static_assert(noexcept(cf(ap)), ""); 74*a061d4d5SA. Jiang #endif 75*a061d4d5SA. Jiang 76*a061d4d5SA. Jiang return true; 77*a061d4d5SA. Jiang } 78*a061d4d5SA. Jiang 79*a061d4d5SA. Jiang template <class F> 80*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_fun0(F f) { 81*a061d4d5SA. Jiang A a = {}; 82*a061d4d5SA. Jiang assert(f(a) == 'a'); 83*a061d4d5SA. Jiang A* ap = &a; 84*a061d4d5SA. Jiang assert(f(ap) == 'a'); 85*a061d4d5SA. Jiang const F& cf = f; 86*a061d4d5SA. Jiang assert(cf(ap) == 'a'); 87*a061d4d5SA. Jiang 88*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 89*a061d4d5SA. Jiang static_assert(!noexcept(f(a)), ""); 90*a061d4d5SA. Jiang static_assert(!noexcept(f(ap)), ""); 91*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap)), ""); 92*a061d4d5SA. Jiang #endif 93*a061d4d5SA. Jiang 94*a061d4d5SA. Jiang return true; 95*a061d4d5SA. Jiang } 96*a061d4d5SA. Jiang 97*a061d4d5SA. Jiang template <class F> 98*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_fun1(F f) { 99*a061d4d5SA. Jiang A a = {}; 100*a061d4d5SA. Jiang assert(f(a, 1) == 'b'); 101*a061d4d5SA. Jiang A* ap = &a; 102*a061d4d5SA. Jiang assert(f(ap, 2) == 'b'); 103*a061d4d5SA. Jiang const F& cf = f; 104*a061d4d5SA. Jiang assert(cf(ap, 2) == 'b'); 105*a061d4d5SA. Jiang 106*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 107*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0)), ""); 108*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1)), ""); 109*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 2)), ""); 110*a061d4d5SA. Jiang #endif 111*a061d4d5SA. Jiang 112*a061d4d5SA. Jiang return true; 113*a061d4d5SA. Jiang } 114*a061d4d5SA. Jiang 115*a061d4d5SA. Jiang template <class F> 116*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_fun2(F f) { 117*a061d4d5SA. Jiang A a = {}; 118*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'c'); 119*a061d4d5SA. Jiang A* ap = &a; 120*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'c'); 121*a061d4d5SA. Jiang const F& cf = f; 122*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'c'); 123*a061d4d5SA. Jiang 124*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 125*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0, 0.0)), ""); 126*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1, 2)), ""); 127*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 2, 3.5)), ""); 128*a061d4d5SA. Jiang #endif 129*a061d4d5SA. Jiang 130*a061d4d5SA. Jiang return true; 131*a061d4d5SA. Jiang } 132*a061d4d5SA. Jiang 133*a061d4d5SA. Jiang template <class F> 134*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_noexcept_fun0(F f) { 135*a061d4d5SA. Jiang A a = {}; 136*a061d4d5SA. Jiang assert(f(a) == 'd'); 137*a061d4d5SA. Jiang A* ap = &a; 138*a061d4d5SA. Jiang assert(f(ap) == 'd'); 139*a061d4d5SA. Jiang const F& cf = f; 140*a061d4d5SA. Jiang assert(cf(ap) == 'd'); 141*a061d4d5SA. Jiang 142*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 143*a061d4d5SA. Jiang static_assert(noexcept(f(a)), ""); 144*a061d4d5SA. Jiang static_assert(noexcept(f(ap)), ""); 145*a061d4d5SA. Jiang static_assert(noexcept(cf(ap)), ""); 146*a061d4d5SA. Jiang #endif 147*a061d4d5SA. Jiang 148*a061d4d5SA. Jiang return true; 149*a061d4d5SA. Jiang } 150*a061d4d5SA. Jiang 151*a061d4d5SA. Jiang template <class F> 152*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_noexcept_fun1(F f) { 153*a061d4d5SA. Jiang A a = {}; 154*a061d4d5SA. Jiang assert(f(a, 1) == 'e'); 155*a061d4d5SA. Jiang A* ap = &a; 156*a061d4d5SA. Jiang assert(f(ap, 2) == 'e'); 157*a061d4d5SA. Jiang const F& cf = f; 158*a061d4d5SA. Jiang assert(cf(ap, 2) == 'e'); 159*a061d4d5SA. Jiang 160*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 161*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0)), ""); 162*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1)), ""); 163*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 2)), ""); 164*a061d4d5SA. Jiang #endif 165*a061d4d5SA. Jiang 166*a061d4d5SA. Jiang return true; 167*a061d4d5SA. Jiang } 168*a061d4d5SA. Jiang 169*a061d4d5SA. Jiang template <class F> 170*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_noexcept_fun2(F f) { 171*a061d4d5SA. Jiang A a = {}; 172*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'f'); 173*a061d4d5SA. Jiang A* ap = &a; 174*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'f'); 175*a061d4d5SA. Jiang const F& cf = f; 176*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'f'); 177*a061d4d5SA. Jiang 178*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 179*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0, 0.0)), ""); 180*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1, 2)), ""); 181*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 2, 3.5)), ""); 182*a061d4d5SA. Jiang #endif 183*a061d4d5SA. Jiang 184*a061d4d5SA. Jiang return true; 185*a061d4d5SA. Jiang } 186*a061d4d5SA. Jiang 187*a061d4d5SA. Jiang template <class F> 188*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_const_fun0(F f) { 189*a061d4d5SA. Jiang A a = {}; 190*a061d4d5SA. Jiang assert(f(a) == 'a'); 191*a061d4d5SA. Jiang A* ap = &a; 192*a061d4d5SA. Jiang assert(f(ap) == 'a'); 193*a061d4d5SA. Jiang const A* cap = &a; 194*a061d4d5SA. Jiang assert(f(cap) == 'a'); 195*a061d4d5SA. Jiang const F& cf = f; 196*a061d4d5SA. Jiang assert(cf(ap) == 'a'); 197*a061d4d5SA. Jiang 198*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 199*a061d4d5SA. Jiang static_assert(!noexcept(f(a)), ""); 200*a061d4d5SA. Jiang static_assert(!noexcept(f(ap)), ""); 201*a061d4d5SA. Jiang static_assert(!noexcept(f(cap)), ""); 202*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap)), ""); 203*a061d4d5SA. Jiang #endif 204*a061d4d5SA. Jiang 205*a061d4d5SA. Jiang return true; 206*a061d4d5SA. Jiang } 207*a061d4d5SA. Jiang 208*a061d4d5SA. Jiang template <class F> 209*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_const_fun1(F f) { 210*a061d4d5SA. Jiang A a = {}; 211*a061d4d5SA. Jiang assert(f(a, 1) == 'b'); 212*a061d4d5SA. Jiang A* ap = &a; 213*a061d4d5SA. Jiang assert(f(ap, 2) == 'b'); 214*a061d4d5SA. Jiang const A* cap = &a; 215*a061d4d5SA. Jiang assert(f(cap, 2) == 'b'); 216*a061d4d5SA. Jiang const F& cf = f; 217*a061d4d5SA. Jiang assert(cf(ap, 2) == 'b'); 218*a061d4d5SA. Jiang 219*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 220*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0)), ""); 221*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1)), ""); 222*a061d4d5SA. Jiang static_assert(!noexcept(f(cap, 2)), ""); 223*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 3)), ""); 224*a061d4d5SA. Jiang #endif 225*a061d4d5SA. Jiang 226*a061d4d5SA. Jiang return true; 227*a061d4d5SA. Jiang } 228*a061d4d5SA. Jiang 229*a061d4d5SA. Jiang template <class F> 230*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_const_fun2(F f) { 231*a061d4d5SA. Jiang A a = {}; 232*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'c'); 233*a061d4d5SA. Jiang A* ap = &a; 234*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'c'); 235*a061d4d5SA. Jiang const A* cap = &a; 236*a061d4d5SA. Jiang assert(f(cap, 2, 3.5) == 'c'); 237*a061d4d5SA. Jiang const F& cf = f; 238*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'c'); 239*a061d4d5SA. Jiang 240*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 241*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0, 0.0)), ""); 242*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1, 2)), ""); 243*a061d4d5SA. Jiang static_assert(!noexcept(f(cap, 2, 3.5)), ""); 244*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 3, 17.29)), ""); 245*a061d4d5SA. Jiang #endif 246*a061d4d5SA. Jiang 247*a061d4d5SA. Jiang return true; 248*a061d4d5SA. Jiang } 249*a061d4d5SA. Jiang 250*a061d4d5SA. Jiang template <class F> 251*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_const_noexcept_fun0(F f) { 252*a061d4d5SA. Jiang A a = {}; 253*a061d4d5SA. Jiang assert(f(a) == 'd'); 254*a061d4d5SA. Jiang A* ap = &a; 255*a061d4d5SA. Jiang assert(f(ap) == 'd'); 256*a061d4d5SA. Jiang const A* cap = &a; 257*a061d4d5SA. Jiang assert(f(cap) == 'd'); 258*a061d4d5SA. Jiang const F& cf = f; 259*a061d4d5SA. Jiang assert(cf(ap) == 'd'); 260*a061d4d5SA. Jiang 261*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 262*a061d4d5SA. Jiang static_assert(noexcept(f(a)), ""); 263*a061d4d5SA. Jiang static_assert(noexcept(f(ap)), ""); 264*a061d4d5SA. Jiang static_assert(noexcept(f(cap)), ""); 265*a061d4d5SA. Jiang static_assert(noexcept(cf(ap)), ""); 266*a061d4d5SA. Jiang #endif 267*a061d4d5SA. Jiang 268*a061d4d5SA. Jiang return true; 269*a061d4d5SA. Jiang } 270*a061d4d5SA. Jiang 271*a061d4d5SA. Jiang template <class F> 272*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_const_noexcept_fun1(F f) { 273*a061d4d5SA. Jiang A a = {}; 274*a061d4d5SA. Jiang assert(f(a, 1) == 'e'); 275*a061d4d5SA. Jiang A* ap = &a; 276*a061d4d5SA. Jiang assert(f(ap, 2) == 'e'); 277*a061d4d5SA. Jiang const A* cap = &a; 278*a061d4d5SA. Jiang assert(f(cap, 2) == 'e'); 279*a061d4d5SA. Jiang const F& cf = f; 280*a061d4d5SA. Jiang assert(cf(ap, 2) == 'e'); 281*a061d4d5SA. Jiang 282*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 283*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0)), ""); 284*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1)), ""); 285*a061d4d5SA. Jiang static_assert(noexcept(f(cap, 2)), ""); 286*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 3)), ""); 287*a061d4d5SA. Jiang #endif 288*a061d4d5SA. Jiang 289*a061d4d5SA. Jiang return true; 290*a061d4d5SA. Jiang } 291*a061d4d5SA. Jiang 292*a061d4d5SA. Jiang template <class F> 293*a061d4d5SA. Jiang TEST_CONSTEXPR_CXX20 bool test_const_noexcept_fun2(F f) { 294*a061d4d5SA. Jiang A a = {}; 295*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'f'); 296*a061d4d5SA. Jiang A* ap = &a; 297*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'f'); 298*a061d4d5SA. Jiang const A* cap = &a; 299*a061d4d5SA. Jiang assert(f(cap, 2, 3.5) == 'f'); 300*a061d4d5SA. Jiang const F& cf = f; 301*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'f'); 302*a061d4d5SA. Jiang 303*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 304*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0, 0.0)), ""); 305*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1, 2)), ""); 306*a061d4d5SA. Jiang static_assert(noexcept(f(cap, 2, 3.5)), ""); 307*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 3, 17.29)), ""); 308*a061d4d5SA. Jiang #endif 309*a061d4d5SA. Jiang 310*a061d4d5SA. Jiang return true; 311*a061d4d5SA. Jiang } 312*a061d4d5SA. Jiang 313*a061d4d5SA. Jiang template <class F> 314*a061d4d5SA. Jiang void test_volatile_fun0(F f) { 315*a061d4d5SA. Jiang A a = {}; 316*a061d4d5SA. Jiang assert(f(a) == 'a'); 317*a061d4d5SA. Jiang A* ap = &a; 318*a061d4d5SA. Jiang assert(f(ap) == 'a'); 319*a061d4d5SA. Jiang volatile A* cap = &a; 320*a061d4d5SA. Jiang assert(f(cap) == 'a'); 321*a061d4d5SA. Jiang const F& cf = f; 322*a061d4d5SA. Jiang assert(cf(ap) == 'a'); 323*a061d4d5SA. Jiang 324*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 325*a061d4d5SA. Jiang static_assert(!noexcept(f(a)), ""); 326*a061d4d5SA. Jiang static_assert(!noexcept(f(ap)), ""); 327*a061d4d5SA. Jiang static_assert(!noexcept(f(cap)), ""); 328*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap)), ""); 329*a061d4d5SA. Jiang #endif 330*a061d4d5SA. Jiang } 331*a061d4d5SA. Jiang 332*a061d4d5SA. Jiang template <class F> 333*a061d4d5SA. Jiang void test_volatile_fun1(F f) { 334*a061d4d5SA. Jiang A a = {}; 335*a061d4d5SA. Jiang assert(f(a, 1) == 'b'); 336*a061d4d5SA. Jiang A* ap = &a; 337*a061d4d5SA. Jiang assert(f(ap, 2) == 'b'); 338*a061d4d5SA. Jiang volatile A* cap = &a; 339*a061d4d5SA. Jiang assert(f(cap, 2) == 'b'); 340*a061d4d5SA. Jiang const F& cf = f; 341*a061d4d5SA. Jiang assert(cf(ap, 2) == 'b'); 342*a061d4d5SA. Jiang 343*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 344*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0)), ""); 345*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1)), ""); 346*a061d4d5SA. Jiang static_assert(!noexcept(f(cap, 2)), ""); 347*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 3)), ""); 348*a061d4d5SA. Jiang #endif 349*a061d4d5SA. Jiang } 350*a061d4d5SA. Jiang 351*a061d4d5SA. Jiang template <class F> 352*a061d4d5SA. Jiang void test_volatile_fun2(F f) { 353*a061d4d5SA. Jiang A a = {}; 354*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'c'); 355*a061d4d5SA. Jiang A* ap = &a; 356*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'c'); 357*a061d4d5SA. Jiang volatile A* cap = &a; 358*a061d4d5SA. Jiang assert(f(cap, 2, 3.5) == 'c'); 359*a061d4d5SA. Jiang const F& cf = f; 360*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'c'); 361*a061d4d5SA. Jiang 362*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 363*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0, 0.0)), ""); 364*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1, 2)), ""); 365*a061d4d5SA. Jiang static_assert(!noexcept(f(cap, 2, 3.5)), ""); 366*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 3, 17.29)), ""); 367*a061d4d5SA. Jiang #endif 368*a061d4d5SA. Jiang } 369*a061d4d5SA. Jiang 370*a061d4d5SA. Jiang template <class F> 371*a061d4d5SA. Jiang void test_volatile_noexcept_fun0(F f) { 372*a061d4d5SA. Jiang A a = {}; 373*a061d4d5SA. Jiang assert(f(a) == 'd'); 374*a061d4d5SA. Jiang A* ap = &a; 375*a061d4d5SA. Jiang assert(f(ap) == 'd'); 376*a061d4d5SA. Jiang volatile A* cap = &a; 377*a061d4d5SA. Jiang assert(f(cap) == 'd'); 378*a061d4d5SA. Jiang const F& cf = f; 379*a061d4d5SA. Jiang assert(cf(ap) == 'd'); 380*a061d4d5SA. Jiang 381*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 382*a061d4d5SA. Jiang static_assert(noexcept(f(a)), ""); 383*a061d4d5SA. Jiang static_assert(noexcept(f(ap)), ""); 384*a061d4d5SA. Jiang static_assert(noexcept(f(cap)), ""); 385*a061d4d5SA. Jiang static_assert(noexcept(cf(ap)), ""); 386*a061d4d5SA. Jiang #endif 387*a061d4d5SA. Jiang } 388*a061d4d5SA. Jiang 389*a061d4d5SA. Jiang template <class F> 390*a061d4d5SA. Jiang void test_volatile_noexcept_fun1(F f) { 391*a061d4d5SA. Jiang A a = {}; 392*a061d4d5SA. Jiang assert(f(a, 1) == 'e'); 393*a061d4d5SA. Jiang A* ap = &a; 394*a061d4d5SA. Jiang assert(f(ap, 2) == 'e'); 395*a061d4d5SA. Jiang volatile A* cap = &a; 396*a061d4d5SA. Jiang assert(f(cap, 2) == 'e'); 397*a061d4d5SA. Jiang const F& cf = f; 398*a061d4d5SA. Jiang assert(cf(ap, 2) == 'e'); 399*a061d4d5SA. Jiang 400*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 401*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0)), ""); 402*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1)), ""); 403*a061d4d5SA. Jiang static_assert(noexcept(f(cap, 2)), ""); 404*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 3)), ""); 405*a061d4d5SA. Jiang #endif 406*a061d4d5SA. Jiang } 407*a061d4d5SA. Jiang 408*a061d4d5SA. Jiang template <class F> 409*a061d4d5SA. Jiang void test_volatile_noexcept_fun2(F f) { 410*a061d4d5SA. Jiang A a = {}; 411*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'f'); 412*a061d4d5SA. Jiang A* ap = &a; 413*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'f'); 414*a061d4d5SA. Jiang volatile A* cap = &a; 415*a061d4d5SA. Jiang assert(f(cap, 2, 3.5) == 'f'); 416*a061d4d5SA. Jiang const F& cf = f; 417*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'f'); 418*a061d4d5SA. Jiang 419*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 420*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0, 0.0)), ""); 421*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1, 2)), ""); 422*a061d4d5SA. Jiang static_assert(noexcept(f(cap, 2, 3.5)), ""); 423*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 3, 17.29)), ""); 424*a061d4d5SA. Jiang #endif 425*a061d4d5SA. Jiang } 426*a061d4d5SA. Jiang 427*a061d4d5SA. Jiang template <class F> 428*a061d4d5SA. Jiang void test_const_volatile_fun0(F f) { 429*a061d4d5SA. Jiang A a = {}; 430*a061d4d5SA. Jiang assert(f(a) == 'a'); 431*a061d4d5SA. Jiang A* ap = &a; 432*a061d4d5SA. Jiang assert(f(ap) == 'a'); 433*a061d4d5SA. Jiang const volatile A* cap = &a; 434*a061d4d5SA. Jiang assert(f(cap) == 'a'); 435*a061d4d5SA. Jiang const F& cf = f; 436*a061d4d5SA. Jiang assert(cf(ap) == 'a'); 437*a061d4d5SA. Jiang 438*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 439*a061d4d5SA. Jiang static_assert(!noexcept(f(a)), ""); 440*a061d4d5SA. Jiang static_assert(!noexcept(f(ap)), ""); 441*a061d4d5SA. Jiang static_assert(!noexcept(f(cap)), ""); 442*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap)), ""); 443*a061d4d5SA. Jiang #endif 444*a061d4d5SA. Jiang } 445*a061d4d5SA. Jiang 446*a061d4d5SA. Jiang template <class F> 447*a061d4d5SA. Jiang void test_const_volatile_fun1(F f) { 448*a061d4d5SA. Jiang A a = {}; 449*a061d4d5SA. Jiang assert(f(a, 1) == 'b'); 450*a061d4d5SA. Jiang A* ap = &a; 451*a061d4d5SA. Jiang assert(f(ap, 2) == 'b'); 452*a061d4d5SA. Jiang const volatile A* cap = &a; 453*a061d4d5SA. Jiang assert(f(cap, 2) == 'b'); 454*a061d4d5SA. Jiang const F& cf = f; 455*a061d4d5SA. Jiang assert(cf(ap, 2) == 'b'); 456*a061d4d5SA. Jiang 457*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 458*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0)), ""); 459*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1)), ""); 460*a061d4d5SA. Jiang static_assert(!noexcept(f(cap, 2)), ""); 461*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 3)), ""); 462*a061d4d5SA. Jiang #endif 463*a061d4d5SA. Jiang } 464*a061d4d5SA. Jiang 465*a061d4d5SA. Jiang template <class F> 466*a061d4d5SA. Jiang void test_const_volatile_fun2(F f) { 467*a061d4d5SA. Jiang A a = {}; 468*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'c'); 469*a061d4d5SA. Jiang A* ap = &a; 470*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'c'); 471*a061d4d5SA. Jiang const volatile A* cap = &a; 472*a061d4d5SA. Jiang assert(f(cap, 2, 3.5) == 'c'); 473*a061d4d5SA. Jiang const F& cf = f; 474*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'c'); 475*a061d4d5SA. Jiang 476*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 477*a061d4d5SA. Jiang static_assert(!noexcept(f(a, 0, 0.0)), ""); 478*a061d4d5SA. Jiang static_assert(!noexcept(f(ap, 1, 2)), ""); 479*a061d4d5SA. Jiang static_assert(!noexcept(f(cap, 2, 3.5)), ""); 480*a061d4d5SA. Jiang static_assert(!noexcept(cf(ap, 3, 17.29)), ""); 481*a061d4d5SA. Jiang #endif 482*a061d4d5SA. Jiang } 483*a061d4d5SA. Jiang 484*a061d4d5SA. Jiang template <class F> 485*a061d4d5SA. Jiang void test_const_volatile_noexcept_fun0(F f) { 486*a061d4d5SA. Jiang A a = {}; 487*a061d4d5SA. Jiang assert(f(a) == 'd'); 488*a061d4d5SA. Jiang A* ap = &a; 489*a061d4d5SA. Jiang assert(f(ap) == 'd'); 490*a061d4d5SA. Jiang const volatile A* cap = &a; 491*a061d4d5SA. Jiang assert(f(cap) == 'd'); 492*a061d4d5SA. Jiang const F& cf = f; 493*a061d4d5SA. Jiang assert(cf(ap) == 'd'); 494*a061d4d5SA. Jiang 495*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 496*a061d4d5SA. Jiang static_assert(noexcept(f(a)), ""); 497*a061d4d5SA. Jiang static_assert(noexcept(f(ap)), ""); 498*a061d4d5SA. Jiang static_assert(noexcept(f(cap)), ""); 499*a061d4d5SA. Jiang static_assert(noexcept(cf(ap)), ""); 500*a061d4d5SA. Jiang #endif 501*a061d4d5SA. Jiang } 502*a061d4d5SA. Jiang 503*a061d4d5SA. Jiang template <class F> 504*a061d4d5SA. Jiang void test_const_volatile_noexcept_fun1(F f) { 505*a061d4d5SA. Jiang A a = {}; 506*a061d4d5SA. Jiang assert(f(a, 1) == 'e'); 507*a061d4d5SA. Jiang A* ap = &a; 508*a061d4d5SA. Jiang assert(f(ap, 2) == 'e'); 509*a061d4d5SA. Jiang const volatile A* cap = &a; 510*a061d4d5SA. Jiang assert(f(cap, 2) == 'e'); 511*a061d4d5SA. Jiang const F& cf = f; 512*a061d4d5SA. Jiang assert(cf(ap, 2) == 'e'); 513*a061d4d5SA. Jiang 514*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 515*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0)), ""); 516*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1)), ""); 517*a061d4d5SA. Jiang static_assert(noexcept(f(cap, 2)), ""); 518*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 3)), ""); 519*a061d4d5SA. Jiang #endif 520*a061d4d5SA. Jiang } 521*a061d4d5SA. Jiang 522*a061d4d5SA. Jiang template <class F> 523*a061d4d5SA. Jiang void test_const_volatile_noexcept_fun2(F f) { 524*a061d4d5SA. Jiang A a = {}; 525*a061d4d5SA. Jiang assert(f(a, 1, 2) == 'f'); 526*a061d4d5SA. Jiang A* ap = &a; 527*a061d4d5SA. Jiang assert(f(ap, 2, 3.5) == 'f'); 528*a061d4d5SA. Jiang const volatile A* cap = &a; 529*a061d4d5SA. Jiang assert(f(cap, 2, 3.5) == 'f'); 530*a061d4d5SA. Jiang const F& cf = f; 531*a061d4d5SA. Jiang assert(cf(ap, 2, 3.5) == 'f'); 532*a061d4d5SA. Jiang 533*a061d4d5SA. Jiang #if TEST_STD_VER >= 17 534*a061d4d5SA. Jiang static_assert(noexcept(f(a, 0, 0.0)), ""); 535*a061d4d5SA. Jiang static_assert(noexcept(f(ap, 1, 2)), ""); 536*a061d4d5SA. Jiang static_assert(noexcept(f(cap, 2, 3.5)), ""); 537*a061d4d5SA. Jiang static_assert(noexcept(cf(ap, 3, 17.29)), ""); 538*a061d4d5SA. Jiang #endif 539*a061d4d5SA. Jiang } 540*a061d4d5SA. Jiang 541*a061d4d5SA. Jiang #if TEST_STD_VER >= 11 542*a061d4d5SA. Jiang template <class V, class Func, class... Args> 543*a061d4d5SA. Jiang struct is_callable_impl : std::false_type {}; 544*a061d4d5SA. Jiang 545*a061d4d5SA. Jiang template <class Func, class... Args> 546*a061d4d5SA. Jiang struct is_callable_impl<decltype((void)std::declval<Func>()(std::declval<Args>()...)), Func, Args...> : std::true_type { 547*a061d4d5SA. Jiang }; 548*a061d4d5SA. Jiang 549*a061d4d5SA. Jiang template <class Func, class... Args> 550*a061d4d5SA. Jiang struct is_callable : is_callable_impl<void, Func, Args...>::type {}; 551*a061d4d5SA. Jiang 552*a061d4d5SA. Jiang template <class F> 553*a061d4d5SA. Jiang void test_sfinae_data(F) { 554*a061d4d5SA. Jiang static_assert(is_callable<F, A>::value, ""); 555*a061d4d5SA. Jiang static_assert(is_callable<F, const A>::value, ""); 556*a061d4d5SA. Jiang static_assert(is_callable<F, A&>::value, ""); 557*a061d4d5SA. Jiang static_assert(is_callable<F, const A&>::value, ""); 558*a061d4d5SA. Jiang static_assert(is_callable<F, A*>::value, ""); 559*a061d4d5SA. Jiang static_assert(is_callable<F, const A*>::value, ""); 560*a061d4d5SA. Jiang 561*a061d4d5SA. Jiang static_assert(!is_callable<F, A, char>::value, ""); 562*a061d4d5SA. Jiang static_assert(!is_callable<F, const A, char>::value, ""); 563*a061d4d5SA. Jiang static_assert(!is_callable<F, A&, char>::value, ""); 564*a061d4d5SA. Jiang static_assert(!is_callable<F, const A&, char>::value, ""); 565*a061d4d5SA. Jiang static_assert(!is_callable<F, A*, char>::value, ""); 566*a061d4d5SA. Jiang static_assert(!is_callable<F, const A*, char>::value, ""); 567*a061d4d5SA. Jiang } 568*a061d4d5SA. Jiang 569*a061d4d5SA. Jiang template <class F> 570*a061d4d5SA. Jiang void test_sfinae_fun0(F) { 571*a061d4d5SA. Jiang static_assert(is_callable<F, A>::value, ""); 572*a061d4d5SA. Jiang static_assert(is_callable<F, A&>::value, ""); 573*a061d4d5SA. Jiang static_assert(is_callable<F, A*>::value, ""); 574*a061d4d5SA. Jiang 575*a061d4d5SA. Jiang static_assert(!is_callable<F, const A>::value, ""); 576*a061d4d5SA. Jiang static_assert(!is_callable<F, const A&>::value, ""); 577*a061d4d5SA. Jiang static_assert(!is_callable<F, const A*>::value, ""); 578*a061d4d5SA. Jiang 579*a061d4d5SA. Jiang static_assert(!is_callable<F, volatile A>::value, ""); 580*a061d4d5SA. Jiang static_assert(!is_callable<F, volatile A&>::value, ""); 581*a061d4d5SA. Jiang static_assert(!is_callable<F, volatile A*>::value, ""); 582*a061d4d5SA. Jiang 583*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A>::value, ""); 584*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A&>::value, ""); 585*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A*>::value, ""); 586*a061d4d5SA. Jiang 587*a061d4d5SA. Jiang static_assert(!is_callable<F, A, int>::value, ""); 588*a061d4d5SA. Jiang static_assert(!is_callable<F, A&, int>::value, ""); 589*a061d4d5SA. Jiang static_assert(!is_callable<F, A*, int>::value, ""); 590*a061d4d5SA. Jiang } 591*a061d4d5SA. Jiang 592*a061d4d5SA. Jiang template <class F> 593*a061d4d5SA. Jiang void test_sfinae_fun1(F) { 594*a061d4d5SA. Jiang static_assert(is_callable<F, A, int>::value, ""); 595*a061d4d5SA. Jiang static_assert(is_callable<F, A&, int>::value, ""); 596*a061d4d5SA. Jiang static_assert(is_callable<F, A*, int>::value, ""); 597*a061d4d5SA. Jiang 598*a061d4d5SA. Jiang static_assert(!is_callable<F, A>::value, ""); 599*a061d4d5SA. Jiang static_assert(!is_callable<F, A&>::value, ""); 600*a061d4d5SA. Jiang static_assert(!is_callable<F, A*>::value, ""); 601*a061d4d5SA. Jiang } 602*a061d4d5SA. Jiang 603*a061d4d5SA. Jiang template <class F> 604*a061d4d5SA. Jiang void test_sfinae_const_fun0(F) { 605*a061d4d5SA. Jiang static_assert(is_callable<F, A>::value, ""); 606*a061d4d5SA. Jiang static_assert(is_callable<F, A&>::value, ""); 607*a061d4d5SA. Jiang static_assert(is_callable<F, A*>::value, ""); 608*a061d4d5SA. Jiang 609*a061d4d5SA. Jiang static_assert(is_callable<F, const A>::value, ""); 610*a061d4d5SA. Jiang static_assert(is_callable<F, const A&>::value, ""); 611*a061d4d5SA. Jiang static_assert(is_callable<F, const A*>::value, ""); 612*a061d4d5SA. Jiang 613*a061d4d5SA. Jiang static_assert(!is_callable<F, volatile A>::value, ""); 614*a061d4d5SA. Jiang static_assert(!is_callable<F, volatile A&>::value, ""); 615*a061d4d5SA. Jiang static_assert(!is_callable<F, volatile A*>::value, ""); 616*a061d4d5SA. Jiang 617*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A>::value, ""); 618*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A&>::value, ""); 619*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A*>::value, ""); 620*a061d4d5SA. Jiang } 621*a061d4d5SA. Jiang 622*a061d4d5SA. Jiang template <class F> 623*a061d4d5SA. Jiang void test_sfinae_volatile_fun0(F) { 624*a061d4d5SA. Jiang static_assert(is_callable<F, A>::value, ""); 625*a061d4d5SA. Jiang static_assert(is_callable<F, A&>::value, ""); 626*a061d4d5SA. Jiang static_assert(is_callable<F, A*>::value, ""); 627*a061d4d5SA. Jiang 628*a061d4d5SA. Jiang static_assert(!is_callable<F, const A>::value, ""); 629*a061d4d5SA. Jiang static_assert(!is_callable<F, const A&>::value, ""); 630*a061d4d5SA. Jiang static_assert(!is_callable<F, const A*>::value, ""); 631*a061d4d5SA. Jiang 632*a061d4d5SA. Jiang static_assert(is_callable<F, volatile A>::value, ""); 633*a061d4d5SA. Jiang static_assert(is_callable<F, volatile A&>::value, ""); 634*a061d4d5SA. Jiang static_assert(is_callable<F, volatile A*>::value, ""); 635*a061d4d5SA. Jiang 636*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A>::value, ""); 637*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A&>::value, ""); 638*a061d4d5SA. Jiang static_assert(!is_callable<F, const volatile A*>::value, ""); 639*a061d4d5SA. Jiang } 640*a061d4d5SA. Jiang 641*a061d4d5SA. Jiang template <class F> 642*a061d4d5SA. Jiang void test_sfinae_const_volatile_fun0(F) { 643*a061d4d5SA. Jiang static_assert(is_callable<F, A>::value, ""); 644*a061d4d5SA. Jiang static_assert(is_callable<F, A&>::value, ""); 645*a061d4d5SA. Jiang static_assert(is_callable<F, A*>::value, ""); 646*a061d4d5SA. Jiang 647*a061d4d5SA. Jiang static_assert(is_callable<F, const A>::value, ""); 648*a061d4d5SA. Jiang static_assert(is_callable<F, const A&>::value, ""); 649*a061d4d5SA. Jiang static_assert(is_callable<F, const A*>::value, ""); 650*a061d4d5SA. Jiang 651*a061d4d5SA. Jiang static_assert(is_callable<F, volatile A>::value, ""); 652*a061d4d5SA. Jiang static_assert(is_callable<F, volatile A&>::value, ""); 653*a061d4d5SA. Jiang static_assert(is_callable<F, volatile A*>::value, ""); 654*a061d4d5SA. Jiang 655*a061d4d5SA. Jiang static_assert(is_callable<F, const volatile A>::value, ""); 656*a061d4d5SA. Jiang static_assert(is_callable<F, const volatile A&>::value, ""); 657*a061d4d5SA. Jiang static_assert(is_callable<F, const volatile A*>::value, ""); 658*a061d4d5SA. Jiang } 659*a061d4d5SA. Jiang #endif 660*a061d4d5SA. Jiang 661*a061d4d5SA. Jiang int main(int, char**) { 662*a061d4d5SA. Jiang test_data(std::mem_fn(&A::data_)); 663*a061d4d5SA. Jiang 664*a061d4d5SA. Jiang test_fun0(std::mem_fn(&A::test0)); 665*a061d4d5SA. Jiang test_fun1(std::mem_fn(&A::test1)); 666*a061d4d5SA. Jiang test_fun2(std::mem_fn(&A::test2)); 667*a061d4d5SA. Jiang 668*a061d4d5SA. Jiang test_noexcept_fun0(std::mem_fn(&A::test0_nothrow)); 669*a061d4d5SA. Jiang test_noexcept_fun1(std::mem_fn(&A::test1_nothrow)); 670*a061d4d5SA. Jiang test_noexcept_fun2(std::mem_fn(&A::test2_nothrow)); 671*a061d4d5SA. Jiang 672*a061d4d5SA. Jiang test_const_fun0(std::mem_fn(&A::test_c0)); 673*a061d4d5SA. Jiang test_const_fun1(std::mem_fn(&A::test_c1)); 674*a061d4d5SA. Jiang test_const_fun2(std::mem_fn(&A::test_c2)); 675*a061d4d5SA. Jiang 676*a061d4d5SA. Jiang test_const_noexcept_fun0(std::mem_fn(&A::test_c0_nothrow)); 677*a061d4d5SA. Jiang test_const_noexcept_fun1(std::mem_fn(&A::test_c1_nothrow)); 678*a061d4d5SA. Jiang test_const_noexcept_fun2(std::mem_fn(&A::test_c2_nothrow)); 679*a061d4d5SA. Jiang 680*a061d4d5SA. Jiang test_volatile_fun0(std::mem_fn(&A::test_v0)); 681*a061d4d5SA. Jiang test_volatile_fun1(std::mem_fn(&A::test_v1)); 682*a061d4d5SA. Jiang test_volatile_fun2(std::mem_fn(&A::test_v2)); 683*a061d4d5SA. Jiang 684*a061d4d5SA. Jiang test_volatile_noexcept_fun0(std::mem_fn(&A::test_v0_nothrow)); 685*a061d4d5SA. Jiang test_volatile_noexcept_fun1(std::mem_fn(&A::test_v1_nothrow)); 686*a061d4d5SA. Jiang test_volatile_noexcept_fun2(std::mem_fn(&A::test_v2_nothrow)); 687*a061d4d5SA. Jiang 688*a061d4d5SA. Jiang test_const_volatile_fun0(std::mem_fn(&A::test_cv0)); 689*a061d4d5SA. Jiang test_const_volatile_fun1(std::mem_fn(&A::test_cv1)); 690*a061d4d5SA. Jiang test_const_volatile_fun2(std::mem_fn(&A::test_cv2)); 691*a061d4d5SA. Jiang 692*a061d4d5SA. Jiang test_const_volatile_noexcept_fun0(std::mem_fn(&A::test_cv0_nothrow)); 693*a061d4d5SA. Jiang test_const_volatile_noexcept_fun1(std::mem_fn(&A::test_cv1_nothrow)); 694*a061d4d5SA. Jiang test_const_volatile_noexcept_fun2(std::mem_fn(&A::test_cv2_nothrow)); 695*a061d4d5SA. Jiang 696*a061d4d5SA. Jiang #if TEST_STD_VER >= 11 697*a061d4d5SA. Jiang // LWG2489 698*a061d4d5SA. Jiang static_assert((noexcept(std::mem_fn(&A::data_))), ""); 699*a061d4d5SA. Jiang static_assert((noexcept(std::mem_fn(&A::test0))), ""); 700*a061d4d5SA. Jiang static_assert((noexcept(std::mem_fn(&A::test0_nothrow))), ""); 701*a061d4d5SA. Jiang 702*a061d4d5SA. Jiang test_sfinae_data(std::mem_fn(&A::data_)); 703*a061d4d5SA. Jiang 704*a061d4d5SA. Jiang test_sfinae_fun0(std::mem_fn(&A::test0)); 705*a061d4d5SA. Jiang test_sfinae_fun0(std::mem_fn(&A::test0_nothrow)); 706*a061d4d5SA. Jiang 707*a061d4d5SA. Jiang test_sfinae_const_fun0(std::mem_fn(&A::test_c0)); 708*a061d4d5SA. Jiang test_sfinae_const_fun0(std::mem_fn(&A::test_c0_nothrow)); 709*a061d4d5SA. Jiang 710*a061d4d5SA. Jiang test_sfinae_volatile_fun0(std::mem_fn(&A::test_v0)); 711*a061d4d5SA. Jiang test_sfinae_volatile_fun0(std::mem_fn(&A::test_v0_nothrow)); 712*a061d4d5SA. Jiang 713*a061d4d5SA. Jiang test_sfinae_const_volatile_fun0(std::mem_fn(&A::test_cv0)); 714*a061d4d5SA. Jiang test_sfinae_const_volatile_fun0(std::mem_fn(&A::test_cv0_nothrow)); 715*a061d4d5SA. Jiang 716*a061d4d5SA. Jiang test_sfinae_fun1(std::mem_fn(&A::test1)); 717*a061d4d5SA. Jiang test_sfinae_fun1(std::mem_fn(&A::test1_nothrow)); 718*a061d4d5SA. Jiang #endif 719*a061d4d5SA. Jiang 720*a061d4d5SA. Jiang #if TEST_STD_VER >= 20 721*a061d4d5SA. Jiang static_assert(test_data(std::mem_fn(&A::data_))); 722*a061d4d5SA. Jiang 723*a061d4d5SA. Jiang static_assert(test_fun0(std::mem_fn(&A::test0))); 724*a061d4d5SA. Jiang static_assert(test_fun1(std::mem_fn(&A::test1))); 725*a061d4d5SA. Jiang static_assert(test_fun2(std::mem_fn(&A::test2))); 726*a061d4d5SA. Jiang 727*a061d4d5SA. Jiang static_assert(test_const_fun0(std::mem_fn(&A::test_c0))); 728*a061d4d5SA. Jiang static_assert(test_const_fun1(std::mem_fn(&A::test_c1))); 729*a061d4d5SA. Jiang static_assert(test_const_fun2(std::mem_fn(&A::test_c2))); 730*a061d4d5SA. Jiang 731*a061d4d5SA. Jiang static_assert(test_noexcept_fun0(std::mem_fn(&A::test0_nothrow))); 732*a061d4d5SA. Jiang static_assert(test_noexcept_fun1(std::mem_fn(&A::test1_nothrow))); 733*a061d4d5SA. Jiang static_assert(test_noexcept_fun2(std::mem_fn(&A::test2_nothrow))); 734*a061d4d5SA. Jiang 735*a061d4d5SA. Jiang static_assert(test_const_noexcept_fun0(std::mem_fn(&A::test_c0_nothrow))); 736*a061d4d5SA. Jiang static_assert(test_const_noexcept_fun1(std::mem_fn(&A::test_c1_nothrow))); 737*a061d4d5SA. Jiang static_assert(test_const_noexcept_fun2(std::mem_fn(&A::test_c2_nothrow))); 738*a061d4d5SA. Jiang #endif 739*a061d4d5SA. Jiang 740*a061d4d5SA. Jiang return 0; 741*a061d4d5SA. Jiang } 742