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
36int 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