gtest/test/gtest-tuple_test.cc - platform/external/protobuf - Git at Google

 // 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.
 //
 // Author: wan@google.com (Zhanyong Wan)

 #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 tuple's default constructor.
 TEST(TupleConstructorTest, DefaultConstructor) {
   // We are just testing that the following compiles.
   tuple<> empty;
   tuple<int> one_field;
   tuple<double, char, bool*> three_fields;
 }

 // 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
	// 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.
	//
	// Author: wan@google.com (Zhanyong Wan)

	#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 tuple's default constructor.
	TEST(TupleConstructorTest, DefaultConstructor) {
	// We are just testing that the following compiles.
	tuple<> empty;
	tuple<int> one_field;
	tuple<double, char, bool*> three_fields;
	}

	// 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