1 files changed, 0 insertions, 408 deletions
diff --git a/contrib/llvm/unittests/ADT/SmallVectorTest.cpp b/contrib/llvm/unittests/ADT/SmallVectorTest.cpp
deleted file mode 100644
index 991c7d6..0000000
--- a/contrib/llvm/unittests/ADT/SmallVectorTest.cpp
+++ /dev/null
@@ -1,408 +0,0 @@
-//===- llvm/unittest/ADT/SmallVectorTest.cpp ------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// SmallVector unit tests.
-//
-//===----------------------------------------------------------------------===//
-
-#include "gtest/gtest.h"
-#include "llvm/ADT/SmallVector.h"
-#include <stdarg.h>
-#include <list>
-
-using namespace llvm;
-
-namespace {
-
-/// A helper class that counts the total number of constructor and
-/// destructor calls.
-class Constructable {
-private:
-  static int numConstructorCalls;
-  static int numDestructorCalls;
-  static int numAssignmentCalls;
-
-  int value;
-
-public:
-  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);
-  }
-
-  static void reset() {
-    numConstructorCalls = 0;
-    numDestructorCalls = 0;
-    numAssignmentCalls = 0;
-  }
-  
-  static int getNumConstructorCalls() {
-    return numConstructorCalls;
-  }
-
-  static int getNumDestructorCalls() {
-    return numDestructorCalls;
-  }
-
-  friend bool operator==(const Constructable & c0, const Constructable & c1) {
-    return c0.getValue() == c1.getValue();
-  }
-
-  friend bool operator!=(const Constructable & c0, const Constructable & c1) {
-    return c0.getValue() != c1.getValue();
-  }
-};
-
-int Constructable::numConstructorCalls;
-int Constructable::numDestructorCalls;
-int Constructable::numAssignmentCalls;
-
-// Test fixture class
-class SmallVectorTest : public testing::Test {
-protected:
-  typedef SmallVector<Constructable, 4> VectorType;
-  
-  VectorType theVector;
-  VectorType otherVector;
-  
-  void SetUp() {
-    Constructable::reset();
-  }
-
-  void assertEmpty(VectorType & v) {
-    // Size tests
-    EXPECT_EQ(0u, v.size());
-    EXPECT_TRUE(v.empty());
-
-    // Iterator tests
-    EXPECT_TRUE(v.begin() == v.end());
-  }
-
-  // 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) {
-      int value = va_arg(ap, int);
-      EXPECT_EQ(value, v[i].getValue());
-    }
-
-    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) {
-      v.push_back(Constructable(i));
-    }
-  }
-};
-
-// New vector test.
-TEST_F(SmallVectorTest, EmptyVectorTest) {
-  SCOPED_TRACE("EmptyVectorTest");
-  assertEmpty(theVector);
-  EXPECT_TRUE(theVector.rbegin() == theVector.rend());
-  EXPECT_EQ(0, Constructable::getNumConstructorCalls());
-  EXPECT_EQ(0, Constructable::getNumDestructorCalls());
-}
-
-// Simple insertions and deletions.
-TEST_F(SmallVectorTest, PushPopTest) {
-  SCOPED_TRACE("PushPopTest");
-
-  // Push an element
-  theVector.push_back(Constructable(1));
-
-  // Size tests
-  assertValuesInOrder(theVector, 1u, 1);
-  EXPECT_FALSE(theVector.begin() == theVector.end());
-  EXPECT_FALSE(theVector.empty());
-
-  // Push another element
-  theVector.push_back(Constructable(2));
-  assertValuesInOrder(theVector, 2u, 1, 2);
-
-  // Pop one element
-  theVector.pop_back();
-  assertValuesInOrder(theVector, 1u, 1);
-
-  // Pop another element
-  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());
-}
-
-// Clear test.
-TEST_F(SmallVectorTest, ClearTest) {
-  SCOPED_TRACE("ClearTest");
-
-  makeSequence(theVector, 1, 2);
-  theVector.clear();
-
-  assertEmpty(theVector);
-  EXPECT_EQ(4, Constructable::getNumConstructorCalls());
-  EXPECT_EQ(4, Constructable::getNumDestructorCalls());
-}
-
-// Resize smaller test.
-TEST_F(SmallVectorTest, ResizeShrinkTest) {
-  SCOPED_TRACE("ResizeShrinkTest");
-
-  makeSequence(theVector, 1, 3);
-  theVector.resize(1);
-
-  assertValuesInOrder(theVector, 1u, 1);
-  EXPECT_EQ(6, Constructable::getNumConstructorCalls());
-  EXPECT_EQ(5, Constructable::getNumDestructorCalls());
-}
-
-// Resize bigger test.
-TEST_F(SmallVectorTest, ResizeGrowTest) {
-  SCOPED_TRACE("ResizeGrowTest");
-
-  theVector.resize(2);
-  
-  // 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());
-}
-
-// Resize with fill value.
-TEST_F(SmallVectorTest, ResizeFillTest) {
-  SCOPED_TRACE("ResizeFillTest");
-
-  theVector.resize(3, Constructable(77));
-  assertValuesInOrder(theVector, 3u, 77, 77, 77);
-}
-
-// Overflow past fixed size.
-TEST_F(SmallVectorTest, OverflowTest) {
-  SCOPED_TRACE("OverflowTest");
-
-  // Push more elements than the fixed size.
-  makeSequence(theVector, 1, 10);
-
-  // 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.
-  theVector.resize(1);
-  
-  assertValuesInOrder(theVector, 1u, 1);
-}
-
-// Iteration tests.
-TEST_F(SmallVectorTest, IterationTest) {
-  makeSequence(theVector, 1, 2);
-
-  // Forward Iteration
-  VectorType::iterator it = theVector.begin();
-  EXPECT_TRUE(*it == theVector.front());
-  EXPECT_TRUE(*it == theVector[0]);
-  EXPECT_EQ(1, it->getValue());
-  ++it;
-  EXPECT_TRUE(*it == theVector[1]);
-  EXPECT_TRUE(*it == theVector.back());
-  EXPECT_EQ(2, it->getValue());
-  ++it;
-  EXPECT_TRUE(it == theVector.end());
-  --it;
-  EXPECT_TRUE(*it == theVector[1]);
-  EXPECT_EQ(2, it->getValue());
-  --it;
-  EXPECT_TRUE(*it == theVector[0]);
-  EXPECT_EQ(1, it->getValue());
-
-  // Reverse Iteration
-  VectorType::reverse_iterator rit = theVector.rbegin();
-  EXPECT_TRUE(*rit == theVector[1]);
-  EXPECT_EQ(2, rit->getValue());
-  ++rit;
-  EXPECT_TRUE(*rit == theVector[0]);
-  EXPECT_EQ(1, rit->getValue());
-  ++rit;
-  EXPECT_TRUE(rit == theVector.rend());
-  --rit;
-  EXPECT_TRUE(*rit == theVector[0]);
-  EXPECT_EQ(1, rit->getValue());
-  --rit;
-  EXPECT_TRUE(*rit == theVector[1]);
-  EXPECT_EQ(2, rit->getValue());
-}
-
-// Swap test.
-TEST_F(SmallVectorTest, SwapTest) {
-  SCOPED_TRACE("SwapTest");
-
-  makeSequence(theVector, 1, 2);
-  std::swap(theVector, otherVector);
-
-  assertEmpty(theVector);
-  assertValuesInOrder(otherVector, 2u, 1, 2);
-}
-
-// Append test
-TEST_F(SmallVectorTest, AppendTest) {
-  SCOPED_TRACE("AppendTest");
-
-  makeSequence(otherVector, 2, 3);
-
-  theVector.push_back(Constructable(1));
-  theVector.append(otherVector.begin(), otherVector.end());
-
-  assertValuesInOrder(theVector, 3u, 1, 2, 3);
-}
-
-// Append repeated test
-TEST_F(SmallVectorTest, AppendRepeatedTest) {
-  SCOPED_TRACE("AppendRepeatedTest");
-
-  theVector.push_back(Constructable(1));
-  theVector.append(2, Constructable(77));
-  assertValuesInOrder(theVector, 3u, 1, 77, 77);
-}
-
-// Assign test
-TEST_F(SmallVectorTest, AssignTest) {
-  SCOPED_TRACE("AssignTest");
-
-  theVector.push_back(Constructable(1));
-  theVector.assign(2, Constructable(77));
-  assertValuesInOrder(theVector, 2u, 77, 77);
-}
-
-// Erase a single element
-TEST_F(SmallVectorTest, EraseTest) {
-  SCOPED_TRACE("EraseTest");
-
-  makeSequence(theVector, 1, 3);
-  theVector.erase(theVector.begin());
-  assertValuesInOrder(theVector, 2u, 2, 3);
-}
-
-// Erase a range of elements
-TEST_F(SmallVectorTest, EraseRangeTest) {
-  SCOPED_TRACE("EraseRangeTest");
-
-  makeSequence(theVector, 1, 3);
-  theVector.erase(theVector.begin(), theVector.begin() + 2);
-  assertValuesInOrder(theVector, 1u, 3);
-}
-
-// Insert a single element.
-TEST_F(SmallVectorTest, InsertTest) {
-  SCOPED_TRACE("InsertTest");
-
-  makeSequence(theVector, 1, 3);
-  theVector.insert(theVector.begin() + 1, Constructable(77));
-  assertValuesInOrder(theVector, 4u, 1, 77, 2, 3);
-}
-
-// Insert repeated elements.
-TEST_F(SmallVectorTest, InsertRepeatedTest) {
-  SCOPED_TRACE("InsertRepeatedTest");
-
-  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.
-TEST_F(SmallVectorTest, InsertRangeTest) {
-  SCOPED_TRACE("InsertRepeatedTest");
-
-  makeSequence(theVector, 1, 3);
-  theVector.insert(theVector.begin() + 1, 3, Constructable(77));
-  assertValuesInOrder(theVector, 6u, 1, 77, 77, 77, 2, 3);
-}
-
-// Comparison tests.
-TEST_F(SmallVectorTest, ComparisonTest) {
-  SCOPED_TRACE("ComparisonTest");
-
-  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;
-
-  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());
-}
-
-}