Migrate WTF::Deque::append() to ::push_back()

third_party/WebKit/Source/wtf/DequeTest.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 77 matching lines @@
       ++index;
     }
   }
   EXPECT_EQ(increment ? deque.rend() : deque.rbegin(), it);
   EXPECT_EQ(increment ? deque.size() : 0, index);
 }
 
 template <size_t inlineCapacity>
 void reverseTest() {
   Deque<int, inlineCapacity> intDeque;
-  intDeque.append(10);
-  intDeque.append(11);
-  intDeque.append(12);
-  intDeque.append(13);
+  intDeque.push_back(10);
+  intDeque.push_back(11);
+  intDeque.push_back(12);
+  intDeque.push_back(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);
+  intDeque.push_back(14);
+  intDeque.push_back(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);
+    intDeque.push_back(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);
@@ skipping 39 matching lines @@
 
  private:
   int m_i;
   int* m_destructNumber;
 };
 
 template <typename OwnPtrDeque>
 void ownPtrTest() {
   int destructNumber = 0;
   OwnPtrDeque deque;
-  deque.append(WTF::wrapUnique(new DestructCounter(0, &destructNumber)));
-  deque.append(WTF::wrapUnique(new DestructCounter(1, &destructNumber)));
+  deque.push_back(WTF::wrapUnique(new DestructCounter(0, &destructNumber)));
+  deque.push_back(WTF::wrapUnique(new DestructCounter(1, &destructNumber)));
   EXPECT_EQ(2u, deque.size());
 
   std::unique_ptr<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 (auto iter = deque.begin(); iter != deque.end(); ++iter) {
@@ skipping 68 matching lines @@
 
   int value() const { return m_i; }
 
  private:
   WTF_MAKE_NONCOPYABLE(MoveOnly);
   int m_i;
 };
 
 TEST(DequeTest, MoveOnlyType) {
   Deque<MoveOnly> deque;
-  deque.append(MoveOnly(1));
-  deque.append(MoveOnly(2));
+  deque.push_back(MoveOnly(1));
+  deque.push_back(MoveOnly(2));
   EXPECT_EQ(2u, deque.size());
 
   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());
 
   Deque<MoveOnly> otherDeque;
@@ skipping 30 matching lines @@
   int get() const { return m_i; }
 
  private:
   void* m_originalThisPtr;
   int m_i;
 };
 
 template <size_t inlineCapacity>
 void swapWithOrWithoutInlineCapacity() {
   Deque<WrappedInt, inlineCapacity> dequeA;
-  dequeA.append(WrappedInt(1));
+  dequeA.push_back(WrappedInt(1));
   Deque<WrappedInt, inlineCapacity> dequeB;
-  dequeB.append(WrappedInt(2));
+  dequeB.push_back(WrappedInt(2));
 
   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());
 
-  dequeA.append(WrappedInt(3));
+  dequeA.push_back(WrappedInt(3));
 
   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_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());
 
-  dequeA.append(WrappedInt(4));
+  dequeA.push_back(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());
 
   dequeB.swap(dequeA);
 }
 
@@ skipping 20 matching lines @@
 }
 
 template <size_t inlineCapacity>
 void testDestructorAndConstructorCallsWhenSwappingWithInlineCapacity() {
   LivenessCounter::s_live = 0;
   LivenessCounter counter;
   EXPECT_EQ(0u, LivenessCounter::s_live);
 
   Deque<RefPtr<LivenessCounter>, inlineCapacity> deque;
   Deque<RefPtr<LivenessCounter>, inlineCapacity> deque2;
-  deque.append(&counter);
-  deque2.append(&counter);
+  deque.push_back(&counter);
+  deque2.push_back(&counter);
   EXPECT_EQ(2u, LivenessCounter::s_live);
 
   // Add various numbers of elements to deques, then remove various numbers
   // of elements from the head. This creates in-use ranges in the backing
   // that sometimes wrap around the end of the buffer, testing various ways
   // in which the in-use ranges of the inline buffers can overlap when we
   // call swap().
   for (unsigned i = 0; i < 12; i++) {
     if (!interestingNumber(i))
       continue;
     for (unsigned j = i; j < 12; j++) {
       if (!interestingNumber(j))
         continue;
       deque.clear();
       deque2.clear();
       EXPECT_EQ(0u, LivenessCounter::s_live);
       for (unsigned k = 0; k < j; k++)
-        deque.append(&counter);
+        deque.push_back(&counter);
       EXPECT_EQ(j, LivenessCounter::s_live);
       EXPECT_EQ(j, deque.size());
       for (unsigned k = 0; k < i; k++)
         deque.removeFirst();
 
       EXPECT_EQ(j - i, LivenessCounter::s_live);
       EXPECT_EQ(j - i, deque.size());
       deque.swap(deque2);
       EXPECT_EQ(j - i, LivenessCounter::s_live);
       EXPECT_EQ(0u, deque.size());
       EXPECT_EQ(j - i, deque2.size());
       deque.swap(deque2);
       EXPECT_EQ(j - i, LivenessCounter::s_live);
 
-      deque2.append(&counter);
-      deque2.append(&counter);
-      deque2.append(&counter);
+      deque2.push_back(&counter);
+      deque2.push_back(&counter);
+      deque2.push_back(&counter);
 
       for (unsigned k = 0; k < 12; k++) {
         EXPECT_EQ(3 + j - i, LivenessCounter::s_live);
         EXPECT_EQ(j - i, deque.size());
         EXPECT_EQ(3u, deque2.size());
         deque.swap(deque2);
         EXPECT_EQ(3 + j - i, LivenessCounter::s_live);
         EXPECT_EQ(j - i, deque2.size());
         EXPECT_EQ(3u, deque.size());
         deque.swap(deque2);
         EXPECT_EQ(3 + j - i, LivenessCounter::s_live);
         EXPECT_EQ(j - i, deque.size());
         EXPECT_EQ(3u, deque2.size());
 
         deque2.removeFirst();
-        deque2.append(&counter);
+        deque2.push_back(&counter);
       }
     }
   }
 }
 
 TEST(DequeTest, SwapWithConstructorsAndDestructors) {
   testDestructorAndConstructorCallsWhenSwappingWithInlineCapacity<0>();
   testDestructorAndConstructorCallsWhenSwappingWithInlineCapacity<4>();
   testDestructorAndConstructorCallsWhenSwappingWithInlineCapacity<9>();
 }
