[webkit-changes] [167348] trunk

Wed, 16 Apr 2014 09:52:28 -0700

Title: [167348] trunk
Revision
167348
Author
da...@apple.com
Date
2014-04-16 09:51:17 -0700 (Wed, 16 Apr 2014)

Log Message

Make Vector::takeLast work with move-only types (and optimize for types where move is faster)
https://bugs.webkit.org/show_bug.cgi?id=131735

Reviewed by Alexey Proskuryakov.

Source/WTF:
* wtf/Vector.h:
(WTF::Vector::takeLast): Added a missing std::move. All the other take functions have it.

Tools:
* TestWebKitAPI/Tests/WTF/Vector.cpp: Added a test for Vector::takeLast with move only types.
Fixed invocations of EXPECT macros so the expected value is on the left, and the test result
is on the right. This can be confusing since our _javascript_ test framework does it the opposite
way, but gtest works better this way.

Modified Paths

Diff

Modified: trunk/Source/WTF/ChangeLog (167347 => 167348)


--- trunk/Source/WTF/ChangeLog	2014-04-16 14:24:51 UTC (rev 167347)
+++ trunk/Source/WTF/ChangeLog	2014-04-16 16:51:17 UTC (rev 167348)
@@ -1,3 +1,13 @@
+2014-04-16  Darin Adler  <da...@apple.com>
+
+        Make Vector::takeLast work with move-only types (and optimize for types where move is faster)
+        https://bugs.webkit.org/show_bug.cgi?id=131735
+
+        Reviewed by Alexey Proskuryakov.
+
+        * wtf/Vector.h:
+        (WTF::Vector::takeLast): Added a missing std::move. All the other take functions have it.
+
 2014-04-14  Mark Lam  <mark....@apple.com>
 
         monotonicallyIncreasingTime() should only initialize its static timebaseInfo once.

Modified: trunk/Source/WTF/wtf/Vector.h (167347 => 167348)


--- trunk/Source/WTF/wtf/Vector.h	2014-04-16 14:24:51 UTC (rev 167347)
+++ trunk/Source/WTF/wtf/Vector.h	2014-04-16 16:51:17 UTC (rev 167348)
@@ -661,7 +661,7 @@
     
     T takeLast()
     {
-        T result = last();
+        T result = std::move(last());
         removeLast();
         return result;
     }

Modified: trunk/Tools/ChangeLog (167347 => 167348)


--- trunk/Tools/ChangeLog	2014-04-16 14:24:51 UTC (rev 167347)
+++ trunk/Tools/ChangeLog	2014-04-16 16:51:17 UTC (rev 167348)
@@ -1,3 +1,15 @@
+2014-04-16  Darin Adler  <da...@apple.com>
+
+        Make Vector::takeLast work with move-only types (and optimize for types where move is faster)
+        https://bugs.webkit.org/show_bug.cgi?id=131735
+
+        Reviewed by Alexey Proskuryakov.
+
+        * TestWebKitAPI/Tests/WTF/Vector.cpp: Added a test for Vector::takeLast with move only types.
+        Fixed invocations of EXPECT macros so the expected value is on the left, and the test result
+        is on the right. This can be confusing since our _javascript_ test framework does it the opposite
+        way, but gtest works better this way.
+
 2014-04-15  Hyowon Kim  <hw1008....@samsung.com>
 
         [EFL] Fix problems with the pixel dump.

Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp (167347 => 167348)


--- trunk/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp	2014-04-16 14:24:51 UTC (rev 167347)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp	2014-04-16 16:51:17 UTC (rev 167348)
@@ -34,8 +34,8 @@
 {
     Vector<int> intVector;
     EXPECT_TRUE(intVector.isEmpty());
-    EXPECT_EQ(0ul, intVector.size());
-    EXPECT_EQ(0ul, intVector.capacity());
+    EXPECT_EQ(0U, intVector.size());
+    EXPECT_EQ(0U, intVector.capacity());
 }
 
 TEST(WTF_Vector, Iterator)
@@ -150,11 +150,11 @@
     for (size_t i = 0; i < 100; ++i) {
         MoveOnly moveOnly(i);
         vector.uncheckedAppend(std::move(moveOnly));
-        EXPECT_EQ(moveOnly.value(), 0U);
+        EXPECT_EQ(0U, moveOnly.value());
     }
 
     for (size_t i = 0; i < 100; ++i)
-        EXPECT_EQ(vector[i].value(), i);
+        EXPECT_EQ(i, vector[i].value());
 }
 
 TEST(WTF_Vector, MoveOnly_Append)
