tuple_cat.pass.cpp revision f5256e16dfc425c1d466f6308d4026d529ce9e0b 
1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <tuple>
11
12// template <class... Types> class tuple;
13
14// template <class... TTypes, class... UTypes>
15//   tuple<TTypes..., UTypes...>
16//   tuple_cat(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
17//
18// template <class... TTypes, class... UTypes>
19//   tuple<TTypes..., UTypes...>
20//   tuple_cat(const tuple<TTypes...>&& t, const tuple<UTypes...>& u);
21//
22// template <class... TTypes, class... UTypes>
23//   tuple<TTypes..., UTypes...>
24//   tuple_cat(const tuple<TTypes...>& t, const tuple<UTypes...>&& u);
25//
26// template <class... TTypes, class... UTypes>
27//   tuple<TTypes..., UTypes...>
28//   tuple_cat(const tuple<TTypes...>&& t, const tuple<UTypes...>&& u);
29
30#include <tuple>
31#include <string>
32#include <cassert>
33
34#include "../MoveOnly.h"
35
36int main()
37{
38    {
39        std::tuple<> t1;
40        std::tuple<> t2;
41        std::tuple<> t3 = std::tuple_cat(t1, t2);
42    }
43    {
44        std::tuple<> t1;
45        std::tuple<int> t2(2);
46        std::tuple<int> t3 = std::tuple_cat(t1, t2);
47        assert(std::get<0>(t3) == 2);
48    }
49    {
50        std::tuple<> t1;
51        std::tuple<int> t2(2);
52        std::tuple<int> t3 = std::tuple_cat(t2, t1);
53        assert(std::get<0>(t3) == 2);
54    }
55    {
56        std::tuple<int*> t1;
57        std::tuple<int> t2(2);
58        std::tuple<int*, int> t3 = std::tuple_cat(t1, t2);
59        assert(std::get<0>(t3) == nullptr);
60        assert(std::get<1>(t3) == 2);
61    }
62    {
63        std::tuple<int*> t1;
64        std::tuple<int> t2(2);
65        std::tuple<int, int*> t3 = std::tuple_cat(t2, t1);
66        assert(std::get<0>(t3) == 2);
67        assert(std::get<1>(t3) == nullptr);
68    }
69    {
70        std::tuple<int*> t1;
71        std::tuple<int, double> t2(2, 3.5);
72        std::tuple<int*, int, double> t3 = std::tuple_cat(t1, t2);
73        assert(std::get<0>(t3) == nullptr);
74        assert(std::get<1>(t3) == 2);
75        assert(std::get<2>(t3) == 3.5);
76    }
77    {
78        std::tuple<int*> t1;
79        std::tuple<int, double> t2(2, 3.5);
80        std::tuple<int, double, int*> t3 = std::tuple_cat(t2, t1);
81        assert(std::get<0>(t3) == 2);
82        assert(std::get<1>(t3) == 3.5);
83        assert(std::get<2>(t3) == nullptr);
84    }
85    {
86        std::tuple<int*, MoveOnly> t1(nullptr, 1);
87        std::tuple<int, double> t2(2, 3.5);
88        std::tuple<int*, MoveOnly, int, double> t3 =
89                                              std::tuple_cat(std::move(t1), t2);
90        assert(std::get<0>(t3) == nullptr);
91        assert(std::get<1>(t3) == 1);
92        assert(std::get<2>(t3) == 2);
93        assert(std::get<3>(t3) == 3.5);
94    }
95    {
96        std::tuple<int*, MoveOnly> t1(nullptr, 1);
97        std::tuple<int, double> t2(2, 3.5);
98        std::tuple<int, double, int*, MoveOnly> t3 =
99                                              std::tuple_cat(t2, std::move(t1));
100        assert(std::get<0>(t3) == 2);
101        assert(std::get<1>(t3) == 3.5);
102        assert(std::get<2>(t3) == nullptr);
103        assert(std::get<3>(t3) == 1);
104    }
105    {
106        std::tuple<MoveOnly, MoveOnly> t1(1, 2);
107        std::tuple<int*, MoveOnly> t2(nullptr, 4);
108        std::tuple<MoveOnly, MoveOnly, int*, MoveOnly> t3 =
109                                   std::tuple_cat(std::move(t1), std::move(t2));
110        assert(std::get<0>(t3) == 1);
111        assert(std::get<1>(t3) == 2);
112        assert(std::get<2>(t3) == nullptr);
113        assert(std::get<3>(t3) == 4);
114    }
115}
116