gcc/testsuite/g++.dg/cpp0x/rv5p.C

   1 // I, Howard Hinnant, hereby place this code in the public domain.
   2
   3 // Test overload resolution among reference types
   4
   5 // { dg-do compile }
   6 // { dg-options "-std=c++0x" }
   7
   8 template <bool> struct sa;
   9 template <> struct sa<true> {};
  10
  11 struct one   {char x[1];};
  12 struct two   {char x[2];};
  13 struct three {char x[3];};
  14 struct four  {char x[4];};
  15 struct five  {char x[5];};
  16 struct six   {char x[6];};
  17 struct seven {char x[7];};
  18 struct eight {char x[8];};
  19
  20 struct A
  21 {
  22     A();
  23     A(const volatile A&&);
  24 };
  25
  26                A    source();
  27 const          A  c_source();
  28       volatile A  v_source();
  29 const volatile A cv_source();
  30
  31 // 5 at a time
  32
  33 one   sink_5_12345(               A&);
  34 two   sink_5_12345(const          A&);
  35 three sink_5_12345(volatile       A&);
  36 four  sink_5_12345(const volatile A&);
  37 five  sink_5_12345(               A&&);
  38
  39 int test5_12345()
  40 {
  41                    A a;
  42     const          A ca = a;
  43           volatile A va;
  44     const volatile A cva = a;
  45     sa<sizeof(sink_5_12345(a))           == 1> t1;
  46     sa<sizeof(sink_5_12345(ca))          == 2> t2;
  47     sa<sizeof(sink_5_12345(va))          == 3> t3;
  48     sa<sizeof(sink_5_12345(cva))         == 4> t4;
  49     sa<sizeof(sink_5_12345(source()))    == 5> t5;
  50     sa<sizeof(sink_5_12345(c_source()))  == 2> t6;
  51     return 0;
  52 }
  53
  54 one   sink_5_12346(               A&);
  55 two   sink_5_12346(const          A&);
  56 three sink_5_12346(volatile       A&);
  57 four  sink_5_12346(const volatile A&);
  58 six   sink_5_12346(const          A&&);
  59
  60 int test5_12346()
  61 {
  62                    A a;
  63     const          A ca = a;
  64           volatile A va;
  65     const volatile A cva = a;
  66     sa<sizeof(sink_5_12346(a))           == 1> t1;
  67     sa<sizeof(sink_5_12346(ca))          == 2> t2;
  68     sa<sizeof(sink_5_12346(va))          == 3> t3;
  69     sa<sizeof(sink_5_12346(cva))         == 4> t4;
  70     sa<sizeof(sink_5_12346(source()))    == 6> t5;
  71     sa<sizeof(sink_5_12346(c_source()))  == 6> t6;
  72     return 0;
  73 }
  74
  75 one   sink_5_12347(               A&);
  76 two   sink_5_12347(const          A&);
  77 three sink_5_12347(volatile       A&);
  78 four  sink_5_12347(const volatile A&);
  79 seven sink_5_12347(volatile       A&&);
  80
  81 int test5_12347()
  82 {
  83                    A a;
  84     const          A ca = a;
  85           volatile A va;
  86     const volatile A cva = a;
  87     sa<sizeof(sink_5_12347(a))           == 1> t1;
  88     sa<sizeof(sink_5_12347(ca))          == 2> t2;
  89     sa<sizeof(sink_5_12347(va))          == 3> t3;
  90     sa<sizeof(sink_5_12347(cva))         == 4> t4;
  91     sa<sizeof(sink_5_12347(source()))    == 7> t5;
  92     sa<sizeof(sink_5_12347(c_source()))  == 2> t6;
  93     sa<sizeof(sink_5_12347(v_source()))  == 7> t7;
  94     return 0;
  95 }
  96
  97 one   sink_5_12348(               A&);
  98 two   sink_5_12348(const          A&);
  99 three sink_5_12348(volatile       A&);
 100 four  sink_5_12348(const volatile A&);
 101 eight sink_5_12348(const volatile A&&);
 102
 103 int test5_12348()
 104 {
 105                    A a;
 106     const          A ca = a;
 107           volatile A va;
 108     const volatile A cva = a;
 109     sa<sizeof(sink_5_12348(a))           == 1> t1;
 110     sa<sizeof(sink_5_12348(ca))          == 2> t2;
 111     sa<sizeof(sink_5_12348(va))          == 3> t3;
 112     sa<sizeof(sink_5_12348(cva))         == 4> t4;
 113     sa<sizeof(sink_5_12348(source()))    == 8> t5;
 114     sa<sizeof(sink_5_12348(c_source()))  == 8> t6;
 115     sa<sizeof(sink_5_12348(v_source()))  == 8> t7;
 116     sa<sizeof(sink_5_12348(cv_source())) == 8> t8;
 117     return 0;
 118 }
 119
 120 one   sink_5_12356(               A&);
 121 two   sink_5_12356(const          A&);
 122 three sink_5_12356(volatile       A&);
 123 five  sink_5_12356(               A&&);
 124 six   sink_5_12356(const          A&&);
 125
 126 int test5_12356()
 127 {
 128                    A a;
 129     const          A ca = a;
 130           volatile A va;
 131     const volatile A cva = a;
 132     sa<sizeof(sink_5_12356(a))           == 1> t1;
 133     sa<sizeof(sink_5_12356(ca))          == 2> t2;
 134     sa<sizeof(sink_5_12356(va))          == 3> t3;
 135     sa<sizeof(sink_5_12356(source()))    == 5> t5;
 136     sa<sizeof(sink_5_12356(c_source()))  == 6> t6;
 137     return 0;
 138 }
 139
 140 one   sink_5_12357(               A&);
 141 two   sink_5_12357(const          A&);
 142 three sink_5_12357(volatile       A&);
 143 five  sink_5_12357(               A&&);
 144 seven sink_5_12357(volatile       A&&);
 145
 146 int test5_12357()
 147 {
 148                    A a;
 149     const          A ca = a;
 150           volatile A va;
 151     const volatile A cva = a;
 152     sa<sizeof(sink_5_12357(a))           == 1> t1;
 153     sa<sizeof(sink_5_12357(ca))          == 2> t2;
 154     sa<sizeof(sink_5_12357(va))          == 3> t3;
 155     sa<sizeof(sink_5_12357(source()))    == 5> t5;
 156     sa<sizeof(sink_5_12357(c_source()))  == 2> t6;
 157     sa<sizeof(sink_5_12357(v_source()))  == 7> t7;
 158     return 0;
 159 }
 160
 161 one   sink_5_12358(               A&);
 162 two   sink_5_12358(const          A&);
 163 three sink_5_12358(volatile       A&);
 164 five  sink_5_12358(               A&&);
 165 eight sink_5_12358(const volatile A&&);
 166
 167 int test5_12358()
 168 {
 169                    A a;
 170     const          A ca = a;
 171           volatile A va;
 172     const volatile A cva = a;
 173     sa<sizeof(sink_5_12358(a))           == 1> t1;
 174     sa<sizeof(sink_5_12358(ca))          == 2> t2;
 175     sa<sizeof(sink_5_12358(va))          == 3> t3;
 176     sa<sizeof(sink_5_12358(source()))    == 5> t5;
 177     sa<sizeof(sink_5_12358(c_source()))  == 8> t6;
 178     sa<sizeof(sink_5_12358(v_source()))  == 8> t7;
 179     sa<sizeof(sink_5_12358(cv_source())) == 8> t8;
 180     return 0;
 181 }
 182
 183 one   sink_5_12367(               A&);
 184 two   sink_5_12367(const          A&);
 185 three sink_5_12367(volatile       A&);
 186 six   sink_5_12367(const          A&&);
 187 seven sink_5_12367(volatile       A&&);
 188
 189 int test5_12367()
 190 {
 191                    A a;
 192     const          A ca = a;
 193           volatile A va;
 194     const volatile A cva = a;
 195     sa<sizeof(sink_5_12367(a))           == 1> t1;
 196     sa<sizeof(sink_5_12367(ca))          == 2> t2;
 197     sa<sizeof(sink_5_12367(va))          == 3> t3;
 198     sa<sizeof(sink_5_12367(c_source()))  == 6> t6;
 199     sa<sizeof(sink_5_12367(v_source()))  == 7> t7;
 200     return 0;
 201 }
 202
 203 one   sink_5_12368(               A&);
 204 two   sink_5_12368(const          A&);
 205 three sink_5_12368(volatile       A&);
 206 six   sink_5_12368(const          A&&);
 207 eight sink_5_12368(const volatile A&&);
 208
 209 int test5_12368()
 210 {
 211                    A a;
 212     const          A ca = a;
 213           volatile A va;
 214     const volatile A cva = a;
 215     sa<sizeof(sink_5_12368(a))           == 1> t1;
 216     sa<sizeof(sink_5_12368(ca))          == 2> t2;
 217     sa<sizeof(sink_5_12368(va))          == 3> t3;
 218     sa<sizeof(sink_5_12368(source()))    == 6> t5;
 219     sa<sizeof(sink_5_12368(c_source()))  == 6> t6;
 220     sa<sizeof(sink_5_12368(v_source()))  == 8> t7;
 221     sa<sizeof(sink_5_12368(cv_source())) == 8> t8;
 222     return 0;
 223 }
 224
 225 one   sink_5_12378(               A&);
 226 two   sink_5_12378(const          A&);
 227 three sink_5_12378(volatile       A&);
 228 seven sink_5_12378(volatile       A&&);
 229 eight sink_5_12378(const volatile A&&);
 230
 231 int test5_12378()
 232 {
 233                    A a;
 234     const          A ca = a;
 235           volatile A va;
 236     const volatile A cva = a;
 237     sa<sizeof(sink_5_12378(a))           == 1> t1;
 238     sa<sizeof(sink_5_12378(ca))          == 2> t2;
 239     sa<sizeof(sink_5_12378(va))          == 3> t3;
 240     sa<sizeof(sink_5_12378(source()))    == 7> t5;
 241     sa<sizeof(sink_5_12378(c_source()))  == 8> t6;
 242     sa<sizeof(sink_5_12378(v_source()))  == 7> t7;
 243     sa<sizeof(sink_5_12378(cv_source())) == 8> t8;
 244     return 0;
 245 }
 246
 247 one   sink_5_12456(               A&);
 248 two   sink_5_12456(const          A&);
 249 four  sink_5_12456(const volatile A&);
 250 five  sink_5_12456(               A&&);
 251 six   sink_5_12456(const          A&&);
 252
 253 int test5_12456()
 254 {
 255                    A a;
 256     const          A ca = a;
 257           volatile A va;
 258     const volatile A cva = a;
 259     sa<sizeof(sink_5_12456(a))           == 1> t1;
 260     sa<sizeof(sink_5_12456(ca))          == 2> t2;
 261     sa<sizeof(sink_5_12456(va))          == 4> t3;
 262     sa<sizeof(sink_5_12456(cva))         == 4> t4;
 263     sa<sizeof(sink_5_12456(source()))    == 5> t5;
 264     sa<sizeof(sink_5_12456(c_source()))  == 6> t6;
 265     return 0;
 266 }
 267
 268 one   sink_5_12457(               A&);
 269 two   sink_5_12457(const          A&);
 270 four  sink_5_12457(const volatile A&);
 271 five  sink_5_12457(               A&&);
 272 seven sink_5_12457(volatile       A&&);
 273
 274 int test5_12457()
 275 {
 276                    A a;
 277     const          A ca = a;
 278           volatile A va;
 279     const volatile A cva = a;
 280     sa<sizeof(sink_5_12457(a))           == 1> t1;
 281     sa<sizeof(sink_5_12457(ca))          == 2> t2;
 282     sa<sizeof(sink_5_12457(va))          == 4> t3;
 283     sa<sizeof(sink_5_12457(cva))         == 4> t4;
 284     sa<sizeof(sink_5_12457(source()))    == 5> t5;
 285     sa<sizeof(sink_5_12457(c_source()))  == 2> t6;
 286     sa<sizeof(sink_5_12457(v_source()))  == 7> t7;
 287     return 0;
 288 }
 289
 290 one   sink_5_12458(               A&);
 291 two   sink_5_12458(const          A&);
 292 four  sink_5_12458(const volatile A&);
 293 five  sink_5_12458(               A&&);
 294 eight sink_5_12458(const volatile A&&);
 295
 296 int test5_12458()
 297 {
 298                    A a;
 299     const          A ca = a;
 300           volatile A va;
 301     const volatile A cva = a;
 302     sa<sizeof(sink_5_12458(a))           == 1> t1;
 303     sa<sizeof(sink_5_12458(ca))          == 2> t2;
 304     sa<sizeof(sink_5_12458(va))          == 4> t3;
 305     sa<sizeof(sink_5_12458(cva))         == 4> t4;
 306     sa<sizeof(sink_5_12458(source()))    == 5> t5;
 307     sa<sizeof(sink_5_12458(c_source()))  == 8> t6;
 308     sa<sizeof(sink_5_12458(v_source()))  == 8> t7;
 309     sa<sizeof(sink_5_12458(cv_source())) == 8> t8;
 310     return 0;
 311 }
 312
 313 one   sink_5_12467(               A&);
 314 two   sink_5_12467(const          A&);
 315 four  sink_5_12467(const volatile A&);
 316 six   sink_5_12467(const          A&&);
 317 seven sink_5_12467(volatile       A&&);
 318
 319 int test5_12467()
 320 {
 321                    A a;
 322     const          A ca = a;
 323           volatile A va;
 324     const volatile A cva = a;
 325     sa<sizeof(sink_5_12467(a))           == 1> t1;
 326     sa<sizeof(sink_5_12467(ca))          == 2> t2;
 327     sa<sizeof(sink_5_12467(va))          == 4> t3;
 328     sa<sizeof(sink_5_12467(cva))         == 4> t4;
 329     sa<sizeof(sink_5_12467(c_source()))  == 6> t6;
 330     sa<sizeof(sink_5_12467(v_source()))  == 7> t7;
 331     return 0;
 332 }
 333
 334 one   sink_5_12468(               A&);
 335 two   sink_5_12468(const          A&);
 336 four  sink_5_12468(const volatile A&);
 337 six   sink_5_12468(const          A&&);
 338 eight sink_5_12468(const volatile A&&);
 339
 340 int test5_12468()
 341 {
 342                    A a;
 343     const          A ca = a;
 344           volatile A va;
 345     const volatile A cva = a;
 346     sa<sizeof(sink_5_12468(a))           == 1> t1;
 347     sa<sizeof(sink_5_12468(ca))          == 2> t2;
 348     sa<sizeof(sink_5_12468(va))          == 4> t3;
 349     sa<sizeof(sink_5_12468(cva))         == 4> t4;
 350     sa<sizeof(sink_5_12468(source()))    == 6> t5;
 351     sa<sizeof(sink_5_12468(c_source()))  == 6> t6;
 352     sa<sizeof(sink_5_12468(v_source()))  == 8> t7;
 353     sa<sizeof(sink_5_12468(cv_source())) == 8> t8;
 354     return 0;
 355 }
 356
 357 one   sink_5_12478(               A&);
 358 two   sink_5_12478(const          A&);
 359 four  sink_5_12478(const volatile A&);
 360 seven sink_5_12478(volatile       A&&);
 361 eight sink_5_12478(const volatile A&&);
 362
 363 int test5_12478()
 364 {
 365                    A a;
 366     const          A ca = a;
 367           volatile A va;
 368     const volatile A cva = a;
 369     sa<sizeof(sink_5_12478(a))           == 1> t1;
 370     sa<sizeof(sink_5_12478(ca))          == 2> t2;
 371     sa<sizeof(sink_5_12478(va))          == 4> t3;
 372     sa<sizeof(sink_5_12478(cva))         == 4> t4;
 373     sa<sizeof(sink_5_12478(source()))    == 7> t5;
 374     sa<sizeof(sink_5_12478(c_source()))  == 8> t6;
 375     sa<sizeof(sink_5_12478(v_source()))  == 7> t7;
 376     sa<sizeof(sink_5_12478(cv_source())) == 8> t8;
 377     return 0;
 378 }
 379
 380 one   sink_5_12567(               A&);
 381 two   sink_5_12567(const          A&);
 382 five  sink_5_12567(               A&&);
 383 six   sink_5_12567(const          A&&);
 384 seven sink_5_12567(volatile       A&&);
 385
 386 int test5_12567()
 387 {
 388                    A a;
 389     const          A ca = a;
 390           volatile A va;
 391     const volatile A cva = a;
 392     sa<sizeof(sink_5_12567(a))           == 1> t1;
 393     sa<sizeof(sink_5_12567(ca))          == 2> t2;
 394     sa<sizeof(sink_5_12567(source()))    == 5> t5;
 395     sa<sizeof(sink_5_12567(c_source()))  == 6> t6;
 396     sa<sizeof(sink_5_12567(v_source()))  == 7> t7;
 397     return 0;
 398 }
 399
 400 one   sink_5_12568(               A&);
 401 two   sink_5_12568(const          A&);
 402 five  sink_5_12568(               A&&);
 403 six   sink_5_12568(const          A&&);
 404 eight sink_5_12568(const volatile A&&);
 405
 406 int test5_12568()
 407 {
 408                    A a;
 409     const          A ca = a;
 410           volatile A va;
 411     const volatile A cva = a;
 412     sa<sizeof(sink_5_12568(a))           == 1> t1;
 413     sa<sizeof(sink_5_12568(ca))          == 2> t2;
 414     sa<sizeof(sink_5_12568(source()))    == 5> t5;
 415     sa<sizeof(sink_5_12568(c_source()))  == 6> t6;
 416     sa<sizeof(sink_5_12568(v_source()))  == 8> t7;
 417     sa<sizeof(sink_5_12568(cv_source())) == 8> t8;
 418     return 0;
 419 }
 420
 421 one   sink_5_12578(               A&);
 422 two   sink_5_12578(const          A&);
 423 five  sink_5_12578(               A&&);
 424 seven sink_5_12578(volatile       A&&);
 425 eight sink_5_12578(const volatile A&&);
 426
 427 int test5_12578()
 428 {
 429                    A a;
 430     const          A ca = a;
 431           volatile A va;
 432     const volatile A cva = a;
 433     sa<sizeof(sink_5_12578(a))           == 1> t1;
 434     sa<sizeof(sink_5_12578(ca))          == 2> t2;
 435     sa<sizeof(sink_5_12578(source()))    == 5> t5;
 436     sa<sizeof(sink_5_12578(c_source()))  == 8> t6;
 437     sa<sizeof(sink_5_12578(v_source()))  == 7> t7;
 438     sa<sizeof(sink_5_12578(cv_source())) == 8> t8;
 439     return 0;
 440 }
 441
 442 one   sink_5_12678(               A&);
 443 two   sink_5_12678(const          A&);
 444 six   sink_5_12678(const          A&&);
 445 seven sink_5_12678(volatile       A&&);
 446 eight sink_5_12678(const volatile A&&);
 447
 448 int test5_12678()
 449 {
 450                    A a;
 451     const          A ca = a;
 452           volatile A va;
 453     const volatile A cva = a;
 454     sa<sizeof(sink_5_12678(a))           == 1> t1;
 455     sa<sizeof(sink_5_12678(ca))          == 2> t2;
 456     sa<sizeof(sink_5_12678(c_source()))  == 6> t6;
 457     sa<sizeof(sink_5_12678(v_source()))  == 7> t7;
 458     sa<sizeof(sink_5_12678(cv_source())) == 8> t8;
 459     return 0;
 460 }
 461
 462 one   sink_5_13456(               A&);
 463 three sink_5_13456(volatile       A&);
 464 four  sink_5_13456(const volatile A&);
 465 five  sink_5_13456(               A&&);
 466 six   sink_5_13456(const          A&&);
 467
 468 int test5_13456()
 469 {
 470                    A a;
 471     const          A ca = a;
 472           volatile A va;
 473     const volatile A cva = a;
 474     sa<sizeof(sink_5_13456(a))           == 1> t1;
 475     sa<sizeof(sink_5_13456(ca))          == 4> t2;
 476     sa<sizeof(sink_5_13456(va))          == 3> t3;
 477     sa<sizeof(sink_5_13456(cva))         == 4> t4;
 478     sa<sizeof(sink_5_13456(source()))    == 5> t5;
 479     sa<sizeof(sink_5_13456(c_source()))  == 6> t6;
 480     return 0;
 481 }
 482
 483 one   sink_5_13457(               A&);
 484 three sink_5_13457(volatile       A&);
 485 four  sink_5_13457(const volatile A&);
 486 five  sink_5_13457(               A&&);
 487 seven sink_5_13457(volatile       A&&);
 488
 489 int test5_13457()
 490 {
 491                    A a;
 492     const          A ca = a;
 493           volatile A va;
 494     const volatile A cva = a;
 495     sa<sizeof(sink_5_13457(a))           == 1> t1;
 496     sa<sizeof(sink_5_13457(ca))          == 4> t2;
 497     sa<sizeof(sink_5_13457(va))          == 3> t3;
 498     sa<sizeof(sink_5_13457(cva))         == 4> t4;
 499     sa<sizeof(sink_5_13457(source()))    == 5> t5;
 500     sa<sizeof(sink_5_13457(v_source()))  == 7> t7;
 501     return 0;
 502 }
 503
 504 one   sink_5_13458(               A&);
 505 three sink_5_13458(volatile       A&);
 506 four  sink_5_13458(const volatile A&);
 507 five  sink_5_13458(               A&&);
 508 eight sink_5_13458(const volatile A&&);
 509
 510 int test5_13458()
 511 {
 512                    A a;
 513     const          A ca = a;
 514           volatile A va;
 515     const volatile A cva = a;
 516     sa<sizeof(sink_5_13458(a))           == 1> t1;
 517     sa<sizeof(sink_5_13458(ca))          == 4> t2;
 518     sa<sizeof(sink_5_13458(va))          == 3> t3;
 519     sa<sizeof(sink_5_13458(cva))         == 4> t4;
 520     sa<sizeof(sink_5_13458(source()))    == 5> t5;
 521     sa<sizeof(sink_5_13458(c_source()))  == 8> t6;
 522     sa<sizeof(sink_5_13458(v_source()))  == 8> t7;
 523     sa<sizeof(sink_5_13458(cv_source())) == 8> t8;
 524     return 0;
 525 }
 526
 527 one   sink_5_13467(               A&);
 528 three sink_5_13467(volatile       A&);
 529 four  sink_5_13467(const volatile A&);
 530 six   sink_5_13467(const          A&&);
 531 seven sink_5_13467(volatile       A&&);
 532
 533 int test5_13467()
 534 {
 535                    A a;
 536     const          A ca = a;
 537           volatile A va;
 538     const volatile A cva = a;
 539     sa<sizeof(sink_5_13467(a))           == 1> t1;
 540     sa<sizeof(sink_5_13467(ca))          == 4> t2;
 541     sa<sizeof(sink_5_13467(va))          == 3> t3;
 542     sa<sizeof(sink_5_13467(cva))         == 4> t4;
 543     sa<sizeof(sink_5_13467(c_source()))  == 6> t6;
 544     sa<sizeof(sink_5_13467(v_source()))  == 7> t7;
 545     return 0;
 546 }
 547
 548 one   sink_5_13468(               A&);
 549 three sink_5_13468(volatile       A&);
 550 four  sink_5_13468(const volatile A&);
 551 six   sink_5_13468(const          A&&);
 552 eight sink_5_13468(const volatile A&&);
 553
 554 int test5_13468()
 555 {
 556                    A a;
 557     const          A ca = a;
 558           volatile A va;
 559     const volatile A cva = a;
 560     sa<sizeof(sink_5_13468(a))           == 1> t1;
 561     sa<sizeof(sink_5_13468(ca))          == 4> t2;
 562     sa<sizeof(sink_5_13468(va))          == 3> t3;
 563     sa<sizeof(sink_5_13468(cva))         == 4> t4;
 564     sa<sizeof(sink_5_13468(source()))    == 6> t5;
 565     sa<sizeof(sink_5_13468(c_source()))  == 6> t6;
 566     sa<sizeof(sink_5_13468(v_source()))  == 8> t7;
 567     sa<sizeof(sink_5_13468(cv_source())) == 8> t8;
 568     return 0;
 569 }
 570
 571 one   sink_5_13478(               A&);
 572 three sink_5_13478(volatile       A&);
 573 four  sink_5_13478(const volatile A&);
 574 seven sink_5_13478(volatile       A&&);
 575 eight sink_5_13478(const volatile A&&);
 576
 577 int test5_13478()
 578 {
 579                    A a;
 580     const          A ca = a;
 581           volatile A va;
 582     const volatile A cva = a;
 583     sa<sizeof(sink_5_13478(a))           == 1> t1;
 584     sa<sizeof(sink_5_13478(ca))          == 4> t2;
 585     sa<sizeof(sink_5_13478(va))          == 3> t3;
 586     sa<sizeof(sink_5_13478(cva))         == 4> t4;
 587     sa<sizeof(sink_5_13478(source()))    == 7> t5;
 588     sa<sizeof(sink_5_13478(c_source()))  == 8> t6;
 589     sa<sizeof(sink_5_13478(v_source()))  == 7> t7;
 590     sa<sizeof(sink_5_13478(cv_source())) == 8> t8;
 591     return 0;
 592 }
 593
 594 one   sink_5_13567(               A&);
 595 three sink_5_13567(volatile       A&);
 596 five  sink_5_13567(               A&&);
 597 six   sink_5_13567(const          A&&);
 598 seven sink_5_13567(volatile       A&&);
 599
 600 int test5_13567()
 601 {
 602                    A a;
 603     const          A ca = a;
 604           volatile A va;
 605     const volatile A cva = a;
 606     sa<sizeof(sink_5_13567(a))           == 1> t1;
 607     sa<sizeof(sink_5_13567(va))          == 3> t3;
 608     sa<sizeof(sink_5_13567(source()))    == 5> t5;
 609     sa<sizeof(sink_5_13567(c_source()))  == 6> t6;
 610     sa<sizeof(sink_5_13567(v_source()))  == 7> t7;
 611     return 0;
 612 }
 613
 614 one   sink_5_13568(               A&);
 615 three sink_5_13568(volatile       A&);
 616 five  sink_5_13568(               A&&);
 617 six   sink_5_13568(const          A&&);
 618 eight sink_5_13568(const volatile A&&);
 619
 620 int test5_13568()
 621 {
 622                    A a;
 623     const          A ca = a;
 624           volatile A va;
 625     const volatile A cva = a;
 626     sa<sizeof(sink_5_13568(a))           == 1> t1;
 627     sa<sizeof(sink_5_13568(va))          == 3> t3;
 628     sa<sizeof(sink_5_13568(source()))    == 5> t5;
 629     sa<sizeof(sink_5_13568(c_source()))  == 6> t6;
 630     sa<sizeof(sink_5_13568(v_source()))  == 8> t7;
 631     sa<sizeof(sink_5_13568(cv_source())) == 8> t8;
 632     return 0;
 633 }
 634
 635 one   sink_5_13578(               A&);
 636 three sink_5_13578(volatile       A&);
 637 five  sink_5_13578(               A&&);
 638 seven sink_5_13578(volatile       A&&);
 639 eight sink_5_13578(const volatile A&&);
 640
 641 int test5_13578()
 642 {
 643                    A a;
 644     const          A ca = a;
 645           volatile A va;
 646     const volatile A cva = a;
 647     sa<sizeof(sink_5_13578(a))           == 1> t1;
 648     sa<sizeof(sink_5_13578(va))          == 3> t3;
 649     sa<sizeof(sink_5_13578(source()))    == 5> t5;
 650     sa<sizeof(sink_5_13578(c_source()))  == 8> t6;
 651     sa<sizeof(sink_5_13578(v_source()))  == 7> t7;
 652     sa<sizeof(sink_5_13578(cv_source())) == 8> t8;
 653     return 0;
 654 }
 655
 656 one   sink_5_13678(               A&);
 657 three sink_5_13678(volatile       A&);
 658 six   sink_5_13678(const          A&&);
 659 seven sink_5_13678(volatile       A&&);
 660 eight sink_5_13678(const volatile A&&);
 661
 662 int test5_13678()
 663 {
 664                    A a;
 665     const          A ca = a;
 666           volatile A va;
 667     const volatile A cva = a;
 668     sa<sizeof(sink_5_13678(a))           == 1> t1;
 669     sa<sizeof(sink_5_13678(va))          == 3> t3;
 670     sa<sizeof(sink_5_13678(c_source()))  == 6> t6;
 671     sa<sizeof(sink_5_13678(v_source()))  == 7> t7;
 672     sa<sizeof(sink_5_13678(cv_source())) == 8> t8;
 673     return 0;
 674 }
 675
 676 one   sink_5_14567(               A&);
 677 four  sink_5_14567(const volatile A&);
 678 five  sink_5_14567(               A&&);
 679 six   sink_5_14567(const          A&&);
 680 seven sink_5_14567(volatile       A&&);
 681
 682 int test5_14567()
 683 {
 684                    A a;
 685     const          A ca = a;
 686           volatile A va;
 687     const volatile A cva = a;
 688     sa<sizeof(sink_5_14567(a))           == 1> t1;
 689     sa<sizeof(sink_5_14567(ca))          == 4> t2;
 690     sa<sizeof(sink_5_14567(va))          == 4> t3;
 691     sa<sizeof(sink_5_14567(cva))         == 4> t4;
 692     sa<sizeof(sink_5_14567(source()))    == 5> t5;
 693     sa<sizeof(sink_5_14567(c_source()))  == 6> t6;
 694     sa<sizeof(sink_5_14567(v_source()))  == 7> t7;
 695     return 0;
 696 }
 697
 698 one   sink_5_14568(               A&);
 699 four  sink_5_14568(const volatile A&);
 700 five  sink_5_14568(               A&&);
 701 six   sink_5_14568(const          A&&);
 702 eight sink_5_14568(const volatile A&&);
 703
 704 int test5_14568()
 705 {
 706                    A a;
 707     const          A ca = a;
 708           volatile A va;
 709     const volatile A cva = a;
 710     sa<sizeof(sink_5_14568(a))           == 1> t1;
 711     sa<sizeof(sink_5_14568(ca))          == 4> t2;
 712     sa<sizeof(sink_5_14568(va))          == 4> t3;
 713     sa<sizeof(sink_5_14568(cva))         == 4> t4;
 714     sa<sizeof(sink_5_14568(source()))    == 5> t5;
 715     sa<sizeof(sink_5_14568(c_source()))  == 6> t6;
 716     sa<sizeof(sink_5_14568(v_source()))  == 8> t7;
 717     sa<sizeof(sink_5_14568(cv_source())) == 8> t8;
 718     return 0;
 719 }
 720
 721 one   sink_5_14578(               A&);
 722 four  sink_5_14578(const volatile A&);
 723 five  sink_5_14578(               A&&);
 724 seven sink_5_14578(volatile       A&&);
 725 eight sink_5_14578(const volatile A&&);
 726
 727 int test5_14578()
 728 {
 729                    A a;
 730     const          A ca = a;
 731           volatile A va;
 732     const volatile A cva = a;
 733     sa<sizeof(sink_5_14578(a))           == 1> t1;
 734     sa<sizeof(sink_5_14578(ca))          == 4> t2;
 735     sa<sizeof(sink_5_14578(va))          == 4> t3;
 736     sa<sizeof(sink_5_14578(cva))         == 4> t4;
 737     sa<sizeof(sink_5_14578(source()))    == 5> t5;
 738     sa<sizeof(sink_5_14578(c_source()))  == 8> t6;
 739     sa<sizeof(sink_5_14578(v_source()))  == 7> t7;
 740     sa<sizeof(sink_5_14578(cv_source())) == 8> t8;
 741     return 0;
 742 }
 743
 744 one   sink_5_14678(               A&);
 745 four  sink_5_14678(const volatile A&);
 746 six   sink_5_14678(const          A&&);
 747 seven sink_5_14678(volatile       A&&);
 748 eight sink_5_14678(const volatile A&&);
 749
 750 int test5_14678()
 751 {
 752                    A a;
 753     const          A ca = a;
 754           volatile A va;
 755     const volatile A cva = a;
 756     sa<sizeof(sink_5_14678(a))           == 1> t1;
 757     sa<sizeof(sink_5_14678(ca))          == 4> t2;
 758     sa<sizeof(sink_5_14678(va))          == 4> t3;
 759     sa<sizeof(sink_5_14678(cva))         == 4> t4;
 760     sa<sizeof(sink_5_14678(c_source()))  == 6> t6;
 761     sa<sizeof(sink_5_14678(v_source()))  == 7> t7;
 762     sa<sizeof(sink_5_14678(cv_source())) == 8> t8;
 763     return 0;
 764 }
 765
 766 one   sink_5_15678(               A&);
 767 five  sink_5_15678(               A&&);
 768 six   sink_5_15678(const          A&&);
 769 seven sink_5_15678(volatile       A&&);
 770 eight sink_5_15678(const volatile A&&);
 771
 772 int test5_15678()
 773 {
 774                    A a;
 775     const          A ca = a;
 776           volatile A va;
 777     const volatile A cva = a;
 778     sa<sizeof(sink_5_15678(a))           == 1> t1;
 779     sa<sizeof(sink_5_15678(source()))    == 5> t5;
 780     sa<sizeof(sink_5_15678(c_source()))  == 6> t6;
 781     sa<sizeof(sink_5_15678(v_source()))  == 7> t7;
 782     sa<sizeof(sink_5_15678(cv_source())) == 8> t8;
 783     return 0;
 784 }
 785
 786 two   sink_5_23456(const          A&);
 787 three sink_5_23456(volatile       A&);
 788 four  sink_5_23456(const volatile A&);
 789 five  sink_5_23456(               A&&);
 790 six   sink_5_23456(const          A&&);
 791
 792 int test5_23456()
 793 {
 794                    A a;
 795     const          A ca = a;
 796           volatile A va;
 797     const volatile A cva = a;
 798     sa<sizeof(sink_5_23456(ca))          == 2> t2;
 799     sa<sizeof(sink_5_23456(va))          == 3> t3;
 800     sa<sizeof(sink_5_23456(cva))         == 4> t4;
 801     sa<sizeof(sink_5_23456(source()))    == 5> t5;
 802     sa<sizeof(sink_5_23456(c_source()))  == 6> t6;
 803     return 0;
 804 }
 805
 806 two   sink_5_23457(const          A&);
 807 three sink_5_23457(volatile       A&);
 808 four  sink_5_23457(const volatile A&);
 809 five  sink_5_23457(               A&&);
 810 seven sink_5_23457(volatile       A&&);
 811
 812 int test5_23457()
 813 {
 814                    A a;
 815     const          A ca = a;
 816           volatile A va;
 817     const volatile A cva = a;
 818     sa<sizeof(sink_5_23457(ca))          == 2> t2;
 819     sa<sizeof(sink_5_23457(va))          == 3> t3;
 820     sa<sizeof(sink_5_23457(cva))         == 4> t4;
 821     sa<sizeof(sink_5_23457(source()))    == 5> t5;
 822     sa<sizeof(sink_5_23457(c_source()))  == 2> t6;
 823     sa<sizeof(sink_5_23457(v_source()))  == 7> t7;
 824     return 0;
 825 }
 826
 827 two   sink_5_23458(const          A&);
 828 three sink_5_23458(volatile       A&);
 829 four  sink_5_23458(const volatile A&);
 830 five  sink_5_23458(               A&&);
 831 eight sink_5_23458(const volatile A&&);
 832
 833 int test5_23458()
 834 {
 835                    A a;
 836     const          A ca = a;
 837           volatile A va;
 838     const volatile A cva = a;
 839     sa<sizeof(sink_5_23458(ca))          == 2> t2;
 840     sa<sizeof(sink_5_23458(va))          == 3> t3;
 841     sa<sizeof(sink_5_23458(cva))         == 4> t4;
 842     sa<sizeof(sink_5_23458(source()))    == 5> t5;
 843     sa<sizeof(sink_5_23458(c_source()))  == 8> t6;
 844     sa<sizeof(sink_5_23458(v_source()))  == 8> t7;
 845     sa<sizeof(sink_5_23458(cv_source())) == 8> t8;
 846     return 0;
 847 }
 848
 849 two   sink_5_23467(const          A&);
 850 three sink_5_23467(volatile       A&);
 851 four  sink_5_23467(const volatile A&);
 852 six   sink_5_23467(const          A&&);
 853 seven sink_5_23467(volatile       A&&);
 854
 855 int test5_23467()
 856 {
 857                    A a;
 858     const          A ca = a;
 859           volatile A va;
 860     const volatile A cva = a;
 861     sa<sizeof(sink_5_23467(ca))          == 2> t2;
 862     sa<sizeof(sink_5_23467(va))          == 3> t3;
 863     sa<sizeof(sink_5_23467(cva))         == 4> t4;
 864     sa<sizeof(sink_5_23467(c_source()))  == 6> t6;
 865     sa<sizeof(sink_5_23467(v_source()))  == 7> t7;
 866     return 0;
 867 }
 868
 869 two   sink_5_23468(const          A&);
 870 three sink_5_23468(volatile       A&);
 871 four  sink_5_23468(const volatile A&);
 872 six   sink_5_23468(const          A&&);
 873 eight sink_5_23468(const volatile A&&);
 874
 875 int test5_23468()
 876 {
 877                    A a;
 878     const          A ca = a;
 879           volatile A va;
 880     const volatile A cva = a;
 881     sa<sizeof(sink_5_23468(ca))          == 2> t2;
 882     sa<sizeof(sink_5_23468(va))          == 3> t3;
 883     sa<sizeof(sink_5_23468(cva))         == 4> t4;
 884     sa<sizeof(sink_5_23468(source()))    == 6> t5;
 885     sa<sizeof(sink_5_23468(c_source()))  == 6> t6;
 886     sa<sizeof(sink_5_23468(v_source()))  == 8> t7;
 887     sa<sizeof(sink_5_23468(cv_source())) == 8> t8;
 888     return 0;
 889 }
 890
 891 two   sink_5_23478(const          A&);
 892 three sink_5_23478(volatile       A&);
 893 four  sink_5_23478(const volatile A&);
 894 seven sink_5_23478(volatile       A&&);
 895 eight sink_5_23478(const volatile A&&);
 896
 897 int test5_23478()
 898 {
 899                    A a;
 900     const          A ca = a;
 901           volatile A va;
 902     const volatile A cva = a;
 903     sa<sizeof(sink_5_23478(ca))          == 2> t2;
 904     sa<sizeof(sink_5_23478(va))          == 3> t3;
 905     sa<sizeof(sink_5_23478(cva))         == 4> t4;
 906     sa<sizeof(sink_5_23478(source()))    == 7> t5;
 907     sa<sizeof(sink_5_23478(c_source()))  == 8> t6;
 908     sa<sizeof(sink_5_23478(v_source()))  == 7> t7;
 909     sa<sizeof(sink_5_23478(cv_source())) == 8> t8;
 910     return 0;
 911 }
 912
 913 two   sink_5_23567(const          A&);
 914 three sink_5_23567(volatile       A&);
 915 five  sink_5_23567(               A&&);
 916 six   sink_5_23567(const          A&&);
 917 seven sink_5_23567(volatile       A&&);
 918
 919 int test5_23567()
 920 {
 921                    A a;
 922     const          A ca = a;
 923           volatile A va;
 924     const volatile A cva = a;
 925     sa<sizeof(sink_5_23567(ca))          == 2> t2;
 926     sa<sizeof(sink_5_23567(va))          == 3> t3;
 927     sa<sizeof(sink_5_23567(source()))    == 5> t5;
 928     sa<sizeof(sink_5_23567(c_source()))  == 6> t6;
 929     sa<sizeof(sink_5_23567(v_source()))  == 7> t7;
 930     return 0;
 931 }
 932
 933 two   sink_5_23568(const          A&);
 934 three sink_5_23568(volatile       A&);
 935 five  sink_5_23568(               A&&);
 936 six   sink_5_23568(const          A&&);
 937 eight sink_5_23568(const volatile A&&);
 938
 939 int test5_23568()
 940 {
 941                    A a;
 942     const          A ca = a;
 943           volatile A va;
 944     const volatile A cva = a;
 945     sa<sizeof(sink_5_23568(ca))          == 2> t2;
 946     sa<sizeof(sink_5_23568(va))          == 3> t3;
 947     sa<sizeof(sink_5_23568(source()))    == 5> t5;
 948     sa<sizeof(sink_5_23568(c_source()))  == 6> t6;
 949     sa<sizeof(sink_5_23568(v_source()))  == 8> t7;
 950     sa<sizeof(sink_5_23568(cv_source())) == 8> t8;
 951     return 0;
 952 }
 953
 954 two   sink_5_23578(const          A&);
 955 three sink_5_23578(volatile       A&);
 956 five  sink_5_23578(               A&&);
 957 seven sink_5_23578(volatile       A&&);
 958 eight sink_5_23578(const volatile A&&);
 959
 960 int test5_23578()
 961 {
 962                    A a;
 963     const          A ca = a;
 964           volatile A va;
 965     const volatile A cva = a;
 966     sa<sizeof(sink_5_23578(ca))          == 2> t2;
 967     sa<sizeof(sink_5_23578(va))          == 3> t3;
 968     sa<sizeof(sink_5_23578(source()))    == 5> t5;
 969     sa<sizeof(sink_5_23578(c_source()))  == 8> t6;
 970     sa<sizeof(sink_5_23578(v_source()))  == 7> t7;
 971     sa<sizeof(sink_5_23578(cv_source())) == 8> t8;
 972     return 0;
 973 }
 974
 975 two   sink_5_23678(const          A&);
 976 three sink_5_23678(volatile       A&);
 977 six   sink_5_23678(const          A&&);
 978 seven sink_5_23678(volatile       A&&);
 979 eight sink_5_23678(const volatile A&&);
 980
 981 int test5_23678()
 982 {
 983                    A a;
 984     const          A ca = a;
 985           volatile A va;
 986     const volatile A cva = a;
 987     sa<sizeof(sink_5_23678(ca))          == 2> t2;
 988     sa<sizeof(sink_5_23678(va))          == 3> t3;
 989     sa<sizeof(sink_5_23678(c_source()))  == 6> t6;
 990     sa<sizeof(sink_5_23678(v_source()))  == 7> t7;
 991     sa<sizeof(sink_5_23678(cv_source())) == 8> t8;
 992     return 0;
 993 }
 994
 995 two   sink_5_24567(const          A&);
 996 four  sink_5_24567(const volatile A&);
 997 five  sink_5_24567(               A&&);
 998 six   sink_5_24567(const          A&&);
 999 seven sink_5_24567(volatile       A&&);
