xref: /llvm-project/libcxx/test/std/utilities/function.objects/func.memfn/mem_fn.pass.cpp (revision a061d4d5cedf8f4651a01ea2e8cf98bd8863bf0f)
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