Changeset View
Changeset View
Standalone View
Standalone View
google/googletest/dist/googletest/test/googletest-tuple-test.cc
- This file was added.
Property | Old Value | New Value |
---|---|---|
svn:eol-style | null | native \ No newline at end of property |
svn:keywords | null | FreeBSD=%H \ No newline at end of property |
svn:mime-type | null | text/plain \ No newline at end of property |
// Copyright 2007, Google Inc. | |||||
// All rights reserved. | |||||
// | |||||
// Redistribution and use in source and binary forms, with or without | |||||
// modification, are permitted provided that the following conditions are | |||||
// met: | |||||
// | |||||
// * Redistributions of source code must retain the above copyright | |||||
// notice, this list of conditions and the following disclaimer. | |||||
// * Redistributions in binary form must reproduce the above | |||||
// copyright notice, this list of conditions and the following disclaimer | |||||
// in the documentation and/or other materials provided with the | |||||
// distribution. | |||||
// * Neither the name of Google Inc. nor the names of its | |||||
// contributors may be used to endorse or promote products derived from | |||||
// this software without specific prior written permission. | |||||
// | |||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||||
#include "gtest/internal/gtest-tuple.h" | |||||
#include <utility> | |||||
#include "gtest/gtest.h" | |||||
namespace { | |||||
using ::std::tr1::get; | |||||
using ::std::tr1::make_tuple; | |||||
using ::std::tr1::tuple; | |||||
using ::std::tr1::tuple_element; | |||||
using ::std::tr1::tuple_size; | |||||
using ::testing::StaticAssertTypeEq; | |||||
// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK. | |||||
TEST(tuple_element_Test, ReturnsElementType) { | |||||
StaticAssertTypeEq<int, tuple_element<0, tuple<int, char> >::type>(); | |||||
StaticAssertTypeEq<int&, tuple_element<1, tuple<double, int&> >::type>(); | |||||
StaticAssertTypeEq<bool, tuple_element<2, tuple<double, int, bool> >::type>(); | |||||
} | |||||
// Tests that tuple_size<T>::value gives the number of fields in tuple | |||||
// type T. | |||||
TEST(tuple_size_Test, ReturnsNumberOfFields) { | |||||
EXPECT_EQ(0, +tuple_size<tuple<> >::value); | |||||
EXPECT_EQ(1, +tuple_size<tuple<void*> >::value); | |||||
EXPECT_EQ(1, +tuple_size<tuple<char> >::value); | |||||
EXPECT_EQ(1, +(tuple_size<tuple<tuple<int, double> > >::value)); | |||||
EXPECT_EQ(2, +(tuple_size<tuple<int&, const char> >::value)); | |||||
EXPECT_EQ(3, +(tuple_size<tuple<char*, void, const bool&> >::value)); | |||||
} | |||||
// Tests comparing a tuple with itself. | |||||
TEST(ComparisonTest, ComparesWithSelf) { | |||||
const tuple<int, char, bool> a(5, 'a', false); | |||||
EXPECT_TRUE(a == a); | |||||
EXPECT_FALSE(a != a); | |||||
} | |||||
// Tests comparing two tuples with the same value. | |||||
TEST(ComparisonTest, ComparesEqualTuples) { | |||||
const tuple<int, bool> a(5, true), b(5, true); | |||||
EXPECT_TRUE(a == b); | |||||
EXPECT_FALSE(a != b); | |||||
} | |||||
// Tests comparing two different tuples that have no reference fields. | |||||
TEST(ComparisonTest, ComparesUnequalTuplesWithoutReferenceFields) { | |||||
typedef tuple<const int, char> FooTuple; | |||||
const FooTuple a(0, 'x'); | |||||
const FooTuple b(1, 'a'); | |||||
EXPECT_TRUE(a != b); | |||||
EXPECT_FALSE(a == b); | |||||
const FooTuple c(1, 'b'); | |||||
EXPECT_TRUE(b != c); | |||||
EXPECT_FALSE(b == c); | |||||
} | |||||
// Tests comparing two different tuples that have reference fields. | |||||
TEST(ComparisonTest, ComparesUnequalTuplesWithReferenceFields) { | |||||
typedef tuple<int&, const char&> FooTuple; | |||||
int i = 5; | |||||
const char ch = 'a'; | |||||
const FooTuple a(i, ch); | |||||
int j = 6; | |||||
const FooTuple b(j, ch); | |||||
EXPECT_TRUE(a != b); | |||||
EXPECT_FALSE(a == b); | |||||
j = 5; | |||||
const char ch2 = 'b'; | |||||
const FooTuple c(j, ch2); | |||||
EXPECT_TRUE(b != c); | |||||
EXPECT_FALSE(b == c); | |||||
} | |||||
// Tests that a tuple field with a reference type is an alias of the | |||||
// variable it's supposed to reference. | |||||
TEST(ReferenceFieldTest, IsAliasOfReferencedVariable) { | |||||
int n = 0; | |||||
tuple<bool, int&> t(true, n); | |||||
n = 1; | |||||
EXPECT_EQ(n, get<1>(t)) | |||||
<< "Changing a underlying variable should update the reference field."; | |||||
// Makes sure that the implementation doesn't do anything funny with | |||||
// the & operator for the return type of get<>(). | |||||
EXPECT_EQ(&n, &(get<1>(t))) | |||||
<< "The address of a reference field should equal the address of " | |||||
<< "the underlying variable."; | |||||
get<1>(t) = 2; | |||||
EXPECT_EQ(2, n) | |||||
<< "Changing a reference field should update the underlying variable."; | |||||
} | |||||
// Tests that tuple's default constructor default initializes each field. | |||||
// This test needs to compile without generating warnings. | |||||
TEST(TupleConstructorTest, DefaultConstructorDefaultInitializesEachField) { | |||||
// The TR1 report requires that tuple's default constructor default | |||||
// initializes each field, even if it's a primitive type. If the | |||||
// implementation forgets to do this, this test will catch it by | |||||
// generating warnings about using uninitialized variables (assuming | |||||
// a decent compiler). | |||||
tuple<> empty; | |||||
tuple<int> a1, b1; | |||||
b1 = a1; | |||||
EXPECT_EQ(0, get<0>(b1)); | |||||
tuple<int, double> a2, b2; | |||||
b2 = a2; | |||||
EXPECT_EQ(0, get<0>(b2)); | |||||
EXPECT_EQ(0.0, get<1>(b2)); | |||||
tuple<double, char, bool*> a3, b3; | |||||
b3 = a3; | |||||
EXPECT_EQ(0.0, get<0>(b3)); | |||||
EXPECT_EQ('\0', get<1>(b3)); | |||||
EXPECT_TRUE(get<2>(b3) == NULL); | |||||
tuple<int, int, int, int, int, int, int, int, int, int> a10, b10; | |||||
b10 = a10; | |||||
EXPECT_EQ(0, get<0>(b10)); | |||||
EXPECT_EQ(0, get<1>(b10)); | |||||
EXPECT_EQ(0, get<2>(b10)); | |||||
EXPECT_EQ(0, get<3>(b10)); | |||||
EXPECT_EQ(0, get<4>(b10)); | |||||
EXPECT_EQ(0, get<5>(b10)); | |||||
EXPECT_EQ(0, get<6>(b10)); | |||||
EXPECT_EQ(0, get<7>(b10)); | |||||
EXPECT_EQ(0, get<8>(b10)); | |||||
EXPECT_EQ(0, get<9>(b10)); | |||||
} | |||||
// Tests constructing a tuple from its fields. | |||||
TEST(TupleConstructorTest, ConstructsFromFields) { | |||||
int n = 1; | |||||
// Reference field. | |||||
tuple<int&> a(n); | |||||
EXPECT_EQ(&n, &(get<0>(a))); | |||||
// Non-reference fields. | |||||
tuple<int, char> b(5, 'a'); | |||||
EXPECT_EQ(5, get<0>(b)); | |||||
EXPECT_EQ('a', get<1>(b)); | |||||
// Const reference field. | |||||
const int m = 2; | |||||
tuple<bool, const int&> c(true, m); | |||||
EXPECT_TRUE(get<0>(c)); | |||||
EXPECT_EQ(&m, &(get<1>(c))); | |||||
} | |||||
// Tests tuple's copy constructor. | |||||
TEST(TupleConstructorTest, CopyConstructor) { | |||||
tuple<double, bool> a(0.0, true); | |||||
tuple<double, bool> b(a); | |||||
EXPECT_DOUBLE_EQ(0.0, get<0>(b)); | |||||
EXPECT_TRUE(get<1>(b)); | |||||
} | |||||
// Tests constructing a tuple from another tuple that has a compatible | |||||
// but different type. | |||||
TEST(TupleConstructorTest, ConstructsFromDifferentTupleType) { | |||||
tuple<int, int, char> a(0, 1, 'a'); | |||||
tuple<double, long, int> b(a); | |||||
EXPECT_DOUBLE_EQ(0.0, get<0>(b)); | |||||
EXPECT_EQ(1, get<1>(b)); | |||||
EXPECT_EQ('a', get<2>(b)); | |||||
} | |||||
// Tests constructing a 2-tuple from an std::pair. | |||||
TEST(TupleConstructorTest, ConstructsFromPair) { | |||||
::std::pair<int, char> a(1, 'a'); | |||||
tuple<int, char> b(a); | |||||
tuple<int, const char&> c(a); | |||||
} | |||||
// Tests assigning a tuple to another tuple with the same type. | |||||
TEST(TupleAssignmentTest, AssignsToSameTupleType) { | |||||
const tuple<int, long> a(5, 7L); | |||||
tuple<int, long> b; | |||||
b = a; | |||||
EXPECT_EQ(5, get<0>(b)); | |||||
EXPECT_EQ(7L, get<1>(b)); | |||||
} | |||||
// Tests assigning a tuple to another tuple with a different but | |||||
// compatible type. | |||||
TEST(TupleAssignmentTest, AssignsToDifferentTupleType) { | |||||
const tuple<int, long, bool> a(1, 7L, true); | |||||
tuple<long, int, bool> b; | |||||
b = a; | |||||
EXPECT_EQ(1L, get<0>(b)); | |||||
EXPECT_EQ(7, get<1>(b)); | |||||
EXPECT_TRUE(get<2>(b)); | |||||
} | |||||
// Tests assigning an std::pair to a 2-tuple. | |||||
TEST(TupleAssignmentTest, AssignsFromPair) { | |||||
const ::std::pair<int, bool> a(5, true); | |||||
tuple<int, bool> b; | |||||
b = a; | |||||
EXPECT_EQ(5, get<0>(b)); | |||||
EXPECT_TRUE(get<1>(b)); | |||||
tuple<long, bool> c; | |||||
c = a; | |||||
EXPECT_EQ(5L, get<0>(c)); | |||||
EXPECT_TRUE(get<1>(c)); | |||||
} | |||||
// A fixture for testing big tuples. | |||||
class BigTupleTest : public testing::Test { | |||||
protected: | |||||
typedef tuple<int, int, int, int, int, int, int, int, int, int> BigTuple; | |||||
BigTupleTest() : | |||||
a_(1, 0, 0, 0, 0, 0, 0, 0, 0, 2), | |||||
b_(1, 0, 0, 0, 0, 0, 0, 0, 0, 3) {} | |||||
BigTuple a_, b_; | |||||
}; | |||||
// Tests constructing big tuples. | |||||
TEST_F(BigTupleTest, Construction) { | |||||
BigTuple a; | |||||
BigTuple b(b_); | |||||
} | |||||
// Tests that get<N>(t) returns the N-th (0-based) field of tuple t. | |||||
TEST_F(BigTupleTest, get) { | |||||
EXPECT_EQ(1, get<0>(a_)); | |||||
EXPECT_EQ(2, get<9>(a_)); | |||||
// Tests that get() works on a const tuple too. | |||||
const BigTuple a(a_); | |||||
EXPECT_EQ(1, get<0>(a)); | |||||
EXPECT_EQ(2, get<9>(a)); | |||||
} | |||||
// Tests comparing big tuples. | |||||
TEST_F(BigTupleTest, Comparisons) { | |||||
EXPECT_TRUE(a_ == a_); | |||||
EXPECT_FALSE(a_ != a_); | |||||
EXPECT_TRUE(a_ != b_); | |||||
EXPECT_FALSE(a_ == b_); | |||||
} | |||||
TEST(MakeTupleTest, WorksForScalarTypes) { | |||||
tuple<bool, int> a; | |||||
a = make_tuple(true, 5); | |||||
EXPECT_TRUE(get<0>(a)); | |||||
EXPECT_EQ(5, get<1>(a)); | |||||
tuple<char, int, long> b; | |||||
b = make_tuple('a', 'b', 5); | |||||
EXPECT_EQ('a', get<0>(b)); | |||||
EXPECT_EQ('b', get<1>(b)); | |||||
EXPECT_EQ(5, get<2>(b)); | |||||
} | |||||
TEST(MakeTupleTest, WorksForPointers) { | |||||
int a[] = { 1, 2, 3, 4 }; | |||||
const char* const str = "hi"; | |||||
int* const p = a; | |||||
tuple<const char*, int*> t; | |||||
t = make_tuple(str, p); | |||||
EXPECT_EQ(str, get<0>(t)); | |||||
EXPECT_EQ(p, get<1>(t)); | |||||
} | |||||
} // namespace |