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

   1 // I, Howard Hinnant, hereby place this code in the public domain.
   2
   3 // Test overlaod resolution among referece 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 // 7 at a time
  32
  33 one   sink_7_1234567(               A&);
  34 two   sink_7_1234567(const          A&);
  35 three sink_7_1234567(volatile       A&);
  36 four  sink_7_1234567(const volatile A&);
  37 five  sink_7_1234567(               A&&);
  38 six   sink_7_1234567(const          A&&);
  39 seven sink_7_1234567(volatile       A&&);
  40
  41 int test7_1234567()
  42 {
  43                    A a;
  44     const          A ca = a;
  45           volatile A va;
  46     const volatile A cva = a;
  47     sa<sizeof(sink_7_1234567(a))           == 1> t1;
  48     sa<sizeof(sink_7_1234567(ca))          == 2> t2;
  49     sa<sizeof(sink_7_1234567(va))          == 3> t3;
  50     sa<sizeof(sink_7_1234567(cva))         == 4> t4;
  51     sa<sizeof(sink_7_1234567(source()))    == 5> t5;
  52     sa<sizeof(sink_7_1234567(c_source()))  == 6> t6;
  53     sa<sizeof(sink_7_1234567(v_source()))  == 7> t7;
  54     return 0;
  55 }
  56
  57 one   sink_7_1234568(               A&);
  58 two   sink_7_1234568(const          A&);
  59 three sink_7_1234568(volatile       A&);
  60 four  sink_7_1234568(const volatile A&);
  61 five  sink_7_1234568(               A&&);
  62 six   sink_7_1234568(const          A&&);
  63 eight sink_7_1234568(const volatile A&&);
  64
  65 int test7_1234568()
  66 {
  67                    A a;
  68     const          A ca = a;
  69           volatile A va;
  70     const volatile A cva = a;
  71     sa<sizeof(sink_7_1234568(a))           == 1> t1;
  72     sa<sizeof(sink_7_1234568(ca))          == 2> t2;
  73     sa<sizeof(sink_7_1234568(va))          == 3> t3;
  74     sa<sizeof(sink_7_1234568(cva))         == 4> t4;
  75     sa<sizeof(sink_7_1234568(source()))    == 5> t5;
  76     sa<sizeof(sink_7_1234568(c_source()))  == 6> t6;
  77     sa<sizeof(sink_7_1234568(v_source()))  == 8> t7;
  78     sa<sizeof(sink_7_1234568(cv_source())) == 8> t8;
  79     return 0;
  80 }
  81
  82 one   sink_7_1234578(               A&);
  83 two   sink_7_1234578(const          A&);
  84 three sink_7_1234578(volatile       A&);
  85 four  sink_7_1234578(const volatile A&);
  86 five  sink_7_1234578(               A&&);
  87 seven sink_7_1234578(volatile       A&&);
  88 eight sink_7_1234578(const volatile A&&);
  89
  90 int test7_1234578()
  91 {
  92                    A a;
  93     const          A ca = a;
  94           volatile A va;
  95     const volatile A cva = a;
  96     sa<sizeof(sink_7_1234578(a))           == 1> t1;
  97     sa<sizeof(sink_7_1234578(ca))          == 2> t2;
  98     sa<sizeof(sink_7_1234578(va))          == 3> t3;
  99     sa<sizeof(sink_7_1234578(cva))         == 4> t4;
 100     sa<sizeof(sink_7_1234578(source()))    == 5> t5;
 101     sa<sizeof(sink_7_1234578(c_source()))  == 8> t6;
 102     sa<sizeof(sink_7_1234578(v_source()))  == 7> t7;
 103     sa<sizeof(sink_7_1234578(cv_source())) == 8> t8;
 104     return 0;
 105 }
 106
 107 one   sink_7_1234678(               A&);
 108 two   sink_7_1234678(const          A&);
 109 three sink_7_1234678(volatile       A&);
 110 four  sink_7_1234678(const volatile A&);
 111 six   sink_7_1234678(const          A&&);
 112 seven sink_7_1234678(volatile       A&&);
 113 eight sink_7_1234678(const volatile A&&);
 114
 115 int test7_1234678()
 116 {
 117                    A a;
 118     const          A ca = a;
 119           volatile A va;
 120     const volatile A cva = a;
 121     sa<sizeof(sink_7_1234678(a))           == 1> t1;
 122     sa<sizeof(sink_7_1234678(ca))          == 2> t2;
 123     sa<sizeof(sink_7_1234678(va))          == 3> t3;
 124     sa<sizeof(sink_7_1234678(cva))         == 4> t4;
 125     sa<sizeof(sink_7_1234678(c_source()))  == 6> t6;
 126     sa<sizeof(sink_7_1234678(v_source()))  == 7> t7;
 127     sa<sizeof(sink_7_1234678(cv_source())) == 8> t8;
 128     return 0;
 129 }
 130
 131 one   sink_7_1235678(               A&);
 132 two   sink_7_1235678(const          A&);
 133 three sink_7_1235678(volatile       A&);
 134 five  sink_7_1235678(               A&&);
 135 six   sink_7_1235678(const          A&&);
 136 seven sink_7_1235678(volatile       A&&);
 137 eight sink_7_1235678(const volatile A&&);
 138
 139 int test7_1235678()
 140 {
 141                    A a;
 142     const          A ca = a;
 143           volatile A va;
 144     const volatile A cva = a;
 145     sa<sizeof(sink_7_1235678(a))           == 1> t1;
 146     sa<sizeof(sink_7_1235678(ca))          == 2> t2;
 147     sa<sizeof(sink_7_1235678(va))          == 3> t3;
 148     sa<sizeof(sink_7_1235678(cva))         == 8> t4;
 149     sa<sizeof(sink_7_1235678(source()))    == 5> t5;
 150     sa<sizeof(sink_7_1235678(c_source()))  == 6> t6;
 151     sa<sizeof(sink_7_1235678(v_source()))  == 7> t7;
 152     sa<sizeof(sink_7_1235678(cv_source())) == 8> t8;
 153     return 0;
 154 }
 155
 156 one   sink_7_1245678(               A&);
 157 two   sink_7_1245678(const          A&);
 158 four  sink_7_1245678(const volatile A&);
 159 five  sink_7_1245678(               A&&);
 160 six   sink_7_1245678(const          A&&);
 161 seven sink_7_1245678(volatile       A&&);
 162 eight sink_7_1245678(const volatile A&&);
 163
 164 int test7_1245678()
 165 {
 166                    A a;
 167     const          A ca = a;
 168           volatile A va;
 169     const volatile A cva = a;
 170     sa<sizeof(sink_7_1245678(a))           == 1> t1;
 171     sa<sizeof(sink_7_1245678(ca))          == 2> t2;
 172     sa<sizeof(sink_7_1245678(va))          == 4> t3;
 173     sa<sizeof(sink_7_1245678(cva))         == 4> t4;
 174     sa<sizeof(sink_7_1245678(source()))    == 5> t5;
 175     sa<sizeof(sink_7_1245678(c_source()))  == 6> t6;
 176     sa<sizeof(sink_7_1245678(v_source()))  == 7> t7;
 177     sa<sizeof(sink_7_1245678(cv_source())) == 8> t8;
 178     return 0;
 179 }
 180
 181 one   sink_7_1345678(               A&);
 182 three sink_7_1345678(volatile       A&);
 183 four  sink_7_1345678(const volatile A&);
 184 five  sink_7_1345678(               A&&);
 185 six   sink_7_1345678(const          A&&);
 186 seven sink_7_1345678(volatile       A&&);
 187 eight sink_7_1345678(const volatile A&&);
 188
 189 int test7_1345678()
 190 {
 191                    A a;
 192     const          A ca = a;
 193           volatile A va;
 194     const volatile A cva = a;
 195     sa<sizeof(sink_7_1345678(a))           == 1> t1;
 196     sa<sizeof(sink_7_1345678(ca))          == 4> t2;
 197     sa<sizeof(sink_7_1345678(va))          == 3> t3;
 198     sa<sizeof(sink_7_1345678(cva))         == 4> t4;
 199     sa<sizeof(sink_7_1345678(source()))    == 5> t5;
 200     sa<sizeof(sink_7_1345678(c_source()))  == 6> t6;
 201     sa<sizeof(sink_7_1345678(v_source()))  == 7> t7;
 202     sa<sizeof(sink_7_1345678(cv_source())) == 8> t8;
 203     return 0;
 204 }
 205
 206 two   sink_7_2345678(const          A&);
 207 three sink_7_2345678(volatile       A&);
 208 four  sink_7_2345678(const volatile A&);
 209 five  sink_7_2345678(               A&&);
 210 six   sink_7_2345678(const          A&&);
 211 seven sink_7_2345678(volatile       A&&);
 212 eight sink_7_2345678(const volatile A&&);
 213
 214 int test7_2345678()
 215 {
 216                    A a;
 217     const          A ca = a;
 218           volatile A va;
 219     const volatile A cva = a;
 220     sa<sizeof(sink_7_2345678(ca))          == 2> t2;
 221     sa<sizeof(sink_7_2345678(va))          == 3> t3;
 222     sa<sizeof(sink_7_2345678(cva))         == 4> t4;
 223     sa<sizeof(sink_7_2345678(source()))    == 5> t5;
 224     sa<sizeof(sink_7_2345678(c_source()))  == 6> t6;
 225     sa<sizeof(sink_7_2345678(v_source()))  == 7> t7;
 226     sa<sizeof(sink_7_2345678(cv_source())) == 8> t8;
 227     return 0;
 228 }
 229
 230 int main()
 231 {
 232     return test7_1234567() + test7_1234568() + test7_1234578() + test7_1234678() +
 233            test7_1235678() + test7_1245678() + test7_1345678() + test7_2345678();
 234 }