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 // <optional>
11
12 // template <class U, class... Args>
13 // constexpr
14 // explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
15
16 #include <experimental/optional>
17 #include <type_traits>
18 #include <vector>
19 #include <cassert>
20
21 #if _LIBCPP_STD_VER > 11
22
23 using std::experimental::optional;
24 using std::experimental::in_place_t;
25 using std::experimental::in_place;
26
27 class X
28 {
29 int i_;
30 int j_ = 0;
31 public:
X()32 X() : i_(0) {}
X(int i)33 X(int i) : i_(i) {}
X(int i,int j)34 X(int i, int j) : i_(i), j_(j) {}
35
~X()36 ~X() {}
37
operator ==(const X & x,const X & y)38 friend bool operator==(const X& x, const X& y)
39 {return x.i_ == y.i_ && x.j_ == y.j_;}
40 };
41
42 class Y
43 {
44 int i_;
45 int j_ = 0;
46 public:
Y()47 constexpr Y() : i_(0) {}
Y(int i)48 constexpr Y(int i) : i_(i) {}
Y(std::initializer_list<int> il)49 constexpr Y(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {}
50
operator ==(const Y & x,const Y & y)51 friend constexpr bool operator==(const Y& x, const Y& y)
52 {return x.i_ == y.i_ && x.j_ == y.j_;}
53 };
54
55 class Z
56 {
57 int i_;
58 int j_ = 0;
59 public:
Z()60 constexpr Z() : i_(0) {}
Z(int i)61 constexpr Z(int i) : i_(i) {}
Z(std::initializer_list<int> il)62 constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
63 {throw 6;}
64
operator ==(const Z & x,const Z & y)65 friend constexpr bool operator==(const Z& x, const Z& y)
66 {return x.i_ == y.i_ && x.j_ == y.j_;}
67 };
68
69
70 #endif // _LIBCPP_STD_VER > 11
71
main()72 int main()
73 {
74 #if _LIBCPP_STD_VER > 11
75 {
76 static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, "");
77 static_assert(!std::is_constructible<optional<X>, std::initializer_list<int>&>::value, "");
78 }
79 {
80 optional<std::vector<int>> opt(in_place, {3, 1});
81 assert(static_cast<bool>(opt) == true);
82 assert((*opt == std::vector<int>{3, 1}));
83 assert(opt->size() == 2);
84 }
85 {
86 optional<std::vector<int>> opt(in_place, {3, 1}, std::allocator<int>());
87 assert(static_cast<bool>(opt) == true);
88 assert((*opt == std::vector<int>{3, 1}));
89 assert(opt->size() == 2);
90 }
91 {
92 static_assert(std::is_constructible<optional<Y>, std::initializer_list<int>&>::value, "");
93 constexpr optional<Y> opt(in_place, {3, 1});
94 static_assert(static_cast<bool>(opt) == true, "");
95 static_assert(*opt == Y{3, 1}, "");
96
97 struct test_constexpr_ctor
98 : public optional<Y>
99 {
100 constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i)
101 : optional<Y>(in_place, i) {}
102 };
103
104 }
105 {
106 static_assert(std::is_constructible<optional<Z>, std::initializer_list<int>&>::value, "");
107 try
108 {
109 optional<Z> opt(in_place, {3, 1});
110 assert(false);
111 }
112 catch (int i)
113 {
114 assert(i == 6);
115 }
116
117 struct test_constexpr_ctor
118 : public optional<Z>
119 {
120 constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i)
121 : optional<Z>(in_place, i) {}
122 };
123
124 }
125 #endif // _LIBCPP_STD_VER > 11
126 }
127