6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 19:31:58 +00:00
Code Issues Projects Releases Wiki Activity

Move the SmallVector unit tests to be type-parameterized so that we can

Browse Source 
test more than a single instantiation of SmallVector.

Add testing for 0, 1, 2, and 4 element sized "small" buffers. These
appear to be essentially untested in the unit tests until now.

Fix several tests to be robust in the face of a '0' small buffer. As
a consequence of this size buffer, the growth patterns are actually
observable in the test -- yes this means that many tests never caused
a grow to occur before. For some tests I've merely added a reserve call
to normalize behavior. For others, the growth is actually interesting,
and so I captured the fact that growth would occur and adjusted the
assertions to not assume how rapidly growth occured.

Also update the specialization for a '0' small buffer length to have all
the same interface points as the normal small vector.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@161001 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chandler Carruth 2012-07-30 22:17:52 +00:00
parent 20f13c50d8
commit ba1f580f33
2 changed files with 193 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/llvm/ADT/SmallVector.h
View File

@ -918,7 +918,8 @@ public:
template <typename T> template <typename T>
class SmallVector<T,0> : public SmallVectorImpl<T> { class SmallVector<T,0> : public SmallVectorImpl<T> {
public: public:
SmallVector() : SmallVectorImpl<T>(0) {} SmallVector() : SmallVectorImpl<T>(0) {
}
explicit SmallVector(unsigned Size, const T &Value = T()) explicit SmallVector(unsigned Size, const T &Value = T())
: SmallVectorImpl<T>(0) { : SmallVectorImpl<T>(0) {
@ -931,13 +932,26 @@ public:
} }
SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(0) { SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(0) {
if (!RHS.empty())
SmallVectorImpl<T>::operator=(RHS);
}
const SmallVector &operator=(const SmallVector &RHS) {
SmallVectorImpl<T>::operator=(RHS); SmallVectorImpl<T>::operator=(RHS);
return *this;
} }
SmallVector &operator=(const SmallVectorImpl<T> &RHS) { #if LLVM_USE_RVALUE_REFERENCES
return SmallVectorImpl<T>::operator=(RHS); SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(0) {
if (!RHS.empty())
SmallVectorImpl<T>::operator=(::std::move(RHS));
} }
const SmallVector &operator=(SmallVector &&RHS) {
SmallVectorImpl<T>::operator=(::std::move(RHS));
return *this;
}
#endif
}; };
template<typename T, unsigned N> template<typename T, unsigned N>

325
unittests/ADT/SmallVectorTest.cpp
View File

