wtf reformat test

third_party/WebKit/Source/wtf/VectorTest.cpp

Index: third_party/WebKit/Source/wtf/VectorTest.cpp
diff --git a/third_party/WebKit/Source/wtf/VectorTest.cpp b/third_party/WebKit/Source/wtf/VectorTest.cpp
index d06b47be7bf0215dc50edbf1bd1879bc0b504fef..cf3fe3655287cadd93511f2674b23b52952adc9c 100644
--- a/third_party/WebKit/Source/wtf/VectorTest.cpp
+++ b/third_party/WebKit/Source/wtf/VectorTest.cpp
@@ -35,430 +35,406 @@ namespace WTF {
 
 namespace {
 
-TEST(VectorTest, Basic)
-{
-    Vector<int> intVector;
-    EXPECT_TRUE(intVector.isEmpty());
-    EXPECT_EQ(0ul, intVector.size());
-    EXPECT_EQ(0ul, intVector.capacity());
+TEST(VectorTest, Basic) {
+  Vector<int> intVector;
+  EXPECT_TRUE(intVector.isEmpty());
+  EXPECT_EQ(0ul, intVector.size());
+  EXPECT_EQ(0ul, intVector.capacity());
 }
 
-TEST(VectorTest, Reverse)
-{
-    Vector<int> intVector;
-    intVector.append(10);
-    intVector.append(11);
-    intVector.append(12);
-    intVector.append(13);
-    intVector.reverse();
-
-    EXPECT_EQ(13, intVector[0]);
-    EXPECT_EQ(12, intVector[1]);
-    EXPECT_EQ(11, intVector[2]);
-    EXPECT_EQ(10, intVector[3]);
-
-    intVector.append(9);
-    intVector.reverse();
-
-    EXPECT_EQ(9, intVector[0]);
-    EXPECT_EQ(10, intVector[1]);
-    EXPECT_EQ(11, intVector[2]);
-    EXPECT_EQ(12, intVector[3]);
-    EXPECT_EQ(13, intVector[4]);
+TEST(VectorTest, Reverse) {
+  Vector<int> intVector;
+  intVector.append(10);
+  intVector.append(11);
+  intVector.append(12);
+  intVector.append(13);
+  intVector.reverse();
+
+  EXPECT_EQ(13, intVector[0]);
+  EXPECT_EQ(12, intVector[1]);
+  EXPECT_EQ(11, intVector[2]);
+  EXPECT_EQ(10, intVector[3]);
+
+  intVector.append(9);
+  intVector.reverse();
+
+  EXPECT_EQ(9, intVector[0]);
+  EXPECT_EQ(10, intVector[1]);
+  EXPECT_EQ(11, intVector[2]);
+  EXPECT_EQ(12, intVector[3]);
+  EXPECT_EQ(13, intVector[4]);
 }
 
-TEST(VectorTest, Remove)
-{
-    Vector<int> intVector;
-    intVector.append(0);
-    intVector.append(1);
-    intVector.append(2);
-    intVector.append(3);
-
-    EXPECT_EQ(4u, intVector.size());
-    EXPECT_EQ(0, intVector[0]);
-    EXPECT_EQ(1, intVector[1]);
-    EXPECT_EQ(2, intVector[2]);
-    EXPECT_EQ(3, intVector[3]);
-
-    intVector.remove(2, 0);
-    EXPECT_EQ(4u, intVector.size());
-    EXPECT_EQ(2, intVector[2]);
-
-    intVector.remove(2, 1);
-    EXPECT_EQ(3u, intVector.size());
-    EXPECT_EQ(3, intVector[2]);
-
-    intVector.remove(0, 0);
-    EXPECT_EQ(3u, intVector.size());
-    EXPECT_EQ(0, intVector[0]);
-
-    intVector.remove(0);
-    EXPECT_EQ(2u, intVector.size());
-    EXPECT_EQ(1, intVector[0]);
+TEST(VectorTest, Remove) {
+  Vector<int> intVector;
+  intVector.append(0);
+  intVector.append(1);
+  intVector.append(2);
+  intVector.append(3);
+
+  EXPECT_EQ(4u, intVector.size());
+  EXPECT_EQ(0, intVector[0]);
+  EXPECT_EQ(1, intVector[1]);
+  EXPECT_EQ(2, intVector[2]);
+  EXPECT_EQ(3, intVector[3]);
+
+  intVector.remove(2, 0);
+  EXPECT_EQ(4u, intVector.size());
+  EXPECT_EQ(2, intVector[2]);
+
+  intVector.remove(2, 1);
+  EXPECT_EQ(3u, intVector.size());
+  EXPECT_EQ(3, intVector[2]);
+
+  intVector.remove(0, 0);
+  EXPECT_EQ(3u, intVector.size());
+  EXPECT_EQ(0, intVector[0]);
+
+  intVector.remove(0);
+  EXPECT_EQ(2u, intVector.size());
+  EXPECT_EQ(1, intVector[0]);
 }
 
-TEST(VectorTest, Iterator)
-{
-    Vector<int> intVector;
-    intVector.append(10);
-    intVector.append(11);
-    intVector.append(12);
-    intVector.append(13);
-
-    Vector<int>::iterator it = intVector.begin();
-    Vector<int>::iterator end = intVector.end();
-    EXPECT_TRUE(end != it);
-
-    EXPECT_EQ(10, *it);
-    ++it;
-    EXPECT_EQ(11, *it);
-    ++it;
-    EXPECT_EQ(12, *it);
-    ++it;
-    EXPECT_EQ(13, *it);
-    ++it;
-
-    EXPECT_TRUE(end == it);
+TEST(VectorTest, Iterator) {
+  Vector<int> intVector;
+  intVector.append(10);
+  intVector.append(11);
+  intVector.append(12);
+  intVector.append(13);
+
+  Vector<int>::iterator it = intVector.begin();
+  Vector<int>::iterator end = intVector.end();
+  EXPECT_TRUE(end != it);
+
+  EXPECT_EQ(10, *it);
+  ++it;
+  EXPECT_EQ(11, *it);
+  ++it;
+  EXPECT_EQ(12, *it);
+  ++it;
+  EXPECT_EQ(13, *it);
+  ++it;
+
+  EXPECT_TRUE(end == it);
 }
 
-TEST(VectorTest, ReverseIterator)
-{
-    Vector<int> intVector;
-    intVector.append(10);
-    intVector.append(11);
-    intVector.append(12);
-    intVector.append(13);
-
-    Vector<int>::reverse_iterator it = intVector.rbegin();
-    Vector<int>::reverse_iterator end = intVector.rend();
-    EXPECT_TRUE(end != it);
-
-    EXPECT_EQ(13, *it);
-    ++it;
-    EXPECT_EQ(12, *it);
-    ++it;
-    EXPECT_EQ(11, *it);
-    ++it;
-    EXPECT_EQ(10, *it);
-    ++it;
-
-    EXPECT_TRUE(end == it);
+TEST(VectorTest, ReverseIterator) {
+  Vector<int> intVector;
+  intVector.append(10);
+  intVector.append(11);
+  intVector.append(12);
+  intVector.append(13);
+
+  Vector<int>::reverse_iterator it = intVector.rbegin();
+  Vector<int>::reverse_iterator end = intVector.rend();
+  EXPECT_TRUE(end != it);
+
+  EXPECT_EQ(13, *it);
+  ++it;
+  EXPECT_EQ(12, *it);
+  ++it;
+  EXPECT_EQ(11, *it);
+  ++it;
+  EXPECT_EQ(10, *it);
+  ++it;
+
+  EXPECT_TRUE(end == it);
 }
 
 class DestructCounter {
-public:
-    explicit DestructCounter(int i, int* destructNumber)
-        : m_i(i)
-        , m_destructNumber(destructNumber)
-    { }
-
-    ~DestructCounter() { ++(*m_destructNumber); }
-    int get() const { return m_i; }
-
-private:
-    int m_i;
-    int* m_destructNumber;
+ public:
+  explicit DestructCounter(int i, int* destructNumber)
+      : m_i(i), m_destructNumber(destructNumber) {}
+
+  ~DestructCounter() { ++(*m_destructNumber); }
+  int get() const { return m_i; }
+
+ private:
+  int m_i;
+  int* m_destructNumber;
 };
 
 typedef WTF::Vector<OwnPtr<DestructCounter>> OwnPtrVector;
 
-TEST(VectorTest, OwnPtr)
-{
-    int destructNumber = 0;
-    OwnPtrVector vector;
-    vector.append(adoptPtr(new DestructCounter(0, &destructNumber)));
-    vector.append(adoptPtr(new DestructCounter(1, &destructNumber)));
-    EXPECT_EQ(2u, vector.size());
-
-    OwnPtr<DestructCounter>& counter0 = vector.first();
-    ASSERT_EQ(0, counter0->get());
-    int counter1 = vector.last()->get();
-    ASSERT_EQ(1, counter1);
-    ASSERT_EQ(0, destructNumber);
-
-    size_t index = 0;
-    for (OwnPtrVector::iterator iter = vector.begin(); iter != vector.end(); ++iter) {
-        OwnPtr<DestructCounter>* refCounter = iter;
-        EXPECT_EQ(index, static_cast<size_t>(refCounter->get()->get()));
-        EXPECT_EQ(index, static_cast<size_t>((*refCounter)->get()));
-        index++;
-    }
-    EXPECT_EQ(0, destructNumber);
-
-    for (index = 0; index < vector.size(); index++) {
-        OwnPtr<DestructCounter>& refCounter = vector[index];
-        EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
-    }
-    EXPECT_EQ(0, destructNumber);
-
-    EXPECT_EQ(0, vector[0]->get());
-    EXPECT_EQ(1, vector[1]->get());
-    vector.remove(0);
-    EXPECT_EQ(1, vector[0]->get());
-    EXPECT_EQ(1u, vector.size());
-    EXPECT_EQ(1, destructNumber);
-
-    OwnPtr<DestructCounter> ownCounter1 = vector[0].release();
-    vector.remove(0);
-    ASSERT_EQ(counter1, ownCounter1->get());
-    ASSERT_EQ(0u, vector.size());
-    ASSERT_EQ(1, destructNumber);
-
-    ownCounter1.clear();
-    EXPECT_EQ(2, destructNumber);
-
-    size_t count = 1025;
-    destructNumber = 0;
-    for (size_t i = 0; i < count; i++)
-        vector.prepend(adoptPtr(new DestructCounter(i, &destructNumber)));
-
-    // Vector relocation must not destruct OwnPtr element.
-    EXPECT_EQ(0, destructNumber);
-    EXPECT_EQ(count, vector.size());
-
-    OwnPtrVector copyVector;
-    vector.swap(copyVector);
-    EXPECT_EQ(0, destructNumber);
-    EXPECT_EQ(count, copyVector.size());
-    EXPECT_EQ(0u, vector.size());
-
-    copyVector.clear();
-    EXPECT_EQ(count, static_cast<size_t>(destructNumber));
+TEST(VectorTest, OwnPtr) {
+  int destructNumber = 0;
+  OwnPtrVector vector;
+  vector.append(adoptPtr(new DestructCounter(0, &destructNumber)));
+  vector.append(adoptPtr(new DestructCounter(1, &destructNumber)));
+  EXPECT_EQ(2u, vector.size());
+
+  OwnPtr<DestructCounter>& counter0 = vector.first();
+  ASSERT_EQ(0, counter0->get());
+  int counter1 = vector.last()->get();
+  ASSERT_EQ(1, counter1);
+  ASSERT_EQ(0, destructNumber);
+
+  size_t index = 0;
+  for (OwnPtrVector::iterator iter = vector.begin(); iter != vector.end();
+       ++iter) {
+    OwnPtr<DestructCounter>* refCounter = iter;
+    EXPECT_EQ(index, static_cast<size_t>(refCounter->get()->get()));
+    EXPECT_EQ(index, static_cast<size_t>((*refCounter)->get()));
+    index++;
+  }
+  EXPECT_EQ(0, destructNumber);
+
+  for (index = 0; index < vector.size(); index++) {
+    OwnPtr<DestructCounter>& refCounter = vector[index];
+    EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
+  }
+  EXPECT_EQ(0, destructNumber);
+
+  EXPECT_EQ(0, vector[0]->get());
+  EXPECT_EQ(1, vector[1]->get());
+  vector.remove(0);
+  EXPECT_EQ(1, vector[0]->get());
+  EXPECT_EQ(1u, vector.size());
+  EXPECT_EQ(1, destructNumber);
+
+  OwnPtr<DestructCounter> ownCounter1 = vector[0].release();
+  vector.remove(0);
+  ASSERT_EQ(counter1, ownCounter1->get());
+  ASSERT_EQ(0u, vector.size());
+  ASSERT_EQ(1, destructNumber);
+
+  ownCounter1.clear();
+  EXPECT_EQ(2, destructNumber);
+
+  size_t count = 1025;
+  destructNumber = 0;
+  for (size_t i = 0; i < count; i++)
+    vector.prepend(adoptPtr(new DestructCounter(i, &destructNumber)));
+
+  // Vector relocation must not destruct OwnPtr element.
+  EXPECT_EQ(0, destructNumber);
+  EXPECT_EQ(count, vector.size());
+
+  OwnPtrVector copyVector;
+  vector.swap(copyVector);
+  EXPECT_EQ(0, destructNumber);
+  EXPECT_EQ(count, copyVector.size());
+  EXPECT_EQ(0u, vector.size());
+
+  copyVector.clear();
+  EXPECT_EQ(count, static_cast<size_t>(destructNumber));
 }
 
 class MoveOnly {
-public:
-    explicit MoveOnly(int i = 0)
-        : m_i(i)
-    { }
-
-    MoveOnly(MoveOnly&& other)
-        : m_i(other.m_i)
-    {
-        other.m_i = 0;
-    }
+ public:
+  explicit MoveOnly(int i = 0) : m_i(i) {}
+
+  MoveOnly(MoveOnly&& other) : m_i(other.m_i) { other.m_i = 0; }
 
-    MoveOnly& operator=(MoveOnly&& other)
-    {
-        if (this != &other) {
-            m_i = other.m_i;
-            other.m_i = 0;
-        }
-        return *this;
+  MoveOnly& operator=(MoveOnly&& other) {
+    if (this != &other) {
+      m_i = other.m_i;
+      other.m_i = 0;
     }
+    return *this;
+  }
 
-    int value() const { return m_i; }
+  int value() const { return m_i; }
 
-private:
-    WTF_MAKE_NONCOPYABLE(MoveOnly);
-    int m_i;
+ private:
+  WTF_MAKE_NONCOPYABLE(MoveOnly);
+  int m_i;
 };
 
-TEST(VectorTest, MoveOnlyType)
-{
-    WTF::Vector<MoveOnly> vector;
-    vector.append(MoveOnly(1));
-    vector.append(MoveOnly(2));
-    EXPECT_EQ(2u, vector.size());
-
-    ASSERT_EQ(1, vector.first().value());
-    ASSERT_EQ(2, vector.last().value());
-
-    vector.remove(0);
-    EXPECT_EQ(2, vector[0].value());
-    EXPECT_EQ(1u, vector.size());
-
-    MoveOnly moveOnly(std::move(vector[0]));
-    vector.remove(0);
-    ASSERT_EQ(2, moveOnly.value());
-    ASSERT_EQ(0u, vector.size());
-
-    size_t count = vector.capacity() + 1;
-    for (size_t i = 0; i < count; i++)
-        vector.append(MoveOnly(i + 1)); // +1 to distinguish from default-constructed.
-
-    // Reallocation did not affect the vector's content.
-    EXPECT_EQ(count, vector.size());
-    for (size_t i = 0; i < vector.size(); i++)
-        EXPECT_EQ(static_cast<int>(i + 1), vector[i].value());
-
-    WTF::Vector<MoveOnly> otherVector;
-    vector.swap(otherVector);
-    EXPECT_EQ(count, otherVector.size());
-    EXPECT_EQ(0u, vector.size());
-
-    vector = std::move(otherVector);
-    EXPECT_EQ(count, vector.size());
+TEST(VectorTest, MoveOnlyType) {
+  WTF::Vector<MoveOnly> vector;
+  vector.append(MoveOnly(1));
+  vector.append(MoveOnly(2));
+  EXPECT_EQ(2u, vector.size());
+
+  ASSERT_EQ(1, vector.first().value());
+  ASSERT_EQ(2, vector.last().value());
+
+  vector.remove(0);
+  EXPECT_EQ(2, vector[0].value());
+  EXPECT_EQ(1u, vector.size());
+
+  MoveOnly moveOnly(std::move(vector[0]));
+  vector.remove(0);
+  ASSERT_EQ(2, moveOnly.value());
+  ASSERT_EQ(0u, vector.size());
+
+  size_t count = vector.capacity() + 1;
+  for (size_t i = 0; i < count; i++)
+    vector.append(
+        MoveOnly(i + 1));  // +1 to distinguish from default-constructed.
+
+  // Reallocation did not affect the vector's content.
+  EXPECT_EQ(count, vector.size());
+  for (size_t i = 0; i < vector.size(); i++)
+    EXPECT_EQ(static_cast<int>(i + 1), vector[i].value());
+
+  WTF::Vector<MoveOnly> otherVector;
+  vector.swap(otherVector);
+  EXPECT_EQ(count, otherVector.size());
+  EXPECT_EQ(0u, vector.size());
+
+  vector = std::move(otherVector);
+  EXPECT_EQ(count, vector.size());
 }
 
 // WrappedInt class will fail if it was memmoved or memcpyed.
 static HashSet<void*> constructedWrappedInts;
 class WrappedInt {
-public:
-    WrappedInt(int i = 0)
-        : m_originalThisPtr(this)
-        , m_i(i)
-    {
-        constructedWrappedInts.add(this);
-    }
-
-    WrappedInt(const WrappedInt& other)
-        : m_originalThisPtr(this)
-        , m_i(other.m_i)
-    {
-        constructedWrappedInts.add(this);
-    }
-
-    WrappedInt& operator=(const WrappedInt& other)
-    {
-        m_i = other.m_i;
-        return *this;
-    }
-
-    ~WrappedInt()
-    {
-        EXPECT_EQ(m_originalThisPtr, this);
-        EXPECT_TRUE(constructedWrappedInts.contains(this));
-        constructedWrappedInts.remove(this);
-    }
-
-    int get() const { return m_i; }
-
-private:
-    void* m_originalThisPtr;
-    int m_i;
+ public:
+  WrappedInt(int i = 0) : m_originalThisPtr(this), m_i(i) {
+    constructedWrappedInts.add(this);
+  }
+
+  WrappedInt(const WrappedInt& other)
+      : m_originalThisPtr(this), m_i(other.m_i) {
+    constructedWrappedInts.add(this);
+  }
+
+  WrappedInt& operator=(const WrappedInt& other) {
+    m_i = other.m_i;
+    return *this;
+  }
+
+  ~WrappedInt() {
+    EXPECT_EQ(m_originalThisPtr, this);
+    EXPECT_TRUE(constructedWrappedInts.contains(this));
+    constructedWrappedInts.remove(this);
+  }
+
+  int get() const { return m_i; }
+
+ private:
+  void* m_originalThisPtr;
+  int m_i;
 };
 
-TEST(VectorTest, SwapWithInlineCapacity)
-{
-    const size_t inlineCapacity = 2;
-    Vector<WrappedInt, inlineCapacity> vectorA;
-    vectorA.append(WrappedInt(1));
-    Vector<WrappedInt, inlineCapacity> vectorB;
-    vectorB.append(WrappedInt(2));
-
-    EXPECT_EQ(vectorA.size(), vectorB.size());
-    vectorA.swap(vectorB);
-
-    EXPECT_EQ(1u, vectorA.size());
-    EXPECT_EQ(2, vectorA.at(0).get());
-    EXPECT_EQ(1u, vectorB.size());
-    EXPECT_EQ(1, vectorB.at(0).get());
-
-    vectorA.append(WrappedInt(3));
-
-    EXPECT_GT(vectorA.size(), vectorB.size());
-    vectorA.swap(vectorB);
-
-    EXPECT_EQ(1u, vectorA.size());
-    EXPECT_EQ(1, vectorA.at(0).get());
-    EXPECT_EQ(2u, vectorB.size());
-    EXPECT_EQ(2, vectorB.at(0).get());
-    EXPECT_EQ(3, vectorB.at(1).get());
-
-    EXPECT_LT(vectorA.size(), vectorB.size());
-    vectorA.swap(vectorB);
-
-    EXPECT_EQ(2u, vectorA.size());
-    EXPECT_EQ(2, vectorA.at(0).get());
-    EXPECT_EQ(3, vectorA.at(1).get());
-    EXPECT_EQ(1u, vectorB.size());
-    EXPECT_EQ(1, vectorB.at(0).get());
-
-    vectorA.append(WrappedInt(4));
-    EXPECT_GT(vectorA.size(), inlineCapacity);
-    vectorA.swap(vectorB);
-
-    EXPECT_EQ(1u, vectorA.size());
-    EXPECT_EQ(1, vectorA.at(0).get());
-    EXPECT_EQ(3u, vectorB.size());
-    EXPECT_EQ(2, vectorB.at(0).get());
-    EXPECT_EQ(3, vectorB.at(1).get());
-    EXPECT_EQ(4, vectorB.at(2).get());
-
-    vectorB.swap(vectorA);
+TEST(VectorTest, SwapWithInlineCapacity) {
+  const size_t inlineCapacity = 2;
+  Vector<WrappedInt, inlineCapacity> vectorA;
+  vectorA.append(WrappedInt(1));
+  Vector<WrappedInt, inlineCapacity> vectorB;
+  vectorB.append(WrappedInt(2));
+
+  EXPECT_EQ(vectorA.size(), vectorB.size());
+  vectorA.swap(vectorB);
+
+  EXPECT_EQ(1u, vectorA.size());
+  EXPECT_EQ(2, vectorA.at(0).get());
+  EXPECT_EQ(1u, vectorB.size());
+  EXPECT_EQ(1, vectorB.at(0).get());
+
+  vectorA.append(WrappedInt(3));
+
+  EXPECT_GT(vectorA.size(), vectorB.size());
+  vectorA.swap(vectorB);
+
+  EXPECT_EQ(1u, vectorA.size());
+  EXPECT_EQ(1, vectorA.at(0).get());
+  EXPECT_EQ(2u, vectorB.size());
+  EXPECT_EQ(2, vectorB.at(0).get());
+  EXPECT_EQ(3, vectorB.at(1).get());
+
+  EXPECT_LT(vectorA.size(), vectorB.size());
+  vectorA.swap(vectorB);
+
+  EXPECT_EQ(2u, vectorA.size());
+  EXPECT_EQ(2, vectorA.at(0).get());
+  EXPECT_EQ(3, vectorA.at(1).get());
+  EXPECT_EQ(1u, vectorB.size());
+  EXPECT_EQ(1, vectorB.at(0).get());
+
+  vectorA.append(WrappedInt(4));
+  EXPECT_GT(vectorA.size(), inlineCapacity);
+  vectorA.swap(vectorB);
+
+  EXPECT_EQ(1u, vectorA.size());
+  EXPECT_EQ(1, vectorA.at(0).get());
+  EXPECT_EQ(3u, vectorB.size());
+  EXPECT_EQ(2, vectorB.at(0).get());
+  EXPECT_EQ(3, vectorB.at(1).get());
+  EXPECT_EQ(4, vectorB.at(2).get());
+
+  vectorB.swap(vectorA);
 }
 
 #if defined(ANNOTATE_CONTIGUOUS_CONTAINER)
-TEST(VectorTest, ContainerAnnotations)
-{
-    Vector<int> vectorA;
-    vectorA.append(10);
-    vectorA.reserveCapacity(32);
-
-    volatile int* intPointerA = vectorA.data();
-    EXPECT_DEATH(intPointerA[1] = 11, "container-overflow");
-    vectorA.append(11);
-    intPointerA[1] = 11;
-    EXPECT_DEATH(intPointerA[2] = 12, "container-overflow");
-    EXPECT_DEATH((void)intPointerA[2], "container-overflow");
-    vectorA.shrinkToFit();
-    vectorA.reserveCapacity(16);
-    intPointerA = vectorA.data();
-    EXPECT_DEATH((void)intPointerA[2], "container-overflow");
-
-    Vector<int> vectorB(vectorA);
-    vectorB.reserveCapacity(16);
-    volatile int* intPointerB = vectorB.data();
-    EXPECT_DEATH((void)intPointerB[2], "container-overflow");
-
-    Vector<int> vectorC((Vector<int>(vectorA)));
-    volatile int* intPointerC = vectorC.data();
-    EXPECT_DEATH((void)intPointerC[2], "container-overflow");
-    vectorC.append(13);
-    vectorC.swap(vectorB);
-
-    volatile int* intPointerB2 = vectorB.data();
-    volatile int* intPointerC2 = vectorC.data();
-    intPointerB2[2] = 13;
-    EXPECT_DEATH((void)intPointerB2[3], "container-overflow");
-    EXPECT_DEATH((void)intPointerC2[2], "container-overflow");
-
-    vectorB = vectorC;
-    volatile int* intPointerB3 = vectorB.data();
-    EXPECT_DEATH((void)intPointerB3[2], "container-overflow");
+TEST(VectorTest, ContainerAnnotations) {
+  Vector<int> vectorA;
+  vectorA.append(10);
+  vectorA.reserveCapacity(32);
+
+  volatile int* intPointerA = vectorA.data();
+  EXPECT_DEATH(intPointerA[1] = 11, "container-overflow");
+  vectorA.append(11);
+  intPointerA[1] = 11;
+  EXPECT_DEATH(intPointerA[2] = 12, "container-overflow");
+  EXPECT_DEATH((void)intPointerA[2], "container-overflow");
+  vectorA.shrinkToFit();
+  vectorA.reserveCapacity(16);
+  intPointerA = vectorA.data();
+  EXPECT_DEATH((void)intPointerA[2], "container-overflow");
+
+  Vector<int> vectorB(vectorA);
+  vectorB.reserveCapacity(16);
+  volatile int* intPointerB = vectorB.data();
+  EXPECT_DEATH((void)intPointerB[2], "container-overflow");
+
+  Vector<int> vectorC((Vector<int>(vectorA)));
+  volatile int* intPointerC = vectorC.data();
+  EXPECT_DEATH((void)intPointerC[2], "container-overflow");
+  vectorC.append(13);
+  vectorC.swap(vectorB);
+
+  volatile int* intPointerB2 = vectorB.data();
+  volatile int* intPointerC2 = vectorC.data();
+  intPointerB2[2] = 13;
+  EXPECT_DEATH((void)intPointerB2[3], "container-overflow");
+  EXPECT_DEATH((void)intPointerC2[2], "container-overflow");
+
+  vectorB = vectorC;
+  volatile int* intPointerB3 = vectorB.data();
+  EXPECT_DEATH((void)intPointerB3[2], "container-overflow");
 }
-#endif // defined(ANNOTATE_CONTIGUOUS_CONTAINER)
+#endif  // defined(ANNOTATE_CONTIGUOUS_CONTAINER)
 
-class Comparable {
-};
-bool operator==(const Comparable& a, const Comparable& b) { return true; }
-
-template<typename T> void compare()
-{
-    EXPECT_TRUE(Vector<T>() == Vector<T>());
-    EXPECT_FALSE(Vector<T>(1) == Vector<T>(0));
-    EXPECT_FALSE(Vector<T>() == Vector<T>(1));
-    EXPECT_TRUE(Vector<T>(1) == Vector<T>(1));
-
-    Vector<T, 1> vectorWithInlineCapacity;
-    EXPECT_TRUE(vectorWithInlineCapacity == Vector<T>());
-    EXPECT_FALSE(vectorWithInlineCapacity == Vector<T>(1));
+class Comparable {};
+bool operator==(const Comparable& a, const Comparable& b) {
+  return true;
+}
+
+template <typename T>
+void compare() {
+  EXPECT_TRUE(Vector<T>() == Vector<T>());
+  EXPECT_FALSE(Vector<T>(1) == Vector<T>(0));
+  EXPECT_FALSE(Vector<T>() == Vector<T>(1));
+  EXPECT_TRUE(Vector<T>(1) == Vector<T>(1));
+
+  Vector<T, 1> vectorWithInlineCapacity;
+  EXPECT_TRUE(vectorWithInlineCapacity == Vector<T>());
+  EXPECT_FALSE(vectorWithInlineCapacity == Vector<T>(1));
 }
 
-TEST(VectorTest, Compare)
-{
-    compare<int>();
-    compare<Comparable>();
-    compare<WTF::String>();
+TEST(VectorTest, Compare) {
+  compare<int>();
+  compare<Comparable>();
+  compare<WTF::String>();
 }
 
-TEST(VectorTest, AppendFirst)
-{
-    Vector<WTF::String> vector;
-    vector.append("string");
-    // Test passes if it does not crash (reallocation did not make
-    // the input reference stale).
-    size_t limit = vector.capacity() + 1;
-    for (size_t i = 0; i < limit; i++)
-        vector.append(vector.first());
-
-    limit = vector.capacity() + 1;
-    for (size_t i = 0; i < limit; i++)
-        vector.append(const_cast<const WTF::String&>(vector.first()));
+TEST(VectorTest, AppendFirst) {
+  Vector<WTF::String> vector;
+  vector.append("string");
+  // Test passes if it does not crash (reallocation did not make
+  // the input reference stale).
+  size_t limit = vector.capacity() + 1;
+  for (size_t i = 0; i < limit; i++)
+    vector.append(vector.first());
+
+  limit = vector.capacity() + 1;
+  for (size_t i = 0; i < limit; i++)
+    vector.append(const_cast<const WTF::String&>(vector.first()));
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
-} // namespace WTF
+}  // namespace WTF