#include "gtest/gtest.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Compiler.h"
#include <stdarg.h>
+#include <list>
using namespace llvm;
Constructable() : value(0) {
++numConstructorCalls;
}
-
+
Constructable(int val) : value(val) {
++numConstructorCalls;
}
-
+
Constructable(const Constructable & src) {
value = src.value;
++numConstructorCalls;
}
-
+
~Constructable() {
++numDestructorCalls;
}
-
+
Constructable & operator=(const Constructable & src) {
value = src.value;
++numAssignmentCalls;
return *this;
}
-
+
int getValue() const {
return abs(value);
}
numDestructorCalls = 0;
numAssignmentCalls = 0;
}
-
+
static int getNumConstructorCalls() {
return numConstructorCalls;
}
return c0.getValue() == c1.getValue();
}
- friend bool operator!=(const Constructable & c0, const Constructable & c1) {
+ friend bool LLVM_ATTRIBUTE_UNUSED
+ operator!=(const Constructable & c0, const Constructable & c1) {
return c0.getValue() != c1.getValue();
}
};
class SmallVectorTest : public testing::Test {
protected:
typedef SmallVector<Constructable, 4> VectorType;
-
+
VectorType theVector;
VectorType otherVector;
-
+
void SetUp() {
Constructable::reset();
}
// Assert that theVector contains the specified values, in order.
void assertValuesInOrder(VectorType & v, size_t size, ...) {
EXPECT_EQ(size, v.size());
-
+
va_list ap;
va_start(ap, size);
for (size_t i = 0; i < size; ++i) {
va_end(ap);
}
-
+
// Generate a sequence of values to initialize the vector.
void makeSequence(VectorType & v, int start, int end) {
for (int i = start; i <= end; ++i) {
theVector.push_back(Constructable(2));
assertValuesInOrder(theVector, 2u, 1, 2);
+ // Insert at beginning
+ theVector.insert(theVector.begin(), theVector[1]);
+ assertValuesInOrder(theVector, 3u, 2, 1, 2);
+
// Pop one element
theVector.pop_back();
- assertValuesInOrder(theVector, 1u, 1);
+ assertValuesInOrder(theVector, 2u, 2, 1);
- // Pop another element
+ // Pop remaining elements
+ theVector.pop_back();
theVector.pop_back();
assertEmpty(theVector);
-
+
// Check number of constructor calls. Should be 2 for each list element,
- // one for the argument to push_back, and one for the list element itself.
- EXPECT_EQ(4, Constructable::getNumConstructorCalls());
- EXPECT_EQ(4, Constructable::getNumDestructorCalls());
+ // one for the argument to push_back, one for the argument to insert,
+ // and one for the list element itself.
+ EXPECT_EQ(5, Constructable::getNumConstructorCalls());
+ EXPECT_EQ(5, Constructable::getNumDestructorCalls());
}
// Clear test.
SCOPED_TRACE("ResizeGrowTest");
theVector.resize(2);
-
- // XXX: I don't know where the extra construct/destruct is coming from.
+
+ // The extra constructor/destructor calls come from the temporary object used
+ // to initialize the contents of the resized array (via copy construction).
EXPECT_EQ(3, Constructable::getNumConstructorCalls());
EXPECT_EQ(1, Constructable::getNumDestructorCalls());
EXPECT_EQ(2u, theVector.size());
TEST_F(SmallVectorTest, OverflowTest) {
SCOPED_TRACE("OverflowTest");
- // Push more elements than the fixed size
+ // Push more elements than the fixed size.
makeSequence(theVector, 1, 10);
- // test size and values
+ // Test size and values.
EXPECT_EQ(10u, theVector.size());
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(i+1, theVector[i].getValue());
}
-
- // Now resize back to fixed size
+
+ // Now resize back to fixed size.
theVector.resize(1);
-
+
assertValuesInOrder(theVector, 1u, 1);
}
TEST_F(SmallVectorTest, InsertRepeatedTest) {
SCOPED_TRACE("InsertRepeatedTest");
- makeSequence(theVector, 1, 3);
- theVector.insert(theVector.begin() + 1, 3, Constructable(77));
- assertValuesInOrder(theVector, 6u, 1, 77, 77, 77, 2, 3);
+ makeSequence(theVector, 10, 15);
+ theVector.insert(theVector.begin() + 1, 2, Constructable(16));
+ assertValuesInOrder(theVector, 8u, 10, 16, 16, 11, 12, 13, 14, 15);
}
// Insert range.
makeSequence(theVector, 1, 3);
makeSequence(otherVector, 1, 3);
-
+
EXPECT_TRUE(theVector == otherVector);
EXPECT_FALSE(theVector != otherVector);
otherVector.clear();
makeSequence(otherVector, 2, 4);
-
+
EXPECT_FALSE(theVector == otherVector);
EXPECT_TRUE(theVector != otherVector);
}
// Constant vector tests.
TEST_F(SmallVectorTest, ConstVectorTest) {
- const VectorType constVector;
+ VectorType constVector;
EXPECT_EQ(0u, constVector.size());
EXPECT_TRUE(constVector.empty());
EXPECT_TRUE(constVector.begin() == constVector.end());
}
+// Direct array access.
+TEST_F(SmallVectorTest, DirectVectorTest) {
+ EXPECT_EQ(0u, theVector.size());
+ EXPECT_LE(4u, theVector.capacity());
+ EXPECT_EQ(0, Constructable::getNumConstructorCalls());
+ theVector.end()[0] = 1;
+ theVector.end()[1] = 2;
+ theVector.end()[2] = 3;
+ theVector.end()[3] = 4;
+ theVector.set_size(4);
+ EXPECT_EQ(4u, theVector.size());
+ EXPECT_EQ(4, Constructable::getNumConstructorCalls());
+ EXPECT_EQ(1, theVector[0].getValue());
+ EXPECT_EQ(2, theVector[1].getValue());
+ EXPECT_EQ(3, theVector[2].getValue());
+ EXPECT_EQ(4, theVector[3].getValue());
+}
+
+TEST_F(SmallVectorTest, IteratorTest) {
+ std::list<int> L;
+ theVector.insert(theVector.end(), L.begin(), L.end());
+}
+
}