@ -88,18 +88,17 @@ int Constructable::numDestructorCalls;
int Constructable::numAssignmentCalls; int Constructable::numAssignmentCalls;
// Test fixture class // Test fixture class
template <typename VectorT>
class SmallVectorTest : public testing::Test { class SmallVectorTest : public testing::Test {
protected: protected:
typedef SmallVector<Constructable, 4> VectorType; VectorT theVector;
VectorT otherVector;
VectorType theVector;
VectorType otherVector;
void SetUp() { void SetUp() {
Constructable::reset(); Constructable::reset();
} }
void assertEmpty(VectorType & v) { void assertEmpty(VectorT & v) {
// Size tests // Size tests
EXPECT_EQ(0u, v.size()); EXPECT_EQ(0u, v.size());
EXPECT_TRUE(v.empty()); EXPECT_TRUE(v.empty());
@ -109,7 +108,7 @@ protected:
} }
// Assert that theVector contains the specified values, in order. // Assert that theVector contains the specified values, in order.
void assertValuesInOrder(VectorType & v, size_t size, ...) { void assertValuesInOrder(VectorT & v, size_t size, ...) {
EXPECT_EQ(size, v.size()); EXPECT_EQ(size, v.size());
va_list ap; va_list ap;
@ -123,300 +122,327 @@ protected:
} }
// Generate a sequence of values to initialize the vector. // Generate a sequence of values to initialize the vector.
void makeSequence(VectorType & v, int start, int end) { void makeSequence(VectorT & v, int start, int end) {
for (int i = start; i <= end; ++i) { for (int i = start; i <= end; ++i) {
v.push_back(Constructable(i)); v.push_back(Constructable(i));
} }
} }
}; };
typedef ::testing::Types<SmallVector<Constructable, 0>,
SmallVector<Constructable, 1>,
SmallVector<Constructable, 2>,
SmallVector<Constructable, 4>
> SmallVectorTestTypes;
TYPED_TEST_CASE(SmallVectorTest, SmallVectorTestTypes);
// New vector test. // New vector test.
TEST_F(SmallVectorTest, EmptyVectorTest) { TYPED_TEST(SmallVectorTest, EmptyVectorTest) {
SCOPED_TRACE("EmptyVectorTest"); SCOPED_TRACE("EmptyVectorTest");
assertEmpty(theVector); this->assertEmpty(this->theVector);
EXPECT_TRUE(theVector.rbegin() == theVector.rend()); EXPECT_TRUE(this->theVector.rbegin() == this->theVector.rend());
EXPECT_EQ(0, Constructable::getNumConstructorCalls()); EXPECT_EQ(0, Constructable::getNumConstructorCalls());
EXPECT_EQ(0, Constructable::getNumDestructorCalls()); EXPECT_EQ(0, Constructable::getNumDestructorCalls());
} }
// Simple insertions and deletions. // Simple insertions and deletions.
TEST_F(SmallVectorTest, PushPopTest) { TYPED_TEST(SmallVectorTest, PushPopTest) {
SCOPED_TRACE("PushPopTest"); SCOPED_TRACE("PushPopTest");
// Track whether the vector will potentially have to grow.
bool RequiresGrowth = this->theVector.capacity() < 3;
// Push an element // Push an element
theVector.push_back(Constructable(1)); this->theVector.push_back(Constructable(1));
// Size tests // Size tests
assertValuesInOrder(theVector, 1u, 1); this->assertValuesInOrder(this->theVector, 1u, 1);
EXPECT_FALSE(theVector.begin() == theVector.end()); EXPECT_FALSE(this->theVector.begin() == this->theVector.end());
EXPECT_FALSE(theVector.empty()); EXPECT_FALSE(this->theVector.empty());
// Push another element // Push another element
theVector.push_back(Constructable(2)); this->theVector.push_back(Constructable(2));
assertValuesInOrder(theVector, 2u, 1, 2); this->assertValuesInOrder(this->theVector, 2u, 1, 2);
// Insert at beginning // Insert at beginning
theVector.insert(theVector.begin(), theVector[1]); this->theVector.insert(this->theVector.begin(), this->theVector[1]);
assertValuesInOrder(theVector, 3u, 2, 1, 2); this->assertValuesInOrder(this->theVector, 3u, 2, 1, 2);
// Pop one element // Pop one element
theVector.pop_back(); this->theVector.pop_back();
assertValuesInOrder(theVector, 2u, 2, 1); this->assertValuesInOrder(this->theVector, 2u, 2, 1);
// Pop remaining elements // Pop remaining elements
theVector.pop_back(); this->theVector.pop_back();
theVector.pop_back(); this->theVector.pop_back();
assertEmpty(theVector); this->assertEmpty(this->theVector);
// Check number of constructor calls. Should be 2 for each list element, // Check number of constructor calls. Should be 2 for each list element,
// one for the argument to push_back, one for the argument to insert, // one for the argument to push_back, one for the argument to insert,
// and one for the list element itself. // and one for the list element itself.
EXPECT_EQ(5, Constructable::getNumConstructorCalls()); if (!RequiresGrowth) {
EXPECT_EQ(5, Constructable::getNumDestructorCalls()); EXPECT_EQ(5, Constructable::getNumConstructorCalls());
EXPECT_EQ(5, Constructable::getNumDestructorCalls());
} else {
// If we had to grow the vector, these only have a lower bound, but should
// always be equal.
EXPECT_LE(5, Constructable::getNumConstructorCalls());
EXPECT_EQ(Constructable::getNumConstructorCalls(),
Constructable::getNumDestructorCalls());
}
} }
// Clear test. // Clear test.
TEST_F(SmallVectorTest, ClearTest) { TYPED_TEST(SmallVectorTest, ClearTest) {
SCOPED_TRACE("ClearTest"); SCOPED_TRACE("ClearTest");
makeSequence(theVector, 1, 2); this->theVector.reserve(2);
theVector.clear(); this->makeSequence(this->theVector, 1, 2);
this->theVector.clear();
assertEmpty(theVector); this->assertEmpty(this->theVector);
EXPECT_EQ(4, Constructable::getNumConstructorCalls()); EXPECT_EQ(4, Constructable::getNumConstructorCalls());
EXPECT_EQ(4, Constructable::getNumDestructorCalls()); EXPECT_EQ(4, Constructable::getNumDestructorCalls());
} }
// Resize smaller test. // Resize smaller test.
TEST_F(SmallVectorTest, ResizeShrinkTest) { TYPED_TEST(SmallVectorTest, ResizeShrinkTest) {
SCOPED_TRACE("ResizeShrinkTest"); SCOPED_TRACE("ResizeShrinkTest");
makeSequence(theVector, 1, 3); this->theVector.reserve(3);
theVector.resize(1); this->makeSequence(this->theVector, 1, 3);
this->theVector.resize(1);
assertValuesInOrder(theVector, 1u, 1); this->assertValuesInOrder(this->theVector, 1u, 1);
EXPECT_EQ(6, Constructable::getNumConstructorCalls()); EXPECT_EQ(6, Constructable::getNumConstructorCalls());
EXPECT_EQ(5, Constructable::getNumDestructorCalls()); EXPECT_EQ(5, Constructable::getNumDestructorCalls());
} }
// Resize bigger test. // Resize bigger test.
TEST_F(SmallVectorTest, ResizeGrowTest) { TYPED_TEST(SmallVectorTest, ResizeGrowTest) {
SCOPED_TRACE("ResizeGrowTest"); SCOPED_TRACE("ResizeGrowTest");
theVector.resize(2); this->theVector.resize(2);
// The extra constructor/destructor calls come from the temporary object used // The extra constructor/destructor calls come from the temporary object used
// to initialize the contents of the resized array (via copy construction). // to initialize the contents of the resized array (via copy construction).
EXPECT_EQ(3, Constructable::getNumConstructorCalls()); EXPECT_EQ(3, Constructable::getNumConstructorCalls());
EXPECT_EQ(1, Constructable::getNumDestructorCalls()); EXPECT_EQ(1, Constructable::getNumDestructorCalls());
EXPECT_EQ(2u, theVector.size()); EXPECT_EQ(2u, this->theVector.size());
} }
// Resize with fill value. // Resize with fill value.
TEST_F(SmallVectorTest, ResizeFillTest) { TYPED_TEST(SmallVectorTest, ResizeFillTest) {
SCOPED_TRACE("ResizeFillTest"); SCOPED_TRACE("ResizeFillTest");
theVector.resize(3, Constructable(77)); this->theVector.resize(3, Constructable(77));
assertValuesInOrder(theVector, 3u, 77, 77, 77); this->assertValuesInOrder(this->theVector, 3u, 77, 77, 77);
} }
// Overflow past fixed size. // Overflow past fixed size.
TEST_F(SmallVectorTest, OverflowTest) { TYPED_TEST(SmallVectorTest, OverflowTest) {
SCOPED_TRACE("OverflowTest"); SCOPED_TRACE("OverflowTest");
// Push more elements than the fixed size. // Push more elements than the fixed size.
makeSequence(theVector, 1, 10); this->makeSequence(this->theVector, 1, 10);
// Test size and values. // Test size and values.
EXPECT_EQ(10u, theVector.size()); EXPECT_EQ(10u, this->theVector.size());
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
EXPECT_EQ(i+1, theVector[i].getValue()); EXPECT_EQ(i+1, this->theVector[i].getValue());
} }
// Now resize back to fixed size. // Now resize back to fixed size.
theVector.resize(1); this->theVector.resize(1);
assertValuesInOrder(theVector, 1u, 1); this->assertValuesInOrder(this->theVector, 1u, 1);
} }
// Iteration tests. // Iteration tests.
TEST_F(SmallVectorTest, IterationTest) { TYPED_TEST(SmallVectorTest, IterationTest) {
makeSequence(theVector, 1, 2); this->makeSequence(this->theVector, 1, 2);
// Forward Iteration // Forward Iteration
VectorType::iterator it = theVector.begin(); typename TypeParam::iterator it = this->theVector.begin();
EXPECT_TRUE(*it == theVector.front()); EXPECT_TRUE(*it == this->theVector.front());
EXPECT_TRUE(*it == theVector[0]); EXPECT_TRUE(*it == this->theVector[0]);
EXPECT_EQ(1, it->getValue()); EXPECT_EQ(1, it->getValue());
++it; ++it;
EXPECT_TRUE(*it == theVector[1]); EXPECT_TRUE(*it == this->theVector[1]);
EXPECT_TRUE(*it == theVector.back()); EXPECT_TRUE(*it == this->theVector.back());
EXPECT_EQ(2, it->getValue()); EXPECT_EQ(2, it->getValue());
++it; ++it;
EXPECT_TRUE(it == theVector.end()); EXPECT_TRUE(it == this->theVector.end());
--it; --it;
EXPECT_TRUE(*it == theVector[1]); EXPECT_TRUE(*it == this->theVector[1]);
EXPECT_EQ(2, it->getValue()); EXPECT_EQ(2, it->getValue());
--it; --it;
EXPECT_TRUE(*it == theVector[0]); EXPECT_TRUE(*it == this->theVector[0]);
EXPECT_EQ(1, it->getValue()); EXPECT_EQ(1, it->getValue());
// Reverse Iteration // Reverse Iteration
VectorType::reverse_iterator rit = theVector.rbegin(); typename TypeParam::reverse_iterator rit = this->theVector.rbegin();
EXPECT_TRUE(*rit == theVector[1]); EXPECT_TRUE(*rit == this->theVector[1]);
EXPECT_EQ(2, rit->getValue()); EXPECT_EQ(2, rit->getValue());
++rit; ++rit;
EXPECT_TRUE(*rit == theVector[0]); EXPECT_TRUE(*rit == this->theVector[0]);
EXPECT_EQ(1, rit->getValue()); EXPECT_EQ(1, rit->getValue());
++rit; ++rit;
EXPECT_TRUE(rit == theVector.rend()); EXPECT_TRUE(rit == this->theVector.rend());
--rit; --rit;
EXPECT_TRUE(*rit == theVector[0]); EXPECT_TRUE(*rit == this->theVector[0]);
EXPECT_EQ(1, rit->getValue()); EXPECT_EQ(1, rit->getValue());
--rit; --rit;
EXPECT_TRUE(*rit == theVector[1]); EXPECT_TRUE(*rit == this->theVector[1]);
EXPECT_EQ(2, rit->getValue()); EXPECT_EQ(2, rit->getValue());
} }
// Swap test. // Swap test.
TEST_F(SmallVectorTest, SwapTest) { TYPED_TEST(SmallVectorTest, SwapTest) {
SCOPED_TRACE("SwapTest"); SCOPED_TRACE("SwapTest");
makeSequence(theVector, 1, 2); this->makeSequence(this->theVector, 1, 2);
std::swap(theVector, otherVector); std::swap(this->theVector, this->otherVector);
assertEmpty(theVector); this->assertEmpty(this->theVector);
assertValuesInOrder(otherVector, 2u, 1, 2); this->assertValuesInOrder(this->otherVector, 2u, 1, 2);
} }
// Append test // Append test
TEST_F(SmallVectorTest, AppendTest) { TYPED_TEST(SmallVectorTest, AppendTest) {
SCOPED_TRACE("AppendTest"); SCOPED_TRACE("AppendTest");
makeSequence(otherVector, 2, 3); this->makeSequence(this->otherVector, 2, 3);
theVector.push_back(Constructable(1)); this->theVector.push_back(Constructable(1));
theVector.append(otherVector.begin(), otherVector.end()); this->theVector.append(this->otherVector.begin(), this->otherVector.end());
assertValuesInOrder(theVector, 3u, 1, 2, 3); this->assertValuesInOrder(this->theVector, 3u, 1, 2, 3);
} }
// Append repeated test // Append repeated test
TEST_F(SmallVectorTest, AppendRepeatedTest) { TYPED_TEST(SmallVectorTest, AppendRepeatedTest) {
SCOPED_TRACE("AppendRepeatedTest"); SCOPED_TRACE("AppendRepeatedTest");
theVector.push_back(Constructable(1)); this->theVector.push_back(Constructable(1));
theVector.append(2, Constructable(77)); this->theVector.append(2, Constructable(77));
assertValuesInOrder(theVector, 3u, 1, 77, 77); this->assertValuesInOrder(this->theVector, 3u, 1, 77, 77);
} }
// Assign test // Assign test
TEST_F(SmallVectorTest, AssignTest) { TYPED_TEST(SmallVectorTest, AssignTest) {
SCOPED_TRACE("AssignTest"); SCOPED_TRACE("AssignTest");
theVector.push_back(Constructable(1)); this->theVector.push_back(Constructable(1));
theVector.assign(2, Constructable(77)); this->theVector.assign(2, Constructable(77));
assertValuesInOrder(theVector, 2u, 77, 77); this->assertValuesInOrder(this->theVector, 2u, 77, 77);
} }
// Erase a single element // Erase a single element
TEST_F(SmallVectorTest, EraseTest) { TYPED_TEST(SmallVectorTest, EraseTest) {
SCOPED_TRACE("EraseTest"); SCOPED_TRACE("EraseTest");
makeSequence(theVector, 1, 3); this->makeSequence(this->theVector, 1, 3);
theVector.erase(theVector.begin()); this->theVector.erase(this->theVector.begin());
assertValuesInOrder(theVector, 2u, 2, 3); this->assertValuesInOrder(this->theVector, 2u, 2, 3);
} }
// Erase a range of elements // Erase a range of elements
TEST_F(SmallVectorTest, EraseRangeTest) { TYPED_TEST(SmallVectorTest, EraseRangeTest) {
SCOPED_TRACE("EraseRangeTest"); SCOPED_TRACE("EraseRangeTest");
makeSequence(theVector, 1, 3); this->makeSequence(this->theVector, 1, 3);
theVector.erase(theVector.begin(), theVector.begin() + 2); this->theVector.erase(this->theVector.begin(), this->theVector.begin() + 2);
assertValuesInOrder(theVector, 1u, 3); this->assertValuesInOrder(this->theVector, 1u, 3);
} }
// Insert a single element. // Insert a single element.
TEST_F(SmallVectorTest, InsertTest) { TYPED_TEST(SmallVectorTest, InsertTest) {
SCOPED_TRACE("InsertTest"); SCOPED_TRACE("InsertTest");
makeSequence(theVector, 1, 3); this->makeSequence(this->theVector, 1, 3);
VectorType::iterator I = typename TypeParam::iterator I =
theVector.insert(theVector.begin() + 1, Constructable(77)); this->theVector.insert(this->theVector.begin() + 1, Constructable(77));
EXPECT_EQ(theVector.begin() + 1, I); EXPECT_EQ(this->theVector.begin() + 1, I);
assertValuesInOrder(theVector, 4u, 1, 77, 2, 3); this->assertValuesInOrder(this->theVector, 4u, 1, 77, 2, 3);
} }
// Insert repeated elements. // Insert repeated elements.
TEST_F(SmallVectorTest, InsertRepeatedTest) { TYPED_TEST(SmallVectorTest, InsertRepeatedTest) {
SCOPED_TRACE("InsertRepeatedTest"); SCOPED_TRACE("InsertRepeatedTest");
makeSequence(theVector, 10, 15); this->makeSequence(this->theVector, 10, 15);
VectorType::iterator I = typename TypeParam::iterator I =
theVector.insert(theVector.begin() + 1, 2, Constructable(16)); this->theVector.insert(this->theVector.begin() + 1, 2, Constructable(16));
EXPECT_EQ(theVector.begin() + 1, I); EXPECT_EQ(this->theVector.begin() + 1, I);
assertValuesInOrder(theVector, 8u, 10, 16, 16, 11, 12, 13, 14, 15); this->assertValuesInOrder(this->theVector, 8u,
10, 16, 16, 11, 12, 13, 14, 15);
// Insert at end. // Insert at end.
I = theVector.insert(theVector.end(), 2, Constructable(16)); I = this->theVector.insert(this->theVector.end(), 2, Constructable(16));
EXPECT_EQ(theVector.begin() + 8, I); EXPECT_EQ(this->theVector.begin() + 8, I);
assertValuesInOrder(theVector, 10u, 10, 16, 16, 11, 12, 13, 14, 15, 16, 16); this->assertValuesInOrder(this->theVector, 10u,
10, 16, 16, 11, 12, 13, 14, 15, 16, 16);
// Empty insert. // Empty insert.
EXPECT_EQ(theVector.end(), EXPECT_EQ(this->theVector.end(),
theVector.insert(theVector.end(), 0, Constructable(42))); this->theVector.insert(this->theVector.end(),
EXPECT_EQ(theVector.begin() + 1, 0, Constructable(42)));
theVector.insert(theVector.begin() + 1, 0, Constructable(42))); EXPECT_EQ(this->theVector.begin() + 1,
this->theVector.insert(this->theVector.begin() + 1,
0, Constructable(42)));
} }
// Insert range. // Insert range.
TEST_F(SmallVectorTest, InsertRangeTest) { TYPED_TEST(SmallVectorTest, InsertRangeTest) {
SCOPED_TRACE("InsertRangeTest"); SCOPED_TRACE("InsertRangeTest");
Constructable Arr[3] = Constructable Arr[3] =
{ Constructable(77), Constructable(77), Constructable(77) }; { Constructable(77), Constructable(77), Constructable(77) };
makeSequence(theVector, 1, 3); this->makeSequence(this->theVector, 1, 3);
VectorType::iterator I = typename TypeParam::iterator I =
theVector.insert(theVector.begin() + 1, Arr, Arr+3); this->theVector.insert(this->theVector.begin() + 1, Arr, Arr+3);
EXPECT_EQ(theVector.begin() + 1, I); EXPECT_EQ(this->theVector.begin() + 1, I);
assertValuesInOrder(theVector, 6u, 1, 77, 77, 77, 2, 3); this->assertValuesInOrder(this->theVector, 6u, 1, 77, 77, 77, 2, 3);
// Insert at end. // Insert at end.
I = theVector.insert(theVector.end(), Arr, Arr+3); I = this->theVector.insert(this->theVector.end(), Arr, Arr+3);
EXPECT_EQ(theVector.begin() + 6, I); EXPECT_EQ(this->theVector.begin() + 6, I);
assertValuesInOrder(theVector, 9u, 1, 77, 77, 77, 2, 3, 77, 77, 77); this->assertValuesInOrder(this->theVector, 9u,
1, 77, 77, 77, 2, 3, 77, 77, 77);
// Empty insert. // Empty insert.
EXPECT_EQ(theVector.end(), theVector.insert(theVector.end(), EXPECT_EQ(this->theVector.end(),
theVector.begin(), this->theVector.insert(this->theVector.end(),
theVector.begin())); this->theVector.begin(),
EXPECT_EQ(theVector.begin() + 1, theVector.insert(theVector.begin() + 1, this->theVector.begin()));
theVector.begin(), EXPECT_EQ(this->theVector.begin() + 1,
theVector.begin())); this->theVector.insert(this->theVector.begin() + 1,
this->theVector.begin(),
this->theVector.begin()));
} }
// Comparison tests. // Comparison tests.
TEST_F(SmallVectorTest, ComparisonTest) { TYPED_TEST(SmallVectorTest, ComparisonTest) {
SCOPED_TRACE("ComparisonTest"); SCOPED_TRACE("ComparisonTest");
makeSequence(theVector, 1, 3); this->makeSequence(this->theVector, 1, 3);
makeSequence(otherVector, 1, 3); this->makeSequence(this->otherVector, 1, 3);
EXPECT_TRUE(theVector == otherVector); EXPECT_TRUE(this->theVector == this->otherVector);
EXPECT_FALSE(theVector != otherVector); EXPECT_FALSE(this->theVector != this->otherVector);
otherVector.clear(); this->otherVector.clear();
makeSequence(otherVector, 2, 4); this->makeSequence(this->otherVector, 2, 4);
EXPECT_FALSE(theVector == otherVector); EXPECT_FALSE(this->theVector == this->otherVector);
EXPECT_TRUE(theVector != otherVector); EXPECT_TRUE(this->theVector != this->otherVector);
} }
// Constant vector tests. // Constant vector tests.
TEST_F(SmallVectorTest, ConstVectorTest) { TYPED_TEST(SmallVectorTest, ConstVectorTest) {
VectorType constVector; const TypeParam constVector;
EXPECT_EQ(0u, constVector.size()); EXPECT_EQ(0u, constVector.size());
EXPECT_TRUE(constVector.empty()); EXPECT_TRUE(constVector.empty());
@ -424,26 +450,27 @@ TEST_F(SmallVectorTest, ConstVectorTest) {
} }
// Direct array access. // Direct array access.
TEST_F(SmallVectorTest, DirectVectorTest) { TYPED_TEST(SmallVectorTest, DirectVectorTest) {
EXPECT_EQ(0u, theVector.size()); EXPECT_EQ(0u, this->theVector.size());
EXPECT_LE(4u, theVector.capacity()); this->theVector.reserve(4);
EXPECT_LE(4u, this->theVector.capacity());
EXPECT_EQ(0, Constructable::getNumConstructorCalls()); EXPECT_EQ(0, Constructable::getNumConstructorCalls());
theVector.end()[0] = 1; this->theVector.end()[0] = 1;
theVector.end()[1] = 2; this->theVector.end()[1] = 2;
theVector.end()[2] = 3; this->theVector.end()[2] = 3;
theVector.end()[3] = 4; this->theVector.end()[3] = 4;
theVector.set_size(4); this->theVector.set_size(4);
EXPECT_EQ(4u, theVector.size()); EXPECT_EQ(4u, this->theVector.size());
EXPECT_EQ(4, Constructable::getNumConstructorCalls()); EXPECT_EQ(4, Constructable::getNumConstructorCalls());
EXPECT_EQ(1, theVector[0].getValue()); EXPECT_EQ(1, this->theVector[0].getValue());
EXPECT_EQ(2, theVector[1].getValue()); EXPECT_EQ(2, this->theVector[1].getValue());
EXPECT_EQ(3, theVector[2].getValue()); EXPECT_EQ(3, this->theVector[2].getValue());
EXPECT_EQ(4, theVector[3].getValue()); EXPECT_EQ(4, this->theVector[3].getValue());
} }
TEST_F(SmallVectorTest, IteratorTest) { TYPED_TEST(SmallVectorTest, IteratorTest) {
std::list<int> L; std::list<int> L;
theVector.insert(theVector.end(), L.begin(), L.end()); this->theVector.insert(this->theVector.end(), L.begin(), L.end());
} }
struct notassignable { struct notassignable {
@ -451,7 +478,7 @@ struct notassignable {
notassignable(int &x) : x(x) {} notassignable(int &x) : x(x) {}
}; };
TEST_F(SmallVectorTest, NoAssignTest) { TEST(SmallVectorCustomTest, NoAssignTest) {
int x = 0; int x = 0;
SmallVector<notassignable, 2> vec; SmallVector<notassignable, 2> vec;
vec.push_back(notassignable(x)); vec.push_back(notassignable(x));