ceph/src/boost/libs/variant2/test/variant_get_by_index.cpp

   1
   2 // Copyright 2017 Peter Dimov.
   3 //
   4 // Distributed under the Boost Software License, Version 1.0.
   5 //
   6 // See accompanying file LICENSE_1_0.txt or copy at
   7 // http://www.boost.org/LICENSE_1_0.txt
   8
   9 #if defined( __clang__ ) && defined( __has_warning )
  10 # if __has_warning( "-Wdeprecated-volatile" )
  11 #  pragma clang diagnostic ignored "-Wdeprecated-volatile"
  12 # endif
  13 #endif
  14
  15 #include <boost/variant2/variant.hpp>
  16 #include <boost/core/lightweight_test.hpp>
  17 #include <boost/core/lightweight_test_trait.hpp>
  18 #include <type_traits>
  19 #include <utility>
  20 #include <string>
  21
  22 using namespace boost::variant2;
  23
  24 int main()
  25 {
  26     {
  27         variant<int> v;
  28
  29         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int&>));
  30         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int&&>));
  31         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int*>));
  32     }
  33
  34     {
  35         variant<int> const v;
  36
  37         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
  38         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
  39         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
  40     }
  41
  42     {
  43         variant<int const> v;
  44
  45         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
  46         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
  47         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
  48     }
  49
  50     {
  51         variant<int volatile> const v;
  52
  53         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const volatile&>));
  54         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const volatile&&>));
  55         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const volatile*>));
  56     }
  57
  58     {
  59         variant<int> v;
  60
  61         BOOST_TEST_EQ( get<0>(v), 0 );
  62         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
  63
  64         BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
  65     }
  66
  67     {
  68         variant<int> const v;
  69
  70         BOOST_TEST_EQ( get<0>(v), 0 );
  71         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
  72
  73         BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
  74     }
  75
  76     {
  77         variant<int> v( 1 );
  78
  79         BOOST_TEST_EQ( get<0>(v), 1 );
  80         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
  81
  82         BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
  83     }
  84
  85     {
  86         variant<int> const v( 1 );
  87
  88         BOOST_TEST_EQ( get<0>(v), 1 );
  89         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
  90
  91         BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
  92     }
  93
  94     {
  95         variant<int, float> v;
  96
  97         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int&>));
  98         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int&&>));
  99         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int*>));
 100
 101         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float&>));
 102         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float&&>));
 103         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float*>));
 104     }
 105
 106     {
 107         variant<int, float> const v;
 108
 109         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
 110         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
 111         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
 112
 113         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float const&>));
 114         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float const&&>));
 115         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float const*>));
 116     }
 117
 118     {
 119         variant<int const, float volatile> v;
 120
 121         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
 122         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
 123         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
 124
 125         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float volatile&>));
 126         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float volatile&&>));
 127         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float volatile*>));
 128     }
 129
 130     {
 131         variant<int const, float volatile> const v;
 132
 133         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
 134         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
 135         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
 136
 137         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float const volatile&>));
 138         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float const volatile&&>));
 139         BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float const volatile*>));
 140     }
 141
 142     {
 143         variant<int, float> v;
 144
 145         BOOST_TEST_EQ( get<0>(v), 0 );
 146         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 147
 148         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 149         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 150
 151         BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
 152     }
 153
 154     {
 155         variant<int, float> const v;
 156
 157         BOOST_TEST_EQ( get<0>(v), 0 );
 158         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 159
 160         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 161         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 162
 163         BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
 164     }
 165
 166     {
 167         variant<int, float> v( 1 );
 168
 169         BOOST_TEST_EQ( get<0>(v), 1 );
 170         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 171
 172         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 173         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 174
 175         BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
 176     }
 177
 178     {
 179         variant<int, float> const v( 1 );
 180
 181         BOOST_TEST_EQ( get<0>(v), 1 );
 182         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 183
 184         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 185         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 186
 187         BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
 188     }
 189
 190     {
 191         variant<int, float> v( 3.14f );
 192
 193         BOOST_TEST_THROWS( get<0>(v), bad_variant_access );
 194         BOOST_TEST_EQ( get_if<0>(&v), nullptr );
 195
 196         BOOST_TEST_EQ( get<1>(v), 3.14f );
 197         BOOST_TEST_EQ( get_if<1>(&v), &get<1>(v) );
 198
 199         BOOST_TEST_EQ( get<1>(std::move(v)), 3.14f );
 200     }
 201
 202     {
 203         variant<int, float> const v( 3.14f );
 204
 205         BOOST_TEST_THROWS( get<0>(v), bad_variant_access );
 206         BOOST_TEST_EQ( get_if<0>(&v), nullptr );
 207
 208         BOOST_TEST_EQ( get<1>(v), 3.14f );
 209         BOOST_TEST_EQ( get_if<1>(&v), &get<1>(v) );
 210
 211         BOOST_TEST_EQ( get<1>(std::move(v)), 3.14f );
 212     }
 213
 214     {
 215         variant<int, float, float> v;
 216
 217         BOOST_TEST_EQ( get<0>(v), 0 );
 218         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 219
 220         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 221         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 222
 223         BOOST_TEST_THROWS( get<2>(v), bad_variant_access );
 224         BOOST_TEST_EQ( get_if<2>(&v), nullptr );
 225
 226         BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
 227     }
 228
 229     {
 230         variant<int, float, float> const v;
 231
 232         BOOST_TEST_EQ( get<0>(v), 0 );
 233         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 234
 235         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 236         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 237
 238         BOOST_TEST_THROWS( get<2>(v), bad_variant_access );
 239         BOOST_TEST_EQ( get_if<2>(&v), nullptr );
 240
 241         BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
 242     }
 243
 244     {
 245         variant<int, float, float> v( 1 );
 246
 247         BOOST_TEST_EQ( get<0>(v), 1 );
 248         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 249
 250         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 251         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 252
 253         BOOST_TEST_THROWS( get<2>(v), bad_variant_access );
 254         BOOST_TEST_EQ( get_if<2>(&v), nullptr );
 255
 256         BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
 257     }
 258
 259     {
 260         variant<int, float, float> const v( 1 );
 261
 262         BOOST_TEST_EQ( get<0>(v), 1 );
 263         BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
 264
 265         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 266         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 267
 268         BOOST_TEST_THROWS( get<2>(v), bad_variant_access );
 269         BOOST_TEST_EQ( get_if<2>(&v), nullptr );
 270
 271         BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
 272     }
 273
 274     {
 275         variant<int, int, float> v( 3.14f );
 276
 277         BOOST_TEST_THROWS( get<0>(v), bad_variant_access );
 278         BOOST_TEST_EQ( get_if<0>(&v), nullptr );
 279
 280         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 281         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 282
 283         BOOST_TEST_EQ( get<2>(v), 3.14f );
 284         BOOST_TEST_EQ( get_if<2>(&v), &get<2>(v) );
 285
 286         BOOST_TEST_EQ( get<2>(std::move(v)), 3.14f );
 287     }
 288
 289     {
 290         variant<int, int, float> const v( 3.14f );
 291
 292         BOOST_TEST_THROWS( get<0>(v), bad_variant_access );
 293         BOOST_TEST_EQ( get_if<0>(&v), nullptr );
 294
 295         BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
 296         BOOST_TEST_EQ( get_if<1>(&v), nullptr );
 297
 298         BOOST_TEST_EQ( get<2>(v), 3.14f );
 299         BOOST_TEST_EQ( get_if<2>(&v), &get<2>(v) );
 300
 301         BOOST_TEST_EQ( get<2>(std::move(v)), 3.14f );
 302     }
 303
 304     {
 305         variant<int> * p = 0;
 306         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 307     }
 308
 309     {
 310         variant<int const> * p = 0;
 311         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 312     }
 313
 314     {
 315         variant<int> const * p = 0;
 316         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 317     }
 318
 319     {
 320         variant<int const> const * p = 0;
 321         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 322     }
 323
 324     {
 325         variant<int, float> * p = 0;
 326         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 327     }
 328
 329     {
 330         variant<int, float> const * p = 0;
 331         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 332     }
 333
 334     {
 335         variant<int const, float volatile> * p = 0;
 336         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 337     }
 338
 339     {
 340         variant<int const, float volatile> const * p = 0;
 341         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 342     }
 343
 344     {
 345         variant<int, int, float, float> * p = 0;
 346         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 347     }
 348
 349     {
 350         variant<int, int, float, float> const * p = 0;
 351         BOOST_TEST_EQ( get_if<0>(p), nullptr );
 352     }
 353
 354     return boost::report_errors();
 355 }