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 // <tuple>
11 
12 // template <class... Types> class tuple;
13 
14 // template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
15 
16 // UNSUPPORTED: c++98, c++03
17 
18 #include <tuple>
19 #include <utility>
20 #include <array>
21 #include <string>
22 #include <cassert>
23 
24 #include "MoveOnly.h"
25 
main()26 int main()
27 {
28     {
29         std::tuple<> t = std::tuple_cat();
30         ((void)t); // Prevent unused warning
31     }
32     {
33         std::tuple<> t1;
34         std::tuple<> t2 = std::tuple_cat(t1);
35         ((void)t2); // Prevent unused warning
36     }
37     {
38         std::tuple<> t = std::tuple_cat(std::tuple<>());
39         ((void)t); // Prevent unused warning
40     }
41     {
42         std::tuple<> t = std::tuple_cat(std::array<int, 0>());
43         ((void)t); // Prevent unused warning
44     }
45     {
46         std::tuple<int> t1(1);
47         std::tuple<int> t = std::tuple_cat(t1);
48         assert(std::get<0>(t) == 1);
49     }
50 
51 #if _LIBCPP_STD_VER > 11
52     {
53         constexpr std::tuple<> t = std::tuple_cat();
54         ((void)t); // Prevent unused warning
55     }
56     {
57         constexpr std::tuple<> t1;
58         constexpr std::tuple<> t2 = std::tuple_cat(t1);
59         ((void)t2); // Prevent unused warning
60     }
61     {
62         constexpr std::tuple<> t = std::tuple_cat(std::tuple<>());
63         ((void)t); // Prevent unused warning
64     }
65     {
66         constexpr std::tuple<> t = std::tuple_cat(std::array<int, 0>());
67         ((void)t); // Prevent unused warning
68     }
69     {
70         constexpr std::tuple<int> t1(1);
71         constexpr std::tuple<int> t = std::tuple_cat(t1);
72         static_assert(std::get<0>(t) == 1, "");
73     }
74     {
75         constexpr std::tuple<int> t1(1);
76         constexpr std::tuple<int, int> t = std::tuple_cat(t1, t1);
77         static_assert(std::get<0>(t) == 1, "");
78         static_assert(std::get<1>(t) == 1, "");
79     }
80 #endif
81     {
82         std::tuple<int, MoveOnly> t =
83                                 std::tuple_cat(std::tuple<int, MoveOnly>(1, 2));
84         assert(std::get<0>(t) == 1);
85         assert(std::get<1>(t) == 2);
86     }
87     {
88         std::tuple<int, int, int> t = std::tuple_cat(std::array<int, 3>());
89         assert(std::get<0>(t) == 0);
90         assert(std::get<1>(t) == 0);
91         assert(std::get<2>(t) == 0);
92     }
93     {
94         std::tuple<int, MoveOnly> t = std::tuple_cat(std::pair<int, MoveOnly>(2, 1));
95         assert(std::get<0>(t) == 2);
96         assert(std::get<1>(t) == 1);
97     }
98 
99     {
100         std::tuple<> t1;
101         std::tuple<> t2;
102         std::tuple<> t3 = std::tuple_cat(t1, t2);
103         ((void)t3); // Prevent unused warning
104     }
105     {
106         std::tuple<> t1;
107         std::tuple<int> t2(2);
108         std::tuple<int> t3 = std::tuple_cat(t1, t2);
109         assert(std::get<0>(t3) == 2);
110     }
111     {
112         std::tuple<> t1;
113         std::tuple<int> t2(2);
114         std::tuple<int> t3 = std::tuple_cat(t2, t1);
115         assert(std::get<0>(t3) == 2);
116     }
117     {
118         std::tuple<int*> t1;
119         std::tuple<int> t2(2);
120         std::tuple<int*, int> t3 = std::tuple_cat(t1, t2);
121         assert(std::get<0>(t3) == nullptr);
122         assert(std::get<1>(t3) == 2);
123     }
124     {
125         std::tuple<int*> t1;
126         std::tuple<int> t2(2);
127         std::tuple<int, int*> t3 = std::tuple_cat(t2, t1);
128         assert(std::get<0>(t3) == 2);
129         assert(std::get<1>(t3) == nullptr);
130     }
131     {
132         std::tuple<int*> t1;
133         std::tuple<int, double> t2(2, 3.5);
134         std::tuple<int*, int, double> t3 = std::tuple_cat(t1, t2);
135         assert(std::get<0>(t3) == nullptr);
136         assert(std::get<1>(t3) == 2);
137         assert(std::get<2>(t3) == 3.5);
138     }
139     {
140         std::tuple<int*> t1;
141         std::tuple<int, double> t2(2, 3.5);
142         std::tuple<int, double, int*> t3 = std::tuple_cat(t2, t1);
143         assert(std::get<0>(t3) == 2);
144         assert(std::get<1>(t3) == 3.5);
145         assert(std::get<2>(t3) == nullptr);
146     }
147     {
148         std::tuple<int*, MoveOnly> t1(nullptr, 1);
149         std::tuple<int, double> t2(2, 3.5);
150         std::tuple<int*, MoveOnly, int, double> t3 =
151                                               std::tuple_cat(std::move(t1), t2);
152         assert(std::get<0>(t3) == nullptr);
153         assert(std::get<1>(t3) == 1);
154         assert(std::get<2>(t3) == 2);
155         assert(std::get<3>(t3) == 3.5);
156     }
157     {
158         std::tuple<int*, MoveOnly> t1(nullptr, 1);
159         std::tuple<int, double> t2(2, 3.5);
160         std::tuple<int, double, int*, MoveOnly> t3 =
161                                               std::tuple_cat(t2, std::move(t1));
162         assert(std::get<0>(t3) == 2);
163         assert(std::get<1>(t3) == 3.5);
164         assert(std::get<2>(t3) == nullptr);
165         assert(std::get<3>(t3) == 1);
166     }
167     {
168         std::tuple<MoveOnly, MoveOnly> t1(1, 2);
169         std::tuple<int*, MoveOnly> t2(nullptr, 4);
170         std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
171                                    std::tuple_cat(std::move(t1), std::move(t2));
172         assert(std::get<0>(t3) == 1);
173         assert(std::get<1>(t3) == 2);
174         assert(std::get<2>(t3) == nullptr);
175         assert(std::get<3>(t3) == 4);
176     }
177 
178     {
179         std::tuple<MoveOnly, MoveOnly> t1(1, 2);
180         std::tuple<int*, MoveOnly> t2(nullptr, 4);
181         std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
182                                    std::tuple_cat(std::tuple<>(),
183                                                   std::move(t1),
184                                                   std::move(t2));
185         assert(std::get<0>(t3) == 1);
186         assert(std::get<1>(t3) == 2);
187         assert(std::get<2>(t3) == nullptr);
188         assert(std::get<3>(t3) == 4);
189     }
190     {
191         std::tuple<MoveOnly, MoveOnly> t1(1, 2);
192         std::tuple<int*, MoveOnly> t2(nullptr, 4);
193         std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
194                                    std::tuple_cat(std::move(t1),
195                                                   std::tuple<>(),
196                                                   std::move(t2));
197         assert(std::get<0>(t3) == 1);
198         assert(std::get<1>(t3) == 2);
199         assert(std::get<2>(t3) == nullptr);
200         assert(std::get<3>(t3) == 4);
201     }
202     {
203         std::tuple<MoveOnly, MoveOnly> t1(1, 2);
204         std::tuple<int*, MoveOnly> t2(nullptr, 4);
205         std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
206                                    std::tuple_cat(std::move(t1),
207                                                   std::move(t2),
208                                                   std::tuple<>());
209         assert(std::get<0>(t3) == 1);
210         assert(std::get<1>(t3) == 2);
211         assert(std::get<2>(t3) == nullptr);
212         assert(std::get<3>(t3) == 4);
213     }
214     {
215         std::tuple<MoveOnly, MoveOnly> t1(1, 2);
216         std::tuple<int*, MoveOnly> t2(nullptr, 4);
217         std::tuple<MoveOnly, MoveOnly, int*, MoveOnly, int> t3 =
218                                    std::tuple_cat(std::move(t1),
219                                                   std::move(t2),
220                                                   std::tuple<int>(5));
221         assert(std::get<0>(t3) == 1);
222         assert(std::get<1>(t3) == 2);
223         assert(std::get<2>(t3) == nullptr);
224         assert(std::get<3>(t3) == 4);
225         assert(std::get<4>(t3) == 5);
226     }
227     {
228         // See bug #19616.
229         auto t1 = std::tuple_cat(
230             std::make_tuple(std::make_tuple(1)),
231             std::make_tuple()
232         );
233         assert(t1 == std::make_tuple(std::make_tuple(1)));
234 
235         auto t2 = std::tuple_cat(
236             std::make_tuple(std::make_tuple(1)),
237             std::make_tuple(std::make_tuple(2))
238         );
239         assert(t2 == std::make_tuple(std::make_tuple(1), std::make_tuple(2)));
240     }
241 }
242