in_place_index_args.pass.cpp (3301B)
1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 // UNSUPPORTED: c++98, c++03, c++11, c++14 12 13 // XFAIL: availability=macosx10.13 14 // XFAIL: availability=macosx10.12 15 // XFAIL: availability=macosx10.11 16 // XFAIL: availability=macosx10.10 17 // XFAIL: availability=macosx10.9 18 // XFAIL: availability=macosx10.8 19 // XFAIL: availability=macosx10.7 20 21 // <variant> 22 23 // template <class ...Types> class variant; 24 25 // template <size_t I, class ...Args> 26 // constexpr explicit variant(in_place_index_t<I>, Args&&...); 27 28 #include <cassert> 29 #include <string> 30 #include <type_traits> 31 #include <variant> 32 33 #include "test_convertible.hpp" 34 #include "test_macros.h" 35 36 void test_ctor_sfinae() { 37 { 38 using V = std::variant<int>; 39 static_assert( 40 std::is_constructible<V, std::in_place_index_t<0>, int>::value, ""); 41 static_assert(!test_convertible<V, std::in_place_index_t<0>, int>(), ""); 42 } 43 { 44 using V = std::variant<int, long, long long>; 45 static_assert( 46 std::is_constructible<V, std::in_place_index_t<1>, int>::value, ""); 47 static_assert(!test_convertible<V, std::in_place_index_t<1>, int>(), ""); 48 } 49 { 50 using V = std::variant<int, long, int *>; 51 static_assert( 52 std::is_constructible<V, std::in_place_index_t<2>, int *>::value, ""); 53 static_assert(!test_convertible<V, std::in_place_index_t<2>, int *>(), ""); 54 } 55 { // args not convertible to type 56 using V = std::variant<int, long, int *>; 57 static_assert( 58 !std::is_constructible<V, std::in_place_index_t<0>, int *>::value, ""); 59 static_assert(!test_convertible<V, std::in_place_index_t<0>, int *>(), ""); 60 } 61 { // index not in variant 62 using V = std::variant<int, long, int *>; 63 static_assert( 64 !std::is_constructible<V, std::in_place_index_t<3>, int>::value, ""); 65 static_assert(!test_convertible<V, std::in_place_index_t<3>, int>(), ""); 66 } 67 } 68 69 void test_ctor_basic() { 70 { 71 constexpr std::variant<int> v(std::in_place_index<0>, 42); 72 static_assert(v.index() == 0, ""); 73 static_assert(std::get<0>(v) == 42, ""); 74 } 75 { 76 constexpr std::variant<int, long, long> v(std::in_place_index<1>, 42); 77 static_assert(v.index() == 1, ""); 78 static_assert(std::get<1>(v) == 42, ""); 79 } 80 { 81 constexpr std::variant<int, const int, long> v(std::in_place_index<1>, 42); 82 static_assert(v.index() == 1, ""); 83 static_assert(std::get<1>(v) == 42, ""); 84 } 85 { 86 using V = std::variant<const int, volatile int, int>; 87 int x = 42; 88 V v(std::in_place_index<0>, x); 89 assert(v.index() == 0); 90 assert(std::get<0>(v) == x); 91 } 92 { 93 using V = std::variant<const int, volatile int, int>; 94 int x = 42; 95 V v(std::in_place_index<1>, x); 96 assert(v.index() == 1); 97 assert(std::get<1>(v) == x); 98 } 99 { 100 using V = std::variant<const int, volatile int, int>; 101 int x = 42; 102 V v(std::in_place_index<2>, x); 103 assert(v.index() == 2); 104 assert(std::get<2>(v) == x); 105 } 106 } 107 108 int main() { 109 test_ctor_basic(); 110 test_ctor_sfinae(); 111 }