1000
1001 int test5_24567()
1002 {
1003                    A a;
1004     const          A ca = a;
1005           volatile A va;
1006     const volatile A cva = a;
1007     sa<sizeof(sink_5_24567(a))           == 2> t1;
1008     sa<sizeof(sink_5_24567(ca))          == 2> t2;
1009     sa<sizeof(sink_5_24567(va))          == 4> t3;
1010     sa<sizeof(sink_5_24567(cva))         == 4> t4;
1011     sa<sizeof(sink_5_24567(source()))    == 5> t5;
1012     sa<sizeof(sink_5_24567(c_source()))  == 6> t6;
1013     sa<sizeof(sink_5_24567(v_source()))  == 7> t7;
1014     return 0;
1015 }
1016
1017 two   sink_5_24568(const          A&);
1018 four  sink_5_24568(const volatile A&);
1019 five  sink_5_24568(               A&&);
1020 six   sink_5_24568(const          A&&);
1021 eight sink_5_24568(const volatile A&&);
1022
1023 int test5_24568()
1024 {
1025                    A a;
1026     const          A ca = a;
1027           volatile A va;
1028     const volatile A cva = a;
1029     sa<sizeof(sink_5_24568(a))           == 2> t1;
1030     sa<sizeof(sink_5_24568(ca))          == 2> t2;
1031     sa<sizeof(sink_5_24568(va))          == 4> t3;
1032     sa<sizeof(sink_5_24568(cva))         == 4> t4;
1033     sa<sizeof(sink_5_24568(source()))    == 5> t5;
1034     sa<sizeof(sink_5_24568(c_source()))  == 6> t6;
1035     sa<sizeof(sink_5_24568(v_source()))  == 8> t7;
1036     sa<sizeof(sink_5_24568(cv_source())) == 8> t8;
1037     return 0;
1038 }
1039
1040 two   sink_5_24578(const          A&);
1041 four  sink_5_24578(const volatile A&);
1042 five  sink_5_24578(               A&&);
1043 seven sink_5_24578(volatile       A&&);
1044 eight sink_5_24578(const volatile A&&);
1045
1046 int test5_24578()
1047 {
1048                    A a;
1049     const          A ca = a;
1050           volatile A va;
1051     const volatile A cva = a;
1052     sa<sizeof(sink_5_24578(a))           == 2> t1;
1053     sa<sizeof(sink_5_24578(ca))          == 2> t2;
1054     sa<sizeof(sink_5_24578(va))          == 4> t3;
1055     sa<sizeof(sink_5_24578(cva))         == 4> t4;
1056     sa<sizeof(sink_5_24578(source()))    == 5> t5;
1057     sa<sizeof(sink_5_24578(c_source()))  == 8> t6;
1058     sa<sizeof(sink_5_24578(v_source()))  == 7> t7;
1059     sa<sizeof(sink_5_24578(cv_source())) == 8> t8;
1060     return 0;
1061 }
1062
1063 two   sink_5_24678(const          A&);
1064 four  sink_5_24678(const volatile A&);
1065 six   sink_5_24678(const          A&&);
1066 seven sink_5_24678(volatile       A&&);
1067 eight sink_5_24678(const volatile A&&);
1068
1069 int test5_24678()
1070 {
1071                    A a;
1072     const          A ca = a;
1073           volatile A va;
1074     const volatile A cva = a;
1075     sa<sizeof(sink_5_24678(a))           == 2> t1;
1076     sa<sizeof(sink_5_24678(ca))          == 2> t2;
1077     sa<sizeof(sink_5_24678(va))          == 4> t3;
1078     sa<sizeof(sink_5_24678(cva))         == 4> t4;
1079     sa<sizeof(sink_5_24678(c_source()))  == 6> t6;
1080     sa<sizeof(sink_5_24678(v_source()))  == 7> t7;
1081     sa<sizeof(sink_5_24678(cv_source())) == 8> t8;
1082     return 0;
1083 }
1084
1085 two   sink_5_25678(const          A&);
1086 five  sink_5_25678(               A&&);
1087 six   sink_5_25678(const          A&&);
1088 seven sink_5_25678(volatile       A&&);
1089 eight sink_5_25678(const volatile A&&);
1090
1091 int test5_25678()
1092 {
1093                    A a;
1094     const          A ca = a;
1095           volatile A va;
1096     const volatile A cva = a;
1097     sa<sizeof(sink_5_25678(a))           == 2> t1;
1098     sa<sizeof(sink_5_25678(ca))          == 2> t2;
1099     sa<sizeof(sink_5_25678(source()))    == 5> t5;
1100     sa<sizeof(sink_5_25678(c_source()))  == 6> t6;
1101     sa<sizeof(sink_5_25678(v_source()))  == 7> t7;
1102     sa<sizeof(sink_5_25678(cv_source())) == 8> t8;
1103     return 0;
1104 }
1105
1106 three sink_5_34567(volatile       A&);
1107 four  sink_5_34567(const volatile A&);
1108 five  sink_5_34567(               A&&);
1109 six   sink_5_34567(const          A&&);
1110 seven sink_5_34567(volatile       A&&);
1111
1112 int test5_34567()
1113 {
1114                    A a;
1115     const          A ca = a;
1116           volatile A va;
1117     const volatile A cva = a;
1118     sa<sizeof(sink_5_34567(a))           == 3> t1;
1119     sa<sizeof(sink_5_34567(ca))          == 4> t2;
1120     sa<sizeof(sink_5_34567(va))          == 3> t3;
1121     sa<sizeof(sink_5_34567(cva))         == 4> t4;
1122     sa<sizeof(sink_5_34567(source()))    == 5> t5;
1123     sa<sizeof(sink_5_34567(c_source()))  == 6> t6;
1124     sa<sizeof(sink_5_34567(v_source()))  == 7> t7;
1125     return 0;
1126 }
1127
1128 three sink_5_34568(volatile       A&);
1129 four  sink_5_34568(const volatile A&);
1130 five  sink_5_34568(               A&&);
1131 six   sink_5_34568(const          A&&);
1132 eight sink_5_34568(const volatile A&&);
1133
1134 int test5_34568()
1135 {
1136                    A a;
1137     const          A ca = a;
1138           volatile A va;
1139     const volatile A cva = a;
1140     sa<sizeof(sink_5_34568(a))           == 3> t1;
1141     sa<sizeof(sink_5_34568(ca))          == 4> t2;
1142     sa<sizeof(sink_5_34568(va))          == 3> t3;
1143     sa<sizeof(sink_5_34568(cva))         == 4> t4;
1144     sa<sizeof(sink_5_34568(source()))    == 5> t5;
1145     sa<sizeof(sink_5_34568(c_source()))  == 6> t6;
1146     sa<sizeof(sink_5_34568(v_source()))  == 8> t7;
1147     sa<sizeof(sink_5_34568(cv_source())) == 8> t8;
1148     return 0;
1149 }
1150
1151 three sink_5_34578(volatile       A&);
1152 four  sink_5_34578(const volatile A&);
1153 five  sink_5_34578(               A&&);
1154 seven sink_5_34578(volatile       A&&);
1155 eight sink_5_34578(const volatile A&&);
1156
1157 int test5_34578()
1158 {
1159                    A a;
1160     const          A ca = a;
1161           volatile A va;
1162     const volatile A cva = a;
1163     sa<sizeof(sink_5_34578(a))           == 3> t1;
1164     sa<sizeof(sink_5_34578(ca))          == 4> t2;
1165     sa<sizeof(sink_5_34578(va))          == 3> t3;
1166     sa<sizeof(sink_5_34578(cva))         == 4> t4;
1167     sa<sizeof(sink_5_34578(source()))    == 5> t5;
1168     sa<sizeof(sink_5_34578(c_source()))  == 8> t6;
1169     sa<sizeof(sink_5_34578(v_source()))  == 7> t7;
1170     sa<sizeof(sink_5_34578(cv_source())) == 8> t8;
1171     return 0;
1172 }
1173
1174 three sink_5_34678(volatile       A&);
1175 four  sink_5_34678(const volatile A&);
1176 six   sink_5_34678(const          A&&);
1177 seven sink_5_34678(volatile       A&&);
1178 eight sink_5_34678(const volatile A&&);
1179
1180 int test5_34678()
1181 {
1182                    A a;
1183     const          A ca = a;
1184           volatile A va;
1185     const volatile A cva = a;
1186     sa<sizeof(sink_5_34678(a))           == 3> t1;
1187     sa<sizeof(sink_5_34678(ca))          == 4> t2;
1188     sa<sizeof(sink_5_34678(va))          == 3> t3;
1189     sa<sizeof(sink_5_34678(cva))         == 4> t4;
1190     sa<sizeof(sink_5_34678(c_source()))  == 6> t6;
1191     sa<sizeof(sink_5_34678(v_source()))  == 7> t7;
1192     sa<sizeof(sink_5_34678(cv_source())) == 8> t8;
1193     return 0;
1194 }
1195
1196 three sink_5_35678(volatile       A&);
1197 five  sink_5_35678(               A&&);
1198 six   sink_5_35678(const          A&&);
1199 seven sink_5_35678(volatile       A&&);
1200 eight sink_5_35678(const volatile A&&);
1201
1202 int test5_35678()
1203 {
1204                    A a;
1205     const          A ca = a;
1206           volatile A va;
1207     const volatile A cva = a;
1208     sa<sizeof(sink_5_35678(a))           == 3> t1;
1209     sa<sizeof(sink_5_35678(va))          == 3> t3;
1210     sa<sizeof(sink_5_35678(source()))    == 5> t5;
1211     sa<sizeof(sink_5_35678(c_source()))  == 6> t6;
1212     sa<sizeof(sink_5_35678(v_source()))  == 7> t7;
1213     sa<sizeof(sink_5_35678(cv_source())) == 8> t8;
1214     return 0;
1215 }
1216
1217 four  sink_5_45678(const volatile A&);
1218 five  sink_5_45678(               A&&);
1219 six   sink_5_45678(const          A&&);
1220 seven sink_5_45678(volatile       A&&);
1221 eight sink_5_45678(const volatile A&&);
1222
1223 int test5_45678()
1224 {
1225                    A a;
1226     const          A ca = a;
1227           volatile A va;
1228     const volatile A cva = a;
1229     sa<sizeof(sink_5_45678(a))           == 4> t1;
1230     sa<sizeof(sink_5_45678(ca))          == 4> t2;
1231     sa<sizeof(sink_5_45678(va))          == 4> t3;
1232     sa<sizeof(sink_5_45678(cva))         == 4> t4;
1233     sa<sizeof(sink_5_45678(source()))    == 5> t5;
1234     sa<sizeof(sink_5_45678(c_source()))  == 6> t6;
1235     sa<sizeof(sink_5_45678(v_source()))  == 7> t7;
1236     sa<sizeof(sink_5_45678(cv_source())) == 8> t8;
1237     return 0;
1238 }
1239
1240 int main()
1241 {
1242     return test5_12345() + test5_12346() + test5_12347() + test5_12348() +
1243            test5_12356() + test5_12357() + test5_12358() + test5_12367() +
1244            test5_12368() + test5_12378() + test5_12456() + test5_12457() +
1245            test5_12458() + test5_12467() + test5_12468() + test5_12478() +
1246            test5_12567() + test5_12568() + test5_12578() + test5_12678() +
1247            test5_13456() + test5_13457() + test5_13458() + test5_13467() +
1248            test5_13468() + test5_13478() + test5_13567() + test5_13568() +
1249            test5_13578() + test5_13678() + test5_14567() + test5_14568() +
1250            test5_14578() + test5_14678() + test5_15678() + test5_23456() +
1251            test5_23457() + test5_23458() + test5_23467() + test5_23468() +
1252            test5_23478() + test5_23567() + test5_23568() + test5_23578() +
1253            test5_23678() + test5_24567() + test5_24568() + test5_24578() +
1254            test5_24678() + test5_25678() + test5_34567() + test5_34568() +
1255            test5_34578() + test5_34678() + test5_35678() + test5_45678();
1256 }