1 |
2 |
jamieiles |
// Copyright 2007, Google Inc.
|
2 |
|
|
// All rights reserved.
|
3 |
|
|
//
|
4 |
|
|
// Redistribution and use in source and binary forms, with or without
|
5 |
|
|
// modification, are permitted provided that the following conditions are
|
6 |
|
|
// met:
|
7 |
|
|
//
|
8 |
|
|
// * Redistributions of source code must retain the above copyright
|
9 |
|
|
// notice, this list of conditions and the following disclaimer.
|
10 |
|
|
// * Redistributions in binary form must reproduce the above
|
11 |
|
|
// copyright notice, this list of conditions and the following disclaimer
|
12 |
|
|
// in the documentation and/or other materials provided with the
|
13 |
|
|
// distribution.
|
14 |
|
|
// * Neither the name of Google Inc. nor the names of its
|
15 |
|
|
// contributors may be used to endorse or promote products derived from
|
16 |
|
|
// this software without specific prior written permission.
|
17 |
|
|
//
|
18 |
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
19 |
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
20 |
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
21 |
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
22 |
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
23 |
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
24 |
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
25 |
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
26 |
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
27 |
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
28 |
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
29 |
|
|
//
|
30 |
|
|
// Author: wan@google.com (Zhanyong Wan)
|
31 |
|
|
|
32 |
|
|
#include "gtest/internal/gtest-tuple.h"
|
33 |
|
|
#include <utility>
|
34 |
|
|
#include "gtest/gtest.h"
|
35 |
|
|
|
36 |
|
|
namespace {
|
37 |
|
|
|
38 |
|
|
using ::std::tr1::get;
|
39 |
|
|
using ::std::tr1::make_tuple;
|
40 |
|
|
using ::std::tr1::tuple;
|
41 |
|
|
using ::std::tr1::tuple_element;
|
42 |
|
|
using ::std::tr1::tuple_size;
|
43 |
|
|
using ::testing::StaticAssertTypeEq;
|
44 |
|
|
|
45 |
|
|
// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.
|
46 |
|
|
TEST(tuple_element_Test, ReturnsElementType) {
|
47 |
|
|
StaticAssertTypeEq<int, tuple_element<0, tuple<int, char> >::type>();
|
48 |
|
|
StaticAssertTypeEq<int&, tuple_element<1, tuple<double, int&> >::type>();
|
49 |
|
|
StaticAssertTypeEq<bool, tuple_element<2, tuple<double, int, bool> >::type>();
|
50 |
|
|
}
|
51 |
|
|
|
52 |
|
|
// Tests that tuple_size<T>::value gives the number of fields in tuple
|
53 |
|
|
// type T.
|
54 |
|
|
TEST(tuple_size_Test, ReturnsNumberOfFields) {
|
55 |
|
|
EXPECT_EQ(0, +tuple_size<tuple<> >::value);
|
56 |
|
|
EXPECT_EQ(1, +tuple_size<tuple<void*> >::value);
|
57 |
|
|
EXPECT_EQ(1, +tuple_size<tuple<char> >::value);
|
58 |
|
|
EXPECT_EQ(1, +(tuple_size<tuple<tuple<int, double> > >::value));
|
59 |
|
|
EXPECT_EQ(2, +(tuple_size<tuple<int&, const char> >::value));
|
60 |
|
|
EXPECT_EQ(3, +(tuple_size<tuple<char*, void, const bool&> >::value));
|
61 |
|
|
}
|
62 |
|
|
|
63 |
|
|
// Tests comparing a tuple with itself.
|
64 |
|
|
TEST(ComparisonTest, ComparesWithSelf) {
|
65 |
|
|
const tuple<int, char, bool> a(5, 'a', false);
|
66 |
|
|
|
67 |
|
|
EXPECT_TRUE(a == a);
|
68 |
|
|
EXPECT_FALSE(a != a);
|
69 |
|
|
}
|
70 |
|
|
|
71 |
|
|
// Tests comparing two tuples with the same value.
|
72 |
|
|
TEST(ComparisonTest, ComparesEqualTuples) {
|
73 |
|
|
const tuple<int, bool> a(5, true), b(5, true);
|
74 |
|
|
|
75 |
|
|
EXPECT_TRUE(a == b);
|
76 |
|
|
EXPECT_FALSE(a != b);
|
77 |
|
|
}
|
78 |
|
|
|
79 |
|
|
// Tests comparing two different tuples that have no reference fields.
|
80 |
|
|
TEST(ComparisonTest, ComparesUnequalTuplesWithoutReferenceFields) {
|
81 |
|
|
typedef tuple<const int, char> FooTuple;
|
82 |
|
|
|
83 |
|
|
const FooTuple a(0, 'x');
|
84 |
|
|
const FooTuple b(1, 'a');
|
85 |
|
|
|
86 |
|
|
EXPECT_TRUE(a != b);
|
87 |
|
|
EXPECT_FALSE(a == b);
|
88 |
|
|
|
89 |
|
|
const FooTuple c(1, 'b');
|
90 |
|
|
|
91 |
|
|
EXPECT_TRUE(b != c);
|
92 |
|
|
EXPECT_FALSE(b == c);
|
93 |
|
|
}
|
94 |
|
|
|
95 |
|
|
// Tests comparing two different tuples that have reference fields.
|
96 |
|
|
TEST(ComparisonTest, ComparesUnequalTuplesWithReferenceFields) {
|
97 |
|
|
typedef tuple<int&, const char&> FooTuple;
|
98 |
|
|
|
99 |
|
|
int i = 5;
|
100 |
|
|
const char ch = 'a';
|
101 |
|
|
const FooTuple a(i, ch);
|
102 |
|
|
|
103 |
|
|
int j = 6;
|
104 |
|
|
const FooTuple b(j, ch);
|
105 |
|
|
|
106 |
|
|
EXPECT_TRUE(a != b);
|
107 |
|
|
EXPECT_FALSE(a == b);
|
108 |
|
|
|
109 |
|
|
j = 5;
|
110 |
|
|
const char ch2 = 'b';
|
111 |
|
|
const FooTuple c(j, ch2);
|
112 |
|
|
|
113 |
|
|
EXPECT_TRUE(b != c);
|
114 |
|
|
EXPECT_FALSE(b == c);
|
115 |
|
|
}
|
116 |
|
|
|
117 |
|
|
// Tests that a tuple field with a reference type is an alias of the
|
118 |
|
|
// variable it's supposed to reference.
|
119 |
|
|
TEST(ReferenceFieldTest, IsAliasOfReferencedVariable) {
|
120 |
|
|
int n = 0;
|
121 |
|
|
tuple<bool, int&> t(true, n);
|
122 |
|
|
|
123 |
|
|
n = 1;
|
124 |
|
|
EXPECT_EQ(n, get<1>(t))
|
125 |
|
|
<< "Changing a underlying variable should update the reference field.";
|
126 |
|
|
|
127 |
|
|
// Makes sure that the implementation doesn't do anything funny with
|
128 |
|
|
// the & operator for the return type of get<>().
|
129 |
|
|
EXPECT_EQ(&n, &(get<1>(t)))
|
130 |
|
|
<< "The address of a reference field should equal the address of "
|
131 |
|
|
<< "the underlying variable.";
|
132 |
|
|
|
133 |
|
|
get<1>(t) = 2;
|
134 |
|
|
EXPECT_EQ(2, n)
|
135 |
|
|
<< "Changing a reference field should update the underlying variable.";
|
136 |
|
|
}
|
137 |
|
|
|
138 |
|
|
// Tests that tuple's default constructor default initializes each field.
|
139 |
|
|
// This test needs to compile without generating warnings.
|
140 |
|
|
TEST(TupleConstructorTest, DefaultConstructorDefaultInitializesEachField) {
|
141 |
|
|
// The TR1 report requires that tuple's default constructor default
|
142 |
|
|
// initializes each field, even if it's a primitive type. If the
|
143 |
|
|
// implementation forgets to do this, this test will catch it by
|
144 |
|
|
// generating warnings about using uninitialized variables (assuming
|
145 |
|
|
// a decent compiler).
|
146 |
|
|
|
147 |
|
|
tuple<> empty;
|
148 |
|
|
|
149 |
|
|
tuple<int> a1, b1;
|
150 |
|
|
b1 = a1;
|
151 |
|
|
EXPECT_EQ(0, get<0>(b1));
|
152 |
|
|
|
153 |
|
|
tuple<int, double> a2, b2;
|
154 |
|
|
b2 = a2;
|
155 |
|
|
EXPECT_EQ(0, get<0>(b2));
|
156 |
|
|
EXPECT_EQ(0.0, get<1>(b2));
|
157 |
|
|
|
158 |
|
|
tuple<double, char, bool*> a3, b3;
|
159 |
|
|
b3 = a3;
|
160 |
|
|
EXPECT_EQ(0.0, get<0>(b3));
|
161 |
|
|
EXPECT_EQ('\0', get<1>(b3));
|
162 |
|
|
EXPECT_TRUE(get<2>(b3) == NULL);
|
163 |
|
|
|
164 |
|
|
tuple<int, int, int, int, int, int, int, int, int, int> a10, b10;
|
165 |
|
|
b10 = a10;
|
166 |
|
|
EXPECT_EQ(0, get<0>(b10));
|
167 |
|
|
EXPECT_EQ(0, get<1>(b10));
|
168 |
|
|
EXPECT_EQ(0, get<2>(b10));
|
169 |
|
|
EXPECT_EQ(0, get<3>(b10));
|
170 |
|
|
EXPECT_EQ(0, get<4>(b10));
|
171 |
|
|
EXPECT_EQ(0, get<5>(b10));
|
172 |
|
|
EXPECT_EQ(0, get<6>(b10));
|
173 |
|
|
EXPECT_EQ(0, get<7>(b10));
|
174 |
|
|
EXPECT_EQ(0, get<8>(b10));
|
175 |
|
|
EXPECT_EQ(0, get<9>(b10));
|
176 |
|
|
}
|
177 |
|
|
|
178 |
|
|
// Tests constructing a tuple from its fields.
|
179 |
|
|
TEST(TupleConstructorTest, ConstructsFromFields) {
|
180 |
|
|
int n = 1;
|
181 |
|
|
// Reference field.
|
182 |
|
|
tuple<int&> a(n);
|
183 |
|
|
EXPECT_EQ(&n, &(get<0>(a)));
|
184 |
|
|
|
185 |
|
|
// Non-reference fields.
|
186 |
|
|
tuple<int, char> b(5, 'a');
|
187 |
|
|
EXPECT_EQ(5, get<0>(b));
|
188 |
|
|
EXPECT_EQ('a', get<1>(b));
|
189 |
|
|
|
190 |
|
|
// Const reference field.
|
191 |
|
|
const int m = 2;
|
192 |
|
|
tuple<bool, const int&> c(true, m);
|
193 |
|
|
EXPECT_TRUE(get<0>(c));
|
194 |
|
|
EXPECT_EQ(&m, &(get<1>(c)));
|
195 |
|
|
}
|
196 |
|
|
|
197 |
|
|
// Tests tuple's copy constructor.
|
198 |
|
|
TEST(TupleConstructorTest, CopyConstructor) {
|
199 |
|
|
tuple<double, bool> a(0.0, true);
|
200 |
|
|
tuple<double, bool> b(a);
|
201 |
|
|
|
202 |
|
|
EXPECT_DOUBLE_EQ(0.0, get<0>(b));
|
203 |
|
|
EXPECT_TRUE(get<1>(b));
|
204 |
|
|
}
|
205 |
|
|
|
206 |
|
|
// Tests constructing a tuple from another tuple that has a compatible
|
207 |
|
|
// but different type.
|
208 |
|
|
TEST(TupleConstructorTest, ConstructsFromDifferentTupleType) {
|
209 |
|
|
tuple<int, int, char> a(0, 1, 'a');
|
210 |
|
|
tuple<double, long, int> b(a);
|
211 |
|
|
|
212 |
|
|
EXPECT_DOUBLE_EQ(0.0, get<0>(b));
|
213 |
|
|
EXPECT_EQ(1, get<1>(b));
|
214 |
|
|
EXPECT_EQ('a', get<2>(b));
|
215 |
|
|
}
|
216 |
|
|
|
217 |
|
|
// Tests constructing a 2-tuple from an std::pair.
|
218 |
|
|
TEST(TupleConstructorTest, ConstructsFromPair) {
|
219 |
|
|
::std::pair<int, char> a(1, 'a');
|
220 |
|
|
tuple<int, char> b(a);
|
221 |
|
|
tuple<int, const char&> c(a);
|
222 |
|
|
}
|
223 |
|
|
|
224 |
|
|
// Tests assigning a tuple to another tuple with the same type.
|
225 |
|
|
TEST(TupleAssignmentTest, AssignsToSameTupleType) {
|
226 |
|
|
const tuple<int, long> a(5, 7L);
|
227 |
|
|
tuple<int, long> b;
|
228 |
|
|
b = a;
|
229 |
|
|
EXPECT_EQ(5, get<0>(b));
|
230 |
|
|
EXPECT_EQ(7L, get<1>(b));
|
231 |
|
|
}
|
232 |
|
|
|
233 |
|
|
// Tests assigning a tuple to another tuple with a different but
|
234 |
|
|
// compatible type.
|
235 |
|
|
TEST(TupleAssignmentTest, AssignsToDifferentTupleType) {
|
236 |
|
|
const tuple<int, long, bool> a(1, 7L, true);
|
237 |
|
|
tuple<long, int, bool> b;
|
238 |
|
|
b = a;
|
239 |
|
|
EXPECT_EQ(1L, get<0>(b));
|
240 |
|
|
EXPECT_EQ(7, get<1>(b));
|
241 |
|
|
EXPECT_TRUE(get<2>(b));
|
242 |
|
|
}
|
243 |
|
|
|
244 |
|
|
// Tests assigning an std::pair to a 2-tuple.
|
245 |
|
|
TEST(TupleAssignmentTest, AssignsFromPair) {
|
246 |
|
|
const ::std::pair<int, bool> a(5, true);
|
247 |
|
|
tuple<int, bool> b;
|
248 |
|
|
b = a;
|
249 |
|
|
EXPECT_EQ(5, get<0>(b));
|
250 |
|
|
EXPECT_TRUE(get<1>(b));
|
251 |
|
|
|
252 |
|
|
tuple<long, bool> c;
|
253 |
|
|
c = a;
|
254 |
|
|
EXPECT_EQ(5L, get<0>(c));
|
255 |
|
|
EXPECT_TRUE(get<1>(c));
|
256 |
|
|
}
|
257 |
|
|
|
258 |
|
|
// A fixture for testing big tuples.
|
259 |
|
|
class BigTupleTest : public testing::Test {
|
260 |
|
|
protected:
|
261 |
|
|
typedef tuple<int, int, int, int, int, int, int, int, int, int> BigTuple;
|
262 |
|
|
|
263 |
|
|
BigTupleTest() :
|
264 |
|
|
a_(1, 0, 0, 0, 0, 0, 0, 0, 0, 2),
|
265 |
|
|
b_(1, 0, 0, 0, 0, 0, 0, 0, 0, 3) {}
|
266 |
|
|
|
267 |
|
|
BigTuple a_, b_;
|
268 |
|
|
};
|
269 |
|
|
|
270 |
|
|
// Tests constructing big tuples.
|
271 |
|
|
TEST_F(BigTupleTest, Construction) {
|
272 |
|
|
BigTuple a;
|
273 |
|
|
BigTuple b(b_);
|
274 |
|
|
}
|
275 |
|
|
|
276 |
|
|
// Tests that get<N>(t) returns the N-th (0-based) field of tuple t.
|
277 |
|
|
TEST_F(BigTupleTest, get) {
|
278 |
|
|
EXPECT_EQ(1, get<0>(a_));
|
279 |
|
|
EXPECT_EQ(2, get<9>(a_));
|
280 |
|
|
|
281 |
|
|
// Tests that get() works on a const tuple too.
|
282 |
|
|
const BigTuple a(a_);
|
283 |
|
|
EXPECT_EQ(1, get<0>(a));
|
284 |
|
|
EXPECT_EQ(2, get<9>(a));
|
285 |
|
|
}
|
286 |
|
|
|
287 |
|
|
// Tests comparing big tuples.
|
288 |
|
|
TEST_F(BigTupleTest, Comparisons) {
|
289 |
|
|
EXPECT_TRUE(a_ == a_);
|
290 |
|
|
EXPECT_FALSE(a_ != a_);
|
291 |
|
|
|
292 |
|
|
EXPECT_TRUE(a_ != b_);
|
293 |
|
|
EXPECT_FALSE(a_ == b_);
|
294 |
|
|
}
|
295 |
|
|
|
296 |
|
|
TEST(MakeTupleTest, WorksForScalarTypes) {
|
297 |
|
|
tuple<bool, int> a;
|
298 |
|
|
a = make_tuple(true, 5);
|
299 |
|
|
EXPECT_TRUE(get<0>(a));
|
300 |
|
|
EXPECT_EQ(5, get<1>(a));
|
301 |
|
|
|
302 |
|
|
tuple<char, int, long> b;
|
303 |
|
|
b = make_tuple('a', 'b', 5);
|
304 |
|
|
EXPECT_EQ('a', get<0>(b));
|
305 |
|
|
EXPECT_EQ('b', get<1>(b));
|
306 |
|
|
EXPECT_EQ(5, get<2>(b));
|
307 |
|
|
}
|
308 |
|
|
|
309 |
|
|
TEST(MakeTupleTest, WorksForPointers) {
|
310 |
|
|
int a[] = { 1, 2, 3, 4 };
|
311 |
|
|
const char* const str = "hi";
|
312 |
|
|
int* const p = a;
|
313 |
|
|
|
314 |
|
|
tuple<const char*, int*> t;
|
315 |
|
|
t = make_tuple(str, p);
|
316 |
|
|
EXPECT_EQ(str, get<0>(t));
|
317 |
|
|
EXPECT_EQ(p, get<1>(t));
|
318 |
|
|
}
|
319 |
|
|
|
320 |
|
|
} // namespace
|