1 // 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 (at) 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 321