@@ skipping 16 matching lines @@
         continue;
       for (unsigned size = 0; size < 12; size++) {
         if (!interestingNumber(size))
           continue;
         for (unsigned size2 = 0; size2 < 12; size2++) {
           if (!interestingNumber(size2))
             continue;
           deque.clear();
           deque2.clear();
           for (unsigned i = 0; i < pad; i++)
-            deque.append(103);
+            deque.push_back(103);
           for (unsigned i = 0; i < pad2; i++)
-            deque2.append(888);
+            deque2.push_back(888);
           for (unsigned i = 0; i < size; i++)
-            deque.append(i);
+            deque.push_back(i);
           for (unsigned i = 0; i < size2; i++)
-            deque2.append(i + 42);
+            deque2.push_back(i + 42);
           for (unsigned i = 0; i < pad; i++)
             EXPECT_EQ(103u, deque.takeFirst());
           for (unsigned i = 0; i < pad2; i++)
             EXPECT_EQ(888u, deque2.takeFirst());
           EXPECT_EQ(size, deque.size());
           EXPECT_EQ(size2, deque2.size());
           deque.swap(deque2);
           for (unsigned i = 0; i < size; i++)
             EXPECT_EQ(i, deque2.takeFirst());
           for (unsigned i = 0; i < size2; i++)
             EXPECT_EQ(i + 42, deque.takeFirst());
         }
       }
     }
   }
 }
 
 TEST(DequeTest, ValuesMovedAndSwappedWithInlineCapacity) {
   testValuesMovedAndSwappedWithInlineCapacity<0>();
   testValuesMovedAndSwappedWithInlineCapacity<4>();
   testValuesMovedAndSwappedWithInlineCapacity<9>();
 }
 
 TEST(DequeTest, UniquePtr) {
   using Pointer = std::unique_ptr<int>;
   Deque<Pointer> deque;
-  deque.append(Pointer(new int(1)));
-  deque.append(Pointer(new int(2)));
+  deque.push_back(Pointer(new int(1)));
+  deque.push_back(Pointer(new int(2)));
   deque.prepend(Pointer(new int(-1)));
   deque.prepend(Pointer(new int(-2)));
   ASSERT_EQ(4u, deque.size());
   EXPECT_EQ(-2, *deque[0]);
   EXPECT_EQ(-1, *deque[1]);
   EXPECT_EQ(1, *deque[2]);
   EXPECT_EQ(2, *deque[3]);
 
   Pointer first(deque.takeFirst());
   EXPECT_EQ(-2, *first);
   Pointer last(deque.takeLast());
   EXPECT_EQ(2, *last);
 
   EXPECT_EQ(2u, deque.size());
   deque.removeFirst();
   deque.pop_back();
   EXPECT_EQ(0u, deque.size());
 
-  deque.append(Pointer(new int(42)));
+  deque.push_back(Pointer(new int(42)));
   deque[0] = Pointer(new int(24));
   ASSERT_EQ(1u, deque.size());
   EXPECT_EQ(24, *deque[0]);
 
   deque.clear();
 }
 
 class CountCopy final {
  public:
   explicit CountCopy(int* counter = nullptr) : m_counter(counter) {}
@@ skipping 11 matching lines @@
  private:
   int* m_counter;
 };
 
 TEST(DequeTest, MoveShouldNotMakeCopy) {
   // Because data in inline buffer may be swapped or moved individually, we
   // force the creation of out-of-line buffer so we can make sure there's no
   // element-wise copy/move.
   Deque<CountCopy, 1> deque;
   int counter = 0;
-  deque.append(CountCopy(&counter));
-  deque.append(CountCopy(&counter));
+  deque.push_back(CountCopy(&counter));
+  deque.push_back(CountCopy(&counter));
 
   Deque<CountCopy, 1> other(deque);
   counter = 0;
   deque = std::move(other);  // Move assignment.
   EXPECT_EQ(0, counter);
 
   counter = 0;
   Deque<CountCopy, 1> yetAnother(std::move(deque));  // Move construction.
   EXPECT_EQ(0, counter);
 }
 
 TEST(DequeTest, RemoveWhileIterating) {
   Deque<int> deque;
   for (int i = 0; i < 10; ++i)
-    deque.append(i);
+    deque.push_back(i);
 
   // All numbers present.
   {
     int i = 0;
     for (int v : deque)
       EXPECT_EQ(i++, v);
   }
 
   // Remove the even numbers while iterating.
   for (auto it = deque.begin(); it != deque.end(); ++it) {
@@ skipping 37 matching lines @@
   EXPECT_EQ(2u, deque.size());
   EXPECT_EQ(3, deque[0].value1);
   EXPECT_EQ(4, deque[0].value2);
   EXPECT_EQ(1, deque[1].value1);
   EXPECT_EQ(2, deque[1].value2);
 }
 
 }  // anonymous namespace
 
 }  // namespace WTF