types.pass.cpp revision 13858ee05627bba4d0e7609ff84ad71d8d7e3ca0
1//===----------------------------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is dual licensed under the MIT and the University of Illinois Open 6// Source Licenses. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10// UNSUPPORTED: c++98, c++03, c++11 11 12// <experimental/tuple> 13 14// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&) 15 16// Test function types. 17 18#include <experimental/tuple> 19#include <array> 20#include <utility> 21#include <cassert> 22 23namespace ex = std::experimental; 24 25int count = 0; 26 27void f_void_0() { ++count; } 28void f_void_1(int i) { count += i; } 29void f_void_2(int x, int y) { count += (x + y); } 30void f_void_3(int x, int y, int z) { count += (x + y + z); } 31 32int f_int_0() { return ++count; } 33int f_int_1(int x) { return count += x; } 34int f_int_2(int x, int y) { return count += (x + y); } 35int f_int_3(int x, int y, int z) { return count += (x + y + z); } 36 37struct A_void_0 38{ 39 A_void_0() {} 40 void operator()() { ++count; } 41 void operator()() const { ++count; ++count; } 42}; 43 44struct A_void_1 45{ 46 A_void_1() {} 47 void operator()(int x) { count += x; } 48 void operator()(int x) const { count += x + 1; } 49}; 50 51struct A_void_2 52{ 53 A_void_2() {} 54 void operator()(int x, int y) { count += (x + y); } 55 void operator()(int x, int y) const { count += (x + y) + 1; } 56}; 57 58struct A_void_3 59{ 60 A_void_3() {} 61 void operator()(int x, int y, int z) { count += (x + y + z); } 62 void operator()(int x, int y, int z) const { count += (x + y + z) + 1; } 63}; 64 65 66struct A_int_0 67{ 68 A_int_0() {} 69 int operator()() { return ++count; } 70 int operator()() const { ++count; return ++count; } 71}; 72 73struct A_int_1 74{ 75 A_int_1() {} 76 int operator()(int x) { return count += x; } 77 int operator()(int x) const { return count += (x + 1); } 78 79}; 80 81struct A_int_2 82{ 83 A_int_2() {} 84 int operator()(int x, int y) { return count += (x + y); } 85 int operator()(int x, int y) const { return count += (x + y + 1); } 86}; 87 88struct A_int_3 89{ 90 A_int_3() {} 91 int operator()(int x, int y, int z) { return count += (x + y + z); } 92 int operator()(int x, int y, int z) const { return count += (x + y + z + 1); } 93}; 94 95 96template <class Tuple> 97void test_void_0() 98{ 99 count = 0; 100 // function 101 { 102 Tuple t{}; 103 ex::apply(f_void_0, t); 104 assert(count == 1); 105 } 106 count = 0; 107 // function pointer 108 { 109 Tuple t{}; 110 auto fp = &f_void_0; 111 ex::apply(fp, t); 112 assert(count == 1); 113 } 114 count = 0; 115 // functor 116 { 117 Tuple t{}; 118 A_void_0 a; 119 ex::apply(a, t); 120 assert(count == 1); 121 } 122 count = 0; 123 // const functor 124 { 125 Tuple t{}; 126 A_void_0 const a; 127 ex::apply(a, t); 128 assert(count == 2); 129 } 130} 131 132template <class Tuple> 133void test_void_1() 134{ 135 count = 0; 136 // function 137 { 138 Tuple t{1}; 139 ex::apply(f_void_1, t); 140 assert(count == 1); 141 } 142 count = 0; 143 // function pointer 144 { 145 Tuple t{2}; 146 void (*fp)(int) = f_void_1; 147 ex::apply(fp, t); 148 assert(count == 2); 149 } 150 count = 0; 151 // functor 152 { 153 Tuple t{3}; 154 A_void_1 fn; 155 ex::apply(fn, t); 156 assert(count == 3); 157 } 158 count = 0; 159 // const functor 160 { 161 Tuple t{4}; 162 A_void_1 const a; 163 ex::apply(a, t); 164 assert(count == 5); 165 } 166} 167 168template <class Tuple> 169void test_void_2() 170{ 171 count = 0; 172 // function 173 { 174 Tuple t{1, 2}; 175 ex::apply(f_void_2, t); 176 assert(count == 3); 177 } 178 count = 0; 179 // function pointer 180 { 181 Tuple t{2, 3}; 182 auto fp = &f_void_2; 183 ex::apply(fp, t); 184 assert(count == 5); 185 } 186 count = 0; 187 // functor 188 { 189 Tuple t{3, 4}; 190 A_void_2 a; 191 ex::apply(a, t); 192 assert(count == 7); 193 } 194 count = 0; 195 // const functor 196 { 197 Tuple t{4, 5}; 198 A_void_2 const a; 199 ex::apply(a, t); 200 assert(count == 10); 201 } 202} 203 204template <class Tuple> 205void test_void_3() 206{ 207 count = 0; 208 // function 209 { 210 Tuple t{1, 2, 3}; 211 ex::apply(f_void_3, t); 212 assert(count == 6); 213 } 214 count = 0; 215 // function pointer 216 { 217 Tuple t{2, 3, 4}; 218 auto fp = &f_void_3; 219 ex::apply(fp, t); 220 assert(count == 9); 221 } 222 count = 0; 223 // functor 224 { 225 Tuple t{3, 4, 5}; 226 A_void_3 a; 227 ex::apply(a, t); 228 assert(count == 12); 229 } 230 count = 0; 231 // const functor 232 { 233 Tuple t{4, 5, 6}; 234 A_void_3 const a; 235 ex::apply(a, t); 236 assert(count == 16); 237 } 238} 239 240 241 242template <class Tuple> 243void test_int_0() 244{ 245 count = 0; 246 // function 247 { 248 Tuple t{}; 249 assert(1 == ex::apply(f_int_0, t)); 250 assert(count == 1); 251 } 252 count = 0; 253 // function pointer 254 { 255 Tuple t{}; 256 auto fp = &f_int_0; 257 assert(1 == ex::apply(fp, t)); 258 assert(count == 1); 259 } 260 count = 0; 261 // functor 262 { 263 Tuple t{}; 264 A_int_0 a; 265 assert(1 == ex::apply(a, t)); 266 assert(count == 1); 267 } 268 count = 0; 269 // const functor 270 { 271 Tuple t{}; 272 A_int_0 const a; 273 assert(2 == ex::apply(a, t)); 274 assert(count == 2); 275 } 276} 277 278template <class Tuple> 279void test_int_1() 280{ 281 count = 0; 282 // function 283 { 284 Tuple t{1}; 285 assert(1 == ex::apply(f_int_1, t)); 286 assert(count == 1); 287 } 288 count = 0; 289 // function pointer 290 { 291 Tuple t{2}; 292 int (*fp)(int) = f_int_1; 293 assert(2 == ex::apply(fp, t)); 294 assert(count == 2); 295 } 296 count = 0; 297 // functor 298 { 299 Tuple t{3}; 300 A_int_1 fn; 301 assert(3 == ex::apply(fn, t)); 302 assert(count == 3); 303 } 304 count = 0; 305 // const functor 306 { 307 Tuple t{4}; 308 A_int_1 const a; 309 assert(5 == ex::apply(a, t)); 310 assert(count == 5); 311 } 312} 313 314template <class Tuple> 315void test_int_2() 316{ 317 count = 0; 318 // function 319 { 320 Tuple t{1, 2}; 321 assert(3 == ex::apply(f_int_2, t)); 322 assert(count == 3); 323 } 324 count = 0; 325 // function pointer 326 { 327 Tuple t{2, 3}; 328 auto fp = &f_int_2; 329 assert(5 == ex::apply(fp, t)); 330 assert(count == 5); 331 } 332 count = 0; 333 // functor 334 { 335 Tuple t{3, 4}; 336 A_int_2 a; 337 assert(7 == ex::apply(a, t)); 338 assert(count == 7); 339 } 340 count = 0; 341 // const functor 342 { 343 Tuple t{4, 5}; 344 A_int_2 const a; 345 assert(10 == ex::apply(a, t)); 346 assert(count == 10); 347 } 348} 349 350template <class Tuple> 351void test_int_3() 352{ 353 count = 0; 354 // function 355 { 356 Tuple t{1, 2, 3}; 357 assert(6 == ex::apply(f_int_3, t)); 358 assert(count == 6); 359 } 360 count = 0; 361 // function pointer 362 { 363 Tuple t{2, 3, 4}; 364 auto fp = &f_int_3; 365 assert(9 == ex::apply(fp, t)); 366 assert(count == 9); 367 } 368 count = 0; 369 // functor 370 { 371 Tuple t{3, 4, 5}; 372 A_int_3 a; 373 assert(12 == ex::apply(a, t)); 374 assert(count == 12); 375 } 376 count = 0; 377 // const functor 378 { 379 Tuple t{4, 5, 6}; 380 A_int_3 const a; 381 assert(16 == ex::apply(a, t)); 382 assert(count == 16); 383 } 384} 385 386template <class Tuple> 387void test_0() 388{ 389 test_void_0<Tuple>(); 390 test_int_0<Tuple>(); 391} 392 393template <class Tuple> 394void test_1() 395{ 396 test_void_1<Tuple>(); 397 test_int_1<Tuple>(); 398} 399 400template <class Tuple> 401void test_2() 402{ 403 test_void_2<Tuple>(); 404 test_int_2<Tuple>(); 405} 406 407template <class Tuple> 408void test_3() 409{ 410 test_void_3<Tuple>(); 411 test_int_3<Tuple>(); 412} 413 414int main() 415{ 416 test_0<std::tuple<>>(); 417 418 test_1<std::tuple<int>>(); 419 test_1<std::array<int, 1>>(); 420 421 test_2<std::tuple<int, int>>(); 422 test_2<std::pair<int, int>>(); 423 test_2<std::array<int, 2>>(); 424 425 test_3<std::tuple<int, int, int>>(); 426 test_3<std::array<int, 3>>(); 427} 428