wtf reformat test

third_party/WebKit/Source/wtf/DequeTest.cpp

Index: third_party/WebKit/Source/wtf/DequeTest.cpp
diff --git a/third_party/WebKit/Source/wtf/DequeTest.cpp b/third_party/WebKit/Source/wtf/DequeTest.cpp
index e204fb23d4b94f83efd62029b2f0e7b54a6c1a91..b3d290a2cf9d55afbbf4952e22b74adf51b1891d 100644
--- a/third_party/WebKit/Source/wtf/DequeTest.cpp
+++ b/third_party/WebKit/Source/wtf/DequeTest.cpp
@@ -34,334 +34,315 @@ namespace WTF {
 
 namespace {
 
-TEST(DequeTest, Basic)
-{
-    Deque<int> intDeque;
-    EXPECT_TRUE(intDeque.isEmpty());
-    EXPECT_EQ(0ul, intDeque.size());
+TEST(DequeTest, Basic) {
+  Deque<int> intDeque;
+  EXPECT_TRUE(intDeque.isEmpty());
+  EXPECT_EQ(0ul, intDeque.size());
 }
 
-void checkNumberSequence(Deque<int>& deque, int from, int to, bool increment)
-{
-    Deque<int>::iterator it = increment ? deque.begin() : deque.end();
-    size_t index = increment ? 0 : deque.size();
-    int step = from < to ? 1 : -1;
-    for (int i = from; i != to + step; i += step) {
-        if (!increment) {
-            --it;
-            --index;
-        }
-
-        EXPECT_EQ(i, *it);
-        EXPECT_EQ(i, deque[index]);
-
-        if (increment) {
-            ++it;
-            ++index;
-        }
+void checkNumberSequence(Deque<int>& deque, int from, int to, bool increment) {
+  Deque<int>::iterator it = increment ? deque.begin() : deque.end();
+  size_t index = increment ? 0 : deque.size();
+  int step = from < to ? 1 : -1;
+  for (int i = from; i != to + step; i += step) {
+    if (!increment) {
+      --it;
+      --index;
     }
-    EXPECT_EQ(increment ? deque.end() : deque.begin(), it);
-    EXPECT_EQ(increment ? deque.size() : 0, index);
-}
 
-void checkNumberSequenceReverse(Deque<int>& deque, int from, int to, bool increment)
-{
-    Deque<int>::reverse_iterator it = increment ? deque.rbegin() : deque.rend();
-    size_t index = increment ? 0 : deque.size();
-    int step = from < to ? 1 : -1;
-    for (int i = from; i != to + step; i += step) {
-        if (!increment) {
-            --it;
-            --index;
-        }
-
-        EXPECT_EQ(i, *it);
-        EXPECT_EQ(i, deque.at(deque.size() - 1 - index));
-
-        if (increment) {
-            ++it;
-            ++index;
-        }
+    EXPECT_EQ(i, *it);
+    EXPECT_EQ(i, deque[index]);
+
+    if (increment) {
+      ++it;
+      ++index;
     }
-    EXPECT_EQ(increment ? deque.rend() : deque.rbegin(), it);
-    EXPECT_EQ(increment ? deque.size() : 0, index);
+  }
+  EXPECT_EQ(increment ? deque.end() : deque.begin(), it);
+  EXPECT_EQ(increment ? deque.size() : 0, index);
 }
 
-TEST(DequeTest, Reverse)
-{
-    Deque<int> intDeque;
-    intDeque.append(10);
-    intDeque.append(11);
-    intDeque.append(12);
-    intDeque.append(13);
-
-    checkNumberSequence(intDeque, 10, 13, true);
-    checkNumberSequence(intDeque, 13, 10, false);
-    checkNumberSequenceReverse(intDeque, 13, 10, true);
-    checkNumberSequenceReverse(intDeque, 10, 13, false);
-
-    intDeque.append(14);
-    intDeque.append(15);
-    EXPECT_EQ(10, intDeque.takeFirst());
-    EXPECT_EQ(15, intDeque.takeLast());
-    checkNumberSequence(intDeque, 11, 14, true);
-    checkNumberSequence(intDeque, 14, 11, false);
-    checkNumberSequenceReverse(intDeque, 14, 11, true);
-    checkNumberSequenceReverse(intDeque, 11, 14, false);
-
-    for (int i = 15; i < 200; ++i)
-        intDeque.append(i);
-    checkNumberSequence(intDeque, 11, 199, true);
-    checkNumberSequence(intDeque, 199, 11, false);
-    checkNumberSequenceReverse(intDeque, 199, 11, true);
-    checkNumberSequenceReverse(intDeque, 11, 199, false);
-
-    for (int i = 0; i < 180; ++i) {
-        EXPECT_EQ(i + 11, intDeque[0]);
-        EXPECT_EQ(i + 11, intDeque.takeFirst());
+void checkNumberSequenceReverse(Deque<int>& deque,
+                                int from,
+                                int to,
+                                bool increment) {
+  Deque<int>::reverse_iterator it = increment ? deque.rbegin() : deque.rend();
+  size_t index = increment ? 0 : deque.size();
+  int step = from < to ? 1 : -1;
+  for (int i = from; i != to + step; i += step) {
+    if (!increment) {
+      --it;
+      --index;
     }
-    checkNumberSequence(intDeque, 191, 199, true);
-    checkNumberSequence(intDeque, 199, 191, false);
-    checkNumberSequenceReverse(intDeque, 199, 191, true);
-    checkNumberSequenceReverse(intDeque, 191, 199, false);
-
-    Deque<int> intDeque2;
-    swap(intDeque, intDeque2);
 
-    checkNumberSequence(intDeque2, 191, 199, true);
-    checkNumberSequence(intDeque2, 199, 191, false);
-    checkNumberSequenceReverse(intDeque2, 199, 191, true);
-    checkNumberSequenceReverse(intDeque2, 191, 199, false);
+    EXPECT_EQ(i, *it);
+    EXPECT_EQ(i, deque.at(deque.size() - 1 - index));
 
-    intDeque.swap(intDeque2);
-
-    checkNumberSequence(intDeque, 191, 199, true);
-    checkNumberSequence(intDeque, 199, 191, false);
-    checkNumberSequenceReverse(intDeque, 199, 191, true);
-    checkNumberSequenceReverse(intDeque, 191, 199, false);
-
-    intDeque.swap(intDeque2);
+    if (increment) {
+      ++it;
+      ++index;
+    }
+  }
+  EXPECT_EQ(increment ? deque.rend() : deque.rbegin(), it);
+  EXPECT_EQ(increment ? deque.size() : 0, index);
+}
 
-    checkNumberSequence(intDeque2, 191, 199, true);
-    checkNumberSequence(intDeque2, 199, 191, false);
-    checkNumberSequenceReverse(intDeque2, 199, 191, true);
-    checkNumberSequenceReverse(intDeque2, 191, 199, false);
+TEST(DequeTest, Reverse) {
+  Deque<int> intDeque;
+  intDeque.append(10);
+  intDeque.append(11);
+  intDeque.append(12);
+  intDeque.append(13);
+
+  checkNumberSequence(intDeque, 10, 13, true);
+  checkNumberSequence(intDeque, 13, 10, false);
+  checkNumberSequenceReverse(intDeque, 13, 10, true);
+  checkNumberSequenceReverse(intDeque, 10, 13, false);
+
+  intDeque.append(14);
+  intDeque.append(15);
+  EXPECT_EQ(10, intDeque.takeFirst());
+  EXPECT_EQ(15, intDeque.takeLast());
+  checkNumberSequence(intDeque, 11, 14, true);
+  checkNumberSequence(intDeque, 14, 11, false);
+  checkNumberSequenceReverse(intDeque, 14, 11, true);
+  checkNumberSequenceReverse(intDeque, 11, 14, false);
+
+  for (int i = 15; i < 200; ++i)
+    intDeque.append(i);
+  checkNumberSequence(intDeque, 11, 199, true);
+  checkNumberSequence(intDeque, 199, 11, false);
+  checkNumberSequenceReverse(intDeque, 199, 11, true);
+  checkNumberSequenceReverse(intDeque, 11, 199, false);
+
+  for (int i = 0; i < 180; ++i) {
+    EXPECT_EQ(i + 11, intDeque[0]);
+    EXPECT_EQ(i + 11, intDeque.takeFirst());
+  }
+  checkNumberSequence(intDeque, 191, 199, true);
+  checkNumberSequence(intDeque, 199, 191, false);
+  checkNumberSequenceReverse(intDeque, 199, 191, true);
+  checkNumberSequenceReverse(intDeque, 191, 199, false);
+
+  Deque<int> intDeque2;
+  swap(intDeque, intDeque2);
+
+  checkNumberSequence(intDeque2, 191, 199, true);
+  checkNumberSequence(intDeque2, 199, 191, false);
+  checkNumberSequenceReverse(intDeque2, 199, 191, true);
+  checkNumberSequenceReverse(intDeque2, 191, 199, false);
+
+  intDeque.swap(intDeque2);
+
+  checkNumberSequence(intDeque, 191, 199, true);
+  checkNumberSequence(intDeque, 199, 191, false);
+  checkNumberSequenceReverse(intDeque, 199, 191, true);
+  checkNumberSequenceReverse(intDeque, 191, 199, false);
+
+  intDeque.swap(intDeque2);
+
+  checkNumberSequence(intDeque2, 191, 199, true);
+  checkNumberSequence(intDeque2, 199, 191, false);
+  checkNumberSequenceReverse(intDeque2, 199, 191, true);
+  checkNumberSequenceReverse(intDeque2, 191, 199, false);
 }
 
 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;
 };
 
 using OwnPtrDeque = Deque<OwnPtr<DestructCounter>>;
 
-TEST(DequeTest, OwnPtr)
-{
-    int destructNumber = 0;
-    OwnPtrDeque deque;
-    deque.append(adoptPtr(new DestructCounter(0, &destructNumber)));
-    deque.append(adoptPtr(new DestructCounter(1, &destructNumber)));
-    EXPECT_EQ(2u, deque.size());
-
-    OwnPtr<DestructCounter>& counter0 = deque.first();
-    EXPECT_EQ(0, counter0->get());
-    int counter1 = deque.last()->get();
-    EXPECT_EQ(1, counter1);
-    EXPECT_EQ(0, destructNumber);
-
-    size_t index = 0;
-    for (OwnPtrDeque::iterator iter = deque.begin(); iter != deque.end(); ++iter) {
-        OwnPtr<DestructCounter>& refCounter = *iter;
-        EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
-        EXPECT_EQ(index, static_cast<size_t>((*refCounter).get()));
-        index++;
-    }
-    EXPECT_EQ(0, destructNumber);
-
-    OwnPtrDeque::iterator it = deque.begin();
-    for (index = 0; index < deque.size(); ++index) {
-        OwnPtr<DestructCounter>& refCounter = *it;
-        EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
-        index++;
-        ++it;
-    }
-    EXPECT_EQ(0, destructNumber);
-
-    EXPECT_EQ(0, deque.first()->get());
-    deque.removeFirst();
-    EXPECT_EQ(1, deque.first()->get());
-    EXPECT_EQ(1u, deque.size());
-    EXPECT_EQ(1, destructNumber);
-
-    OwnPtr<DestructCounter> ownCounter1 = deque.first().release();
-    deque.removeFirst();
-    EXPECT_EQ(counter1, ownCounter1->get());
-    EXPECT_EQ(0u, deque.size());
-    EXPECT_EQ(1, destructNumber);
-
-    ownCounter1.clear();
-    EXPECT_EQ(2, destructNumber);
-
-    size_t count = 1025;
-    destructNumber = 0;
-    for (size_t i = 0; i < count; ++i)
-        deque.prepend(adoptPtr(new DestructCounter(i, &destructNumber)));
-
-    // Deque relocation must not destruct OwnPtr element.
-    EXPECT_EQ(0, destructNumber);
-    EXPECT_EQ(count, deque.size());
-
-    OwnPtrDeque copyDeque;
-    deque.swap(copyDeque);
-    EXPECT_EQ(0, destructNumber);
-    EXPECT_EQ(count, copyDeque.size());
-    EXPECT_EQ(0u, deque.size());
-
-    copyDeque.clear();
-    EXPECT_EQ(count, static_cast<size_t>(destructNumber));
+TEST(DequeTest, OwnPtr) {
+  int destructNumber = 0;
+  OwnPtrDeque deque;
+  deque.append(adoptPtr(new DestructCounter(0, &destructNumber)));
+  deque.append(adoptPtr(new DestructCounter(1, &destructNumber)));
+  EXPECT_EQ(2u, deque.size());
+
+  OwnPtr<DestructCounter>& counter0 = deque.first();
+  EXPECT_EQ(0, counter0->get());
+  int counter1 = deque.last()->get();
+  EXPECT_EQ(1, counter1);
+  EXPECT_EQ(0, destructNumber);
+
+  size_t index = 0;
+  for (OwnPtrDeque::iterator iter = deque.begin(); iter != deque.end();
+       ++iter) {
+    OwnPtr<DestructCounter>& refCounter = *iter;
+    EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
+    EXPECT_EQ(index, static_cast<size_t>((*refCounter).get()));
+    index++;
+  }
+  EXPECT_EQ(0, destructNumber);
+
+  OwnPtrDeque::iterator it = deque.begin();
+  for (index = 0; index < deque.size(); ++index) {
+    OwnPtr<DestructCounter>& refCounter = *it;
+    EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
+    index++;
+    ++it;
+  }
+  EXPECT_EQ(0, destructNumber);
+
+  EXPECT_EQ(0, deque.first()->get());
+  deque.removeFirst();
+  EXPECT_EQ(1, deque.first()->get());
+  EXPECT_EQ(1u, deque.size());
+  EXPECT_EQ(1, destructNumber);
+
+  OwnPtr<DestructCounter> ownCounter1 = deque.first().release();
+  deque.removeFirst();
+  EXPECT_EQ(counter1, ownCounter1->get());
+  EXPECT_EQ(0u, deque.size());
+  EXPECT_EQ(1, destructNumber);
+
+  ownCounter1.clear();
+  EXPECT_EQ(2, destructNumber);
+
+  size_t count = 1025;
+  destructNumber = 0;
+  for (size_t i = 0; i < count; ++i)
+    deque.prepend(adoptPtr(new DestructCounter(i, &destructNumber)));
+
+  // Deque relocation must not destruct OwnPtr element.
+  EXPECT_EQ(0, destructNumber);
+  EXPECT_EQ(count, deque.size());
+
+  OwnPtrDeque copyDeque;
+  deque.swap(copyDeque);
+  EXPECT_EQ(0, destructNumber);
+  EXPECT_EQ(count, copyDeque.size());
+  EXPECT_EQ(0u, deque.size());
+
+  copyDeque.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(DequeTest, MoveOnlyType)
-{
-    Deque<MoveOnly> deque;
-    deque.append(MoveOnly(1));
-    deque.append(MoveOnly(2));
-    EXPECT_EQ(2u, deque.size());
+TEST(DequeTest, MoveOnlyType) {
+  Deque<MoveOnly> deque;
+  deque.append(MoveOnly(1));
+  deque.append(MoveOnly(2));
+  EXPECT_EQ(2u, deque.size());
 
-    ASSERT_EQ(1, deque.first().value());
-    ASSERT_EQ(2, deque.last().value());
+  ASSERT_EQ(1, deque.first().value());
+  ASSERT_EQ(2, deque.last().value());
 
-    MoveOnly oldFirst = deque.takeFirst();
-    ASSERT_EQ(1, oldFirst.value());
-    EXPECT_EQ(1u, deque.size());
+  MoveOnly oldFirst = deque.takeFirst();
+  ASSERT_EQ(1, oldFirst.value());
+  EXPECT_EQ(1u, deque.size());
 
-    Deque<MoveOnly> otherDeque;
-    deque.swap(otherDeque);
-    EXPECT_EQ(1u, otherDeque.size());
-    EXPECT_EQ(0u, deque.size());
+  Deque<MoveOnly> otherDeque;
+  deque.swap(otherDeque);
+  EXPECT_EQ(1u, otherDeque.size());
+  EXPECT_EQ(0u, deque.size());
 }
 
 // WrappedInt class will fail if it was memmoved or memcpyed.
 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(DequeTest, SwapWithoutInlineCapacity)
-{
-    Deque<WrappedInt> dequeA;
-    dequeA.append(WrappedInt(1));
-    Deque<WrappedInt> dequeB;
-    dequeB.append(WrappedInt(2));
+TEST(DequeTest, SwapWithoutInlineCapacity) {
+  Deque<WrappedInt> dequeA;
+  dequeA.append(WrappedInt(1));
+  Deque<WrappedInt> dequeB;
+  dequeB.append(WrappedInt(2));
 
-    ASSERT_EQ(dequeA.size(), dequeB.size());
-    dequeA.swap(dequeB);
+  ASSERT_EQ(dequeA.size(), dequeB.size());
+  dequeA.swap(dequeB);
 
-    ASSERT_EQ(1u, dequeA.size());
-    EXPECT_EQ(2, dequeA.first().get());
-    ASSERT_EQ(1u, dequeB.size());
-    EXPECT_EQ(1, dequeB.first().get());
+  ASSERT_EQ(1u, dequeA.size());
+  EXPECT_EQ(2, dequeA.first().get());
+  ASSERT_EQ(1u, dequeB.size());
+  EXPECT_EQ(1, dequeB.first().get());
 
-    dequeA.append(WrappedInt(3));
+  dequeA.append(WrappedInt(3));
 
-    ASSERT_GT(dequeA.size(), dequeB.size());
-    dequeA.swap(dequeB);
+  ASSERT_GT(dequeA.size(), dequeB.size());
+  dequeA.swap(dequeB);
 
-    ASSERT_EQ(1u, dequeA.size());
-    EXPECT_EQ(1, dequeA.first().get());
-    ASSERT_EQ(2u, dequeB.size());
-    EXPECT_EQ(2, dequeB.first().get());
+  ASSERT_EQ(1u, dequeA.size());
+  EXPECT_EQ(1, dequeA.first().get());
+  ASSERT_EQ(2u, dequeB.size());
+  EXPECT_EQ(2, dequeB.first().get());
 
-    ASSERT_LT(dequeA.size(), dequeB.size());
-    dequeA.swap(dequeB);
+  ASSERT_LT(dequeA.size(), dequeB.size());
+  dequeA.swap(dequeB);
 
-    ASSERT_EQ(2u, dequeA.size());
-    EXPECT_EQ(2, dequeA.first().get());
-    ASSERT_EQ(1u, dequeB.size());
-    EXPECT_EQ(1, dequeB.first().get());
+  ASSERT_EQ(2u, dequeA.size());
+  EXPECT_EQ(2, dequeA.first().get());
+  ASSERT_EQ(1u, dequeB.size());
+  EXPECT_EQ(1, dequeB.first().get());
 
-    dequeA.append(WrappedInt(4));
-    dequeA.swap(dequeB);
+  dequeA.append(WrappedInt(4));
+  dequeA.swap(dequeB);
 
-    ASSERT_EQ(1u, dequeA.size());
-    EXPECT_EQ(1, dequeA.first().get());
-    ASSERT_EQ(3u, dequeB.size());
-    EXPECT_EQ(2, dequeB.first().get());
+  ASSERT_EQ(1u, dequeA.size());
+  EXPECT_EQ(1, dequeA.first().get());
+  ASSERT_EQ(3u, dequeB.size());
+  EXPECT_EQ(2, dequeB.first().get());
 
-    dequeB.swap(dequeA);
+  dequeB.swap(dequeA);
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
-} // namespace WTF
+}  // namespace WTF