tuple_cat.pass.cpp revision 0e1493ec5e125adfb7531b2a05c26bff26325cb2 
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#include <tuple>
17#include <utility>
18#include <array>
19#include <string>
20#include <cassert>
21
22#include "../MoveOnly.h"
23
24int main()
25{
26    {
27        std::tuple<> t = std::tuple_cat();
28    }
29    {
30        std::tuple<> t1;
31        std::tuple<> t2 = std::tuple_cat(t1);
32    }
33    {
34        std::tuple<> t = std::tuple_cat(std::tuple<>());
35    }
36    {
37        std::tuple<> t = std::tuple_cat(std::array<int, 0>());
38    }
39
40    {
41        std::tuple<int> t1(1);
42        std::tuple<int> t = std::tuple_cat(t1);
43        assert(std::get<0>(t) == 1);
44    }
45    {
46        std::tuple<int, MoveOnly> t =
47                                std::tuple_cat(std::tuple<int, MoveOnly>(1, 2));
48        assert(std::get<0>(t) == 1);
49        assert(std::get<1>(t) == 2);
50    }
51    {
52        std::tuple<int, int, int> t = std::tuple_cat(std::array<int, 3>());
53        assert(std::get<0>(t) == 0);
54        assert(std::get<1>(t) == 0);
55        assert(std::get<2>(t) == 0);
56    }
57    {
58        std::tuple<int, MoveOnly> t = std::tuple_cat(std::pair<int, MoveOnly>(2, 1));
59        assert(std::get<0>(t) == 2);
60        assert(std::get<1>(t) == 1);
61    }
62
63    {
64        std::tuple<> t1;
65        std::tuple<> t2;
66        std::tuple<> t3 = std::tuple_cat(t1, t2);
67    }
68    {
69        std::tuple<> t1;
70        std::tuple<int> t2(2);
71        std::tuple<int> t3 = std::tuple_cat(t1, t2);
72        assert(std::get<0>(t3) == 2);
73    }
74    {
75        std::tuple<> t1;
76        std::tuple<int> t2(2);
77        std::tuple<int> t3 = std::tuple_cat(t2, t1);
78        assert(std::get<0>(t3) == 2);
79    }
80    {
81        std::tuple<int*> t1;
82        std::tuple<int> t2(2);
83        std::tuple<int*, int> t3 = std::tuple_cat(t1, t2);
84        assert(std::get<0>(t3) == nullptr);
85        assert(std::get<1>(t3) == 2);
86    }
87    {
88        std::tuple<int*> t1;
89        std::tuple<int> t2(2);
90        std::tuple<int, int*> t3 = std::tuple_cat(t2, t1);
91        assert(std::get<0>(t3) == 2);
92        assert(std::get<1>(t3) == nullptr);
93    }
94    {
95        std::tuple<int*> t1;
96        std::tuple<int, double> t2(2, 3.5);
97        std::tuple<int*, int, double> t3 = std::tuple_cat(t1, t2);
98        assert(std::get<0>(t3) == nullptr);
99        assert(std::get<1>(t3) == 2);
100        assert(std::get<2>(t3) == 3.5);
101    }
102    {
103        std::tuple<int*> t1;
104        std::tuple<int, double> t2(2, 3.5);
105        std::tuple<int, double, int*> t3 = std::tuple_cat(t2, t1);
106        assert(std::get<0>(t3) == 2);
107        assert(std::get<1>(t3) == 3.5);
108        assert(std::get<2>(t3) == nullptr);
109    }
110    {
111        std::tuple<int*, MoveOnly> t1(nullptr, 1);
112        std::tuple<int, double> t2(2, 3.5);
113        std::tuple<int*, MoveOnly, int, double> t3 =
114                                              std::tuple_cat(std::move(t1), t2);
115        assert(std::get<0>(t3) == nullptr);
116        assert(std::get<1>(t3) == 1);
117        assert(std::get<2>(t3) == 2);
118        assert(std::get<3>(t3) == 3.5);
119    }
120    {
121        std::tuple<int*, MoveOnly> t1(nullptr, 1);
122        std::tuple<int, double> t2(2, 3.5);
123        std::tuple<int, double, int*, MoveOnly> t3 =
124                                              std::tuple_cat(t2, std::move(t1));
125        assert(std::get<0>(t3) == 2);
126        assert(std::get<1>(t3) == 3.5);
127        assert(std::get<2>(t3) == nullptr);
128        assert(std::get<3>(t3) == 1);
129    }
130    {
131        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
132        std::tuple<int*, MoveOnly> t2(nullptr, 4);
133        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
134                                   std::tuple_cat(std::move(t1), std::move(t2));
135        assert(std::get<0>(t3) == 1);
136        assert(std::get<1>(t3) == 2);
137        assert(std::get<2>(t3) == nullptr);
138        assert(std::get<3>(t3) == 4);
139    }
140
141    {
142        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
143        std::tuple<int*, MoveOnly> t2(nullptr, 4);
144        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
145                                   std::tuple_cat(std::tuple<>(),
146                                                  std::move(t1),
147                                                  std::move(t2));
148        assert(std::get<0>(t3) == 1);
149        assert(std::get<1>(t3) == 2);
150        assert(std::get<2>(t3) == nullptr);
151        assert(std::get<3>(t3) == 4);
152    }
153    {
154        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
155        std::tuple<int*, MoveOnly> t2(nullptr, 4);
156        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
157                                   std::tuple_cat(std::move(t1),
158                                                  std::tuple<>(),
159                                                  std::move(t2));
160        assert(std::get<0>(t3) == 1);
161        assert(std::get<1>(t3) == 2);
162        assert(std::get<2>(t3) == nullptr);
163        assert(std::get<3>(t3) == 4);
164    }
165    {
166        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
167        std::tuple<int*, MoveOnly> t2(nullptr, 4);
168        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
169                                   std::tuple_cat(std::move(t1),
170                                                  std::move(t2),
171                                                  std::tuple<>());
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        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
179        std::tuple<int*, MoveOnly> t2(nullptr, 4);
180        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly, int> t3 =
181                                   std::tuple_cat(std::move(t1),
182                                                  std::move(t2),
183                                                  std::tuple<int>(5));
184        assert(std::get<0>(t3) == 1);
185        assert(std::get<1>(t3) == 2);
186        assert(std::get<2>(t3) == nullptr);
187        assert(std::get<3>(t3) == 4);
188        assert(std::get<4>(t3) == 5);
189    }
190}
191