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... TTypes, class... UTypes>
15 // bool
16 // operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
17 //
18 // template<class... TTypes, class... UTypes>
19 // bool
20 // operator>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
21 //
22 // template<class... TTypes, class... UTypes>
23 // bool
24 // operator<=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
25 //
26 // template<class... TTypes, class... UTypes>
27 // bool
28 // operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
29
30 // UNSUPPORTED: c++98, c++03
31
32 #include <tuple>
33 #include <string>
34 #include <cassert>
35
main()36 int main()
37 {
38 {
39 typedef std::tuple<> T1;
40 typedef std::tuple<> T2;
41 const T1 t1;
42 const T2 t2;
43 assert(!(t1 < t2));
44 assert( (t1 <= t2));
45 assert(!(t1 > t2));
46 assert( (t1 >= t2));
47 }
48 {
49 typedef std::tuple<char> T1;
50 typedef std::tuple<double> T2;
51 const T1 t1(1);
52 const T2 t2(1);
53 assert(!(t1 < t2));
54 assert( (t1 <= t2));
55 assert(!(t1 > t2));
56 assert( (t1 >= t2));
57 }
58 {
59 typedef std::tuple<char> T1;
60 typedef std::tuple<double> T2;
61 const T1 t1(1);
62 const T2 t2(0.9);
63 assert(!(t1 < t2));
64 assert(!(t1 <= t2));
65 assert( (t1 > t2));
66 assert( (t1 >= t2));
67 }
68 {
69 typedef std::tuple<char> T1;
70 typedef std::tuple<double> T2;
71 const T1 t1(1);
72 const T2 t2(1.1);
73 assert( (t1 < t2));
74 assert( (t1 <= t2));
75 assert(!(t1 > t2));
76 assert(!(t1 >= t2));
77 }
78 {
79 typedef std::tuple<char, int> T1;
80 typedef std::tuple<double, char> T2;
81 const T1 t1(1, 2);
82 const T2 t2(1, 2);
83 assert(!(t1 < t2));
84 assert( (t1 <= t2));
85 assert(!(t1 > t2));
86 assert( (t1 >= t2));
87 }
88 {
89 typedef std::tuple<char, int> T1;
90 typedef std::tuple<double, char> T2;
91 const T1 t1(1, 2);
92 const T2 t2(0.9, 2);
93 assert(!(t1 < t2));
94 assert(!(t1 <= t2));
95 assert( (t1 > t2));
96 assert( (t1 >= t2));
97 }
98 {
99 typedef std::tuple<char, int> T1;
100 typedef std::tuple<double, char> T2;
101 const T1 t1(1, 2);
102 const T2 t2(1.1, 2);
103 assert( (t1 < t2));
104 assert( (t1 <= t2));
105 assert(!(t1 > t2));
106 assert(!(t1 >= t2));
107 }
108 {
109 typedef std::tuple<char, int> T1;
110 typedef std::tuple<double, char> T2;
111 const T1 t1(1, 2);
112 const T2 t2(1, 1);
113 assert(!(t1 < t2));
114 assert(!(t1 <= t2));
115 assert( (t1 > t2));
116 assert( (t1 >= t2));
117 }
118 {
119 typedef std::tuple<char, int> T1;
120 typedef std::tuple<double, char> T2;
121 const T1 t1(1, 2);
122 const T2 t2(1, 3);
123 assert( (t1 < t2));
124 assert( (t1 <= t2));
125 assert(!(t1 > t2));
126 assert(!(t1 >= t2));
127 }
128 {
129 typedef std::tuple<char, int, double> T1;
130 typedef std::tuple<double, char, int> T2;
131 const T1 t1(1, 2, 3);
132 const T2 t2(1, 2, 3);
133 assert(!(t1 < t2));
134 assert( (t1 <= t2));
135 assert(!(t1 > t2));
136 assert( (t1 >= t2));
137 }
138 {
139 typedef std::tuple<char, int, double> T1;
140 typedef std::tuple<double, char, int> T2;
141 const T1 t1(1, 2, 3);
142 const T2 t2(0.9, 2, 3);
143 assert(!(t1 < t2));
144 assert(!(t1 <= t2));
145 assert( (t1 > t2));
146 assert( (t1 >= t2));
147 }
148 {
149 typedef std::tuple<char, int, double> T1;
150 typedef std::tuple<double, char, int> T2;
151 const T1 t1(1, 2, 3);
152 const T2 t2(1.1, 2, 3);
153 assert( (t1 < t2));
154 assert( (t1 <= t2));
155 assert(!(t1 > t2));
156 assert(!(t1 >= t2));
157 }
158 {
159 typedef std::tuple<char, int, double> T1;
160 typedef std::tuple<double, char, int> T2;
161 const T1 t1(1, 2, 3);
162 const T2 t2(1, 1, 3);
163 assert(!(t1 < t2));
164 assert(!(t1 <= t2));
165 assert( (t1 > t2));
166 assert( (t1 >= t2));
167 }
168 {
169 typedef std::tuple<char, int, double> T1;
170 typedef std::tuple<double, char, int> T2;
171 const T1 t1(1, 2, 3);
172 const T2 t2(1, 3, 3);
173 assert( (t1 < t2));
174 assert( (t1 <= t2));
175 assert(!(t1 > t2));
176 assert(!(t1 >= t2));
177 }
178 {
179 typedef std::tuple<char, int, double> T1;
180 typedef std::tuple<double, char, int> T2;
181 const T1 t1(1, 2, 3);
182 const T2 t2(1, 2, 2);
183 assert(!(t1 < t2));
184 assert(!(t1 <= t2));
185 assert( (t1 > t2));
186 assert( (t1 >= t2));
187 }
188 {
189 typedef std::tuple<char, int, double> T1;
190 typedef std::tuple<double, char, int> T2;
191 const T1 t1(1, 2, 3);
192 const T2 t2(1, 2, 4);
193 assert( (t1 < t2));
194 assert( (t1 <= t2));
195 assert(!(t1 > t2));
196 assert(!(t1 >= t2));
197 }
198 #if _LIBCPP_STD_VER > 11
199 {
200 typedef std::tuple<char, int, double> T1;
201 typedef std::tuple<double, char, int> T2;
202 constexpr T1 t1(1, 2, 3);
203 constexpr T2 t2(1, 2, 4);
204 static_assert( (t1 < t2), "");
205 static_assert( (t1 <= t2), "");
206 static_assert(!(t1 > t2), "");
207 static_assert(!(t1 >= t2), "");
208 }
209 #endif
210 }
211