@@ -164,11 +164,11 @@
     for (size_t i = 0; i < 100; ++i) {
         MoveOnly moveOnly(i);
         vector.append(std::move(moveOnly));
-        EXPECT_EQ(moveOnly.value(), 0U);
+        EXPECT_EQ(0U, moveOnly.value());
     }
 
     for (size_t i = 0; i < 100; ++i)
-        EXPECT_EQ(vector[i].value(), i);
+        EXPECT_EQ(i, vector[i].value());
 
     for (size_t i = 0; i < 16; ++i) {
         Vector<MoveOnly> vector;
@@ -179,11 +179,11 @@
             vector.append(j);
         vector.append(std::move(vector[0]));
 
-        EXPECT_EQ(vector[0].value(), 0U);
+        EXPECT_EQ(0U, vector[0].value());
 
         for (size_t j = 0; j < i; ++j)
-            EXPECT_EQ(vector[j + 1].value(), j);
-        EXPECT_EQ(vector.last().value(), i);
+            EXPECT_EQ(j, vector[j + 1].value());
+        EXPECT_EQ(i, vector.last().value());
     }
 }
 
@@ -207,7 +207,7 @@
         EXPECT_EQ(0U, moveOnly.value());
     }
 
-    EXPECT_EQ(vector.size(), 200U);
+    EXPECT_EQ(200U, vector.size());
     for (size_t i = 0; i < 200; ++i) {
         if (i % 2)
             EXPECT_EQ(99 - i / 2, vector[i].value());
@@ -216,94 +216,111 @@
     }
 }
 
