Fix Deque.swap for deques with inline capacity

Source/wtf/VectorTest.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 284 matching lines @@
     EXPECT_FALSE(Vector<T>() == Vector<T>(1));
     EXPECT_TRUE(Vector<T>(1) == Vector<T>(1));
 }
 
 TEST(VectorTest, Compare)
 {
     compare<int>();
     compare<Comparable>();
     compare<WTF::String>();
 }
+
+class LivenessCounter {
+public:
+    void ref() { s_live++; }
+    void deref() { s_live--; }
+
+    static unsigned s_live;
+};
+
+unsigned LivenessCounter::s_live = 0;
+
+template<size_t inlineCapacity>
+void theBigSwapTest()
+{
+    LivenessCounter::s_live = 0;
+    LivenessCounter counter;
+    EXPECT_EQ(0u, LivenessCounter::s_live);
+
+    Vector<RefPtr<LivenessCounter>, inlineCapacity> vector;
+    Vector<RefPtr<LivenessCounter>, inlineCapacity> vector2;
+    vector.append(&counter);
+    vector2.append(&counter);
+    EXPECT_EQ(2u, LivenessCounter::s_live);
+
+    for (unsigned i = 0; i < 13; i++) {
+        for (unsigned j = 0; j < 13; j++) {
+            vector.clear();
+            vector2.clear();
+            EXPECT_EQ(0u, LivenessCounter::s_live);
+
+            for (unsigned k = 0; k < j; k++)
+                vector.append(&counter);
+            EXPECT_EQ(j, LivenessCounter::s_live);
+            EXPECT_EQ(j, vector.size());
+
+            for (unsigned k = 0; k < i; k++)
+                vector2.append(&counter);
+            EXPECT_EQ(i + j, LivenessCounter::s_live);
+            EXPECT_EQ(i, vector2.size());
+
+            vector.swap(vector2);
+            EXPECT_EQ(i + j, LivenessCounter::s_live);
+            EXPECT_EQ(i, vector.size());
+            EXPECT_EQ(j, vector2.size());
+
+            unsigned size = vector.size();
+            unsigned size2 = vector2.size();
+
+            for (unsigned k = 0; k < 5; k++) {
+                vector.swap(vector2);
+                std::swap(size, size2);
+                EXPECT_EQ(i + j, LivenessCounter::s_live);
+                EXPECT_EQ(size, vector.size());
+                EXPECT_EQ(size2, vector2.size());
+
+                vector2.append(&counter);
+                vector2.remove(0);
+            }
+        }
+    }
+
+}
+
+TEST(VectorTest, BigSwapTest)
+{
+    theBigSwapTest<0>();
+    theBigSwapTest<2>();
+    theBigSwapTest<10>();
+}
+
+template<size_t inlineCapacity>
+void swapValuesTest()
+{
+    Vector<unsigned, inlineCapacity> vector;
+    Vector<unsigned, inlineCapacity> vector2;
+
+    for (unsigned size = 0; size < 13; size++) {
+        for (unsigned size2 = 0; size2 < 13; size2++) {
+            vector.clear();
+            vector2.clear();
+            for (unsigned i = 0; i < size; i++)
+                vector.append(i);
+            for (unsigned i = 0; i < size2; i++)
+                vector2.append(i + 42);
+            EXPECT_EQ(size, vector.size());
+            EXPECT_EQ(size2, vector2.size());
+            vector.swap(vector2);
+            for (unsigned i = 0; i < size; i++)
+                EXPECT_EQ(i, vector2[i]);
+            for (unsigned i = 0; i < size2; i++)
+                EXPECT_EQ(i + 42, vector[i]);
+        }
+    }
+}
+
+TEST(VectorTest, SwapValuesTest)
+{
+    swapValuesTest<0>();
+    swapValuesTest<2>();
+    swapValuesTest<10>();
+}
+
 } // namespace