+TEST(WTF_Vector, MoveOnly_TakeLast)
+{
+    Vector<MoveOnly> vector;
+
+    for (size_t i = 0; i < 100; ++i) {
+        MoveOnly moveOnly(i);
+        vector.append(std::move(moveOnly));
+        EXPECT_EQ(0U, moveOnly.value());
+    }
+
+    EXPECT_EQ(100U, vector.size());
+    for (size_t i = 0; i < 100; ++i)
+        EXPECT_EQ(99 - i, vector.takeLast().value());
+
+    EXPECT_EQ(0U, vector.size());
+}
+
 TEST(WTF_Vector, VectorOfVectorsOfVectorsInlineCapacitySwap)
 {
     Vector<Vector<Vector<int, 1>, 1>, 1> a;
     Vector<Vector<Vector<int, 1>, 1>, 1> b;
     Vector<Vector<Vector<int, 1>, 1>, 1> c;
-    
-    EXPECT_EQ(a.size(), 0U);
-    EXPECT_EQ(b.size(), 0U);
-    EXPECT_EQ(c.size(), 0U);
-    
+
+    EXPECT_EQ(0U, a.size());
+    EXPECT_EQ(0U, b.size());
+    EXPECT_EQ(0U, c.size());
+
     Vector<int, 1> x;
     x.append(42);
+
+    EXPECT_EQ(1U, x.size());
+    EXPECT_EQ(42, x[0]);
     
-    EXPECT_EQ(x.size(), 1U);
-    EXPECT_EQ(x[0], 42);
-    
     Vector<Vector<int, 1>, 1> y;
     y.append(x);
     
-    EXPECT_EQ(x.size(), 1U);
-    EXPECT_EQ(x[0], 42);
-    EXPECT_EQ(y.size(), 1U);
-    EXPECT_EQ(y[0].size(), 1U);
-    EXPECT_EQ(y[0][0], 42);
+    EXPECT_EQ(1U, x.size());
+    EXPECT_EQ(42, x[0]);
+    EXPECT_EQ(1U, y.size());
+    EXPECT_EQ(1U, y[0].size());
+    EXPECT_EQ(42, y[0][0]);
     
     a.append(y);
 
-    EXPECT_EQ(x.size(), 1U);
-    EXPECT_EQ(x[0], 42);
-    EXPECT_EQ(y.size(), 1U);
-    EXPECT_EQ(y[0].size(), 1U);
-    EXPECT_EQ(y[0][0], 42);
-    EXPECT_EQ(a.size(), 1U);
-    EXPECT_EQ(a[0].size(), 1U);
-    EXPECT_EQ(a[0][0].size(), 1U);
-    EXPECT_EQ(a[0][0][0], 42);
+    EXPECT_EQ(1U, x.size());
+    EXPECT_EQ(42, x[0]);
+    EXPECT_EQ(1U, y.size());
+    EXPECT_EQ(1U, y[0].size());
+    EXPECT_EQ(42, y[0][0]);
+    EXPECT_EQ(1U, a.size());
+    EXPECT_EQ(1U, a[0].size());
+    EXPECT_EQ(1U, a[0][0].size());
+    EXPECT_EQ(42, a[0][0][0]);
     
     a.swap(b);
 
-    EXPECT_EQ(a.size(), 0U);
-    EXPECT_EQ(x.size(), 1U);
-    EXPECT_EQ(x[0], 42);
-    EXPECT_EQ(y.size(), 1U);
-    EXPECT_EQ(y[0].size(), 1U);
-    EXPECT_EQ(y[0][0], 42);
-    EXPECT_EQ(b.size(), 1U);
-    EXPECT_EQ(b[0].size(), 1U);
-    EXPECT_EQ(b[0][0].size(), 1U);
-    EXPECT_EQ(b[0][0][0], 42);
+    EXPECT_EQ(0U, a.size());
+    EXPECT_EQ(1U, x.size());
+    EXPECT_EQ(42, x[0]);
+    EXPECT_EQ(1U, y.size());
+    EXPECT_EQ(1U, y[0].size());
+    EXPECT_EQ(42, y[0][0]);
+    EXPECT_EQ(1U, b.size());
+    EXPECT_EQ(1U, b[0].size());
+    EXPECT_EQ(1U, b[0][0].size());
+    EXPECT_EQ(42, b[0][0][0]);
     
     b.swap(c);
 
-    EXPECT_EQ(a.size(), 0U);
-    EXPECT_EQ(b.size(), 0U);
-    EXPECT_EQ(x.size(), 1U);
-    EXPECT_EQ(x[0], 42);
-    EXPECT_EQ(y.size(), 1U);
-    EXPECT_EQ(y[0].size(), 1U);
-    EXPECT_EQ(y[0][0], 42);
-    EXPECT_EQ(c.size(), 1U);
-    EXPECT_EQ(c[0].size(), 1U);
-    EXPECT_EQ(c[0][0].size(), 1U);
-    EXPECT_EQ(c[0][0][0], 42);
+    EXPECT_EQ(0U, a.size());
+    EXPECT_EQ(0U, b.size());
+    EXPECT_EQ(1U, x.size());
+    EXPECT_EQ(42, x[0]);
+    EXPECT_EQ(1U, y.size());
+    EXPECT_EQ(1U, y[0].size());
+    EXPECT_EQ(42, y[0][0]);
+    EXPECT_EQ(1U, c.size());
+    EXPECT_EQ(1U, c[0].size());
+    EXPECT_EQ(1U, c[0][0].size());
+    EXPECT_EQ(42, c[0][0][0]);
     
     y[0][0] = 24;
 
-    EXPECT_EQ(x.size(), 1U);
-    EXPECT_EQ(x[0], 42);
-    EXPECT_EQ(y.size(), 1U);
-    EXPECT_EQ(y[0].size(), 1U);
-    EXPECT_EQ(y[0][0], 24);
+    EXPECT_EQ(1U, x.size());
+    EXPECT_EQ(42, x[0]);
+    EXPECT_EQ(1U, y.size());
+    EXPECT_EQ(1U, y[0].size());
+    EXPECT_EQ(24, y[0][0]);
     
     a.append(y);
 
-    EXPECT_EQ(x.size(), 1U);
-    EXPECT_EQ(x[0], 42);
-    EXPECT_EQ(y.size(), 1U);
-    EXPECT_EQ(y[0].size(), 1U);
-    EXPECT_EQ(y[0][0], 24);
-    EXPECT_EQ(a.size(), 1U);
-    EXPECT_EQ(a[0].size(), 1U);
-    EXPECT_EQ(a[0][0].size(), 1U);
-    EXPECT_EQ(a[0][0][0], 24);
-    EXPECT_EQ(c.size(), 1U);
-    EXPECT_EQ(c[0].size(), 1U);
-    EXPECT_EQ(c[0][0].size(), 1U);
-    EXPECT_EQ(c[0][0][0], 42);
-    EXPECT_EQ(b.size(), 0U);
+    EXPECT_EQ(1U, x.size());
+    EXPECT_EQ(42, x[0]);
+    EXPECT_EQ(1U, y.size());
+    EXPECT_EQ(1U, y[0].size());
+    EXPECT_EQ(24, y[0][0]);
+    EXPECT_EQ(1U, a.size());
+    EXPECT_EQ(1U, a[0].size());
+    EXPECT_EQ(1U, a[0][0].size());
+    EXPECT_EQ(24, a[0][0][0]);
+    EXPECT_EQ(1U, c.size());
+    EXPECT_EQ(1U, c[0].size());
+    EXPECT_EQ(1U, c[0][0].size());
+    EXPECT_EQ(42, c[0][0][0]);
+    EXPECT_EQ(0U, b.size());
 }
 
 } // namespace TestWebKitAPI

_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to