[webkit-changes] [243965] trunk

Sat, 06 Apr 2019 20:56:52 -0700

Title: [243965] trunk
Revision
243965
Author
[email protected]
Date
2019-04-06 20:55:59 -0700 (Sat, 06 Apr 2019)

Log Message

Added tests for WeakHashSet::computesEmpty and WeakHashSet::computeSize
https://bugs.webkit.org/show_bug.cgi?id=196669

Reviewed by Geoffrey Garen.

Source/WTF:

Removed the superflous type names from forward declarations, and made WeakHashSet::add
take a const object to match other container types in WTF.

* wtf/WeakHashSet.h:
(WTF::WeakHashSet::add):
* wtf/WeakPtr.h:

Tools:

Added three new unit tests for WeakHashSet.

* TestWebKitAPI/Tests/WTF/WeakPtr.cpp:
(WTF_WeakPtr.WeakHashSetConstObjects):
(WTF_WeakPtr.WeakHashSetComputesEmpty):
(WTF_WeakPtr.WeakHashSetComputeSize):

Modified Paths

Diff

Modified: trunk/Source/WTF/ChangeLog (243964 => 243965)


--- trunk/Source/WTF/ChangeLog	2019-04-07 02:54:58 UTC (rev 243964)
+++ trunk/Source/WTF/ChangeLog	2019-04-07 03:55:59 UTC (rev 243965)
@@ -1,3 +1,17 @@
+2019-04-06  Ryosuke Niwa  <[email protected]>
+
+        Added tests for WeakHashSet::computesEmpty and WeakHashSet::computeSize
+        https://bugs.webkit.org/show_bug.cgi?id=196669
+
+        Reviewed by Geoffrey Garen.
+
+        Removed the superflous type names from forward declarations, and made WeakHashSet::add
+        take a const object to match other container types in WTF.
+
+        * wtf/WeakHashSet.h:
+        (WTF::WeakHashSet::add):
+        * wtf/WeakPtr.h:
+
 2019-04-05  Ryosuke Niwa  <[email protected]>
 
         Make WeakPtr<Element> possible and deploy it in form associated elements code

Modified: trunk/Source/WTF/wtf/WeakHashSet.h (243964 => 243965)


--- trunk/Source/WTF/wtf/WeakHashSet.h	2019-04-07 02:54:58 UTC (rev 243964)
+++ trunk/Source/WTF/wtf/WeakHashSet.h	2019-04-07 03:55:59 UTC (rev 243965)
@@ -74,7 +74,7 @@
         }
 
     private:
-        template <typename U> friend class WeakHashSet;
+        template <typename> friend class WeakHashSet;
 
         typename WeakReferenceSet::const_iterator m_position;
         typename WeakReferenceSet::const_iterator m_endPosition;
@@ -86,9 +86,10 @@
     const_iterator begin() const { return WeakHashSetConstIterator(m_set, m_set.begin()); }
     const_iterator end() const { return WeakHashSetConstIterator(m_set, m_set.end()); }
 
-    void add(T& value)
+    template <typename U>
+    void add(const U& value)
     {
-        m_set.add(*makeWeakPtr(value).m_ref);
+        m_set.add(*makeWeakPtr<T>(const_cast<U&>(value)).m_ref);
     }
 
     template <typename U>

Modified: trunk/Source/WTF/wtf/WeakPtr.h (243964 => 243965)


--- trunk/Source/WTF/wtf/WeakPtr.h	2019-04-07 02:54:58 UTC (rev 243964)
+++ trunk/Source/WTF/wtf/WeakPtr.h	2019-04-07 03:55:59 UTC (rev 243965)
@@ -33,9 +33,9 @@
 
 namespace WTF {
 
-template<typename U> class WeakHashSet;
-template<typename T> class WeakPtr;
-template<typename T> class WeakPtrFactory;
+template<typename> class WeakHashSet;
+template<typename> class WeakPtr;
+template<typename> class WeakPtrFactory;
 
 // Note: WeakReference is an implementation detail, and should not be used directly.
 template<typename T>
@@ -86,8 +86,8 @@
     void clear() { m_ref = nullptr; }
 
 private:
-    template<typename U> friend class WeakHashSet;
-    template<typename U> friend class WeakPtr;
+    template<typename> friend class WeakHashSet;
+    template<typename> friend class WeakPtr;
     template<typename U> friend WeakPtr<U> makeWeakPtr(U&);
 
     RefPtr<WeakReference<T>> m_ref;
@@ -131,7 +131,7 @@
     }
 
 private:
-    template<typename U> friend class WeakHashSet;
+    template<typename> friend class WeakHashSet;
 
     mutable RefPtr<WeakReference<T>> m_ref;
 };

Modified: trunk/Tools/ChangeLog (243964 => 243965)


--- trunk/Tools/ChangeLog	2019-04-07 02:54:58 UTC (rev 243964)
+++ trunk/Tools/ChangeLog	2019-04-07 03:55:59 UTC (rev 243965)
@@ -1,3 +1,17 @@
+2019-04-06  Ryosuke Niwa  <[email protected]>
+
+        Added tests for WeakHashSet::computesEmpty and WeakHashSet::computeSize
+        https://bugs.webkit.org/show_bug.cgi?id=196669
+
+        Reviewed by Geoffrey Garen.
+
+        Added three new unit tests for WeakHashSet.
+
+        * TestWebKitAPI/Tests/WTF/WeakPtr.cpp:
+        (WTF_WeakPtr.WeakHashSetConstObjects):
+        (WTF_WeakPtr.WeakHashSetComputesEmpty):
+        (WTF_WeakPtr.WeakHashSetComputeSize):
+
 2019-04-06  Wenson Hsieh  <[email protected]>
 
         Hide next and previous form control buttons when WKWebView is editable

Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp (243964 => 243965)


--- trunk/Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp	2019-04-07 02:54:58 UTC (rev 243964)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp	2019-04-07 03:55:59 UTC (rev 243965)
@@ -492,6 +492,72 @@
     EXPECT_EQ(s_baseWeakReferences, 0u);
 }
 
+TEST(WTF_WeakPtr, WeakHashSetConstObjects)
+{
+    {
+        WeakHashSet<Base> weakHashSet;
+        const Base object;
+        EXPECT_FALSE(weakHashSet.contains(object));
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
+        weakHashSet.add(object);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
+        EXPECT_TRUE(weakHashSet.contains(object));
+        weakHashSet.checkConsistency();
+        weakHashSet.add(object);
+        EXPECT_TRUE(weakHashSet.contains(object));
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
+        weakHashSet.checkConsistency();
+        weakHashSet.remove(object);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
+    }
+
+    {
+        WeakHashSet<Base> weakHashSet;
+        const Derived object;
+        EXPECT_FALSE(weakHashSet.contains(object));
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
+        weakHashSet.add(object);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
+        EXPECT_TRUE(weakHashSet.contains(object));
+        weakHashSet.checkConsistency();
+        weakHashSet.add(object);
+        EXPECT_TRUE(weakHashSet.contains(object));
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
+        weakHashSet.checkConsistency();
+        weakHashSet.remove(object);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
+    }
+
+    {
+        WeakHashSet<Derived> weakHashSet;
+        const Derived object;
+        EXPECT_FALSE(weakHashSet.contains(object));
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
+        weakHashSet.add(object);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
+        EXPECT_TRUE(weakHashSet.contains(object));
+        weakHashSet.checkConsistency();
+        weakHashSet.add(object);
+        EXPECT_TRUE(weakHashSet.contains(object));
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
+        weakHashSet.checkConsistency();
+        weakHashSet.remove(object);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
+    }
+}
+
 TEST(WTF_WeakPtr, WeakHashSetExpansion)
 {
     unsigned initialCapacity;
@@ -569,4 +635,154 @@
     }
 }
 
+TEST(WTF_WeakPtr, WeakHashSetComputesEmpty)
+{
+    {
+        WeakHashSet<Base> weakHashSet;
+        {
+            Base object;
+            EXPECT_EQ(s_baseWeakReferences, 0u);
+            weakHashSet.add(object);
+            EXPECT_FALSE(weakHashSet.computesEmpty());
+        }
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_TRUE(weakHashSet.computesEmpty());
+    }
+
+    {
+        WeakHashSet<Base> weakHashSet;
+        Base object1;
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+        weakHashSet.add(object1);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        {
+            Base object2;
+            weakHashSet.add(object2);
+            EXPECT_FALSE(weakHashSet.computesEmpty());
+        }
+        EXPECT_EQ(s_baseWeakReferences, 2u);
+        EXPECT_FALSE(weakHashSet.computesEmpty());
+        weakHashSet.remove(object1);
+        EXPECT_TRUE(weakHashSet.computesEmpty());
+    }
+
+    {
+        WeakHashSet<Base> weakHashSet;
+        Vector<std::unique_ptr<Base>> objects;
+        auto firstObject = std::make_unique<Base>();
+        weakHashSet.add(*firstObject);
+        do {
+            auto object = std::make_unique<Base>();
+            weakHashSet.add(*object);
+            objects.append(WTFMove(object));
+        } while (weakHashSet.begin().get() == firstObject.get());
+
+        EXPECT_EQ(s_baseWeakReferences, objects.size() + 1);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), objects.size() + 1);
+        EXPECT_FALSE(weakHashSet.computesEmpty());
+        firstObject = nullptr;
+        EXPECT_FALSE(weakHashSet.computesEmpty());
+        EXPECT_EQ(s_baseWeakReferences, objects.size() + 1);
+        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), objects.size());
+    }
+}
+
+TEST(WTF_WeakPtr, WeakHashSetComputeSize)
+{
+    {
+        WeakHashSet<Base> weakHashSet;
+        {
+            Base object;
+            EXPECT_EQ(s_baseWeakReferences, 0u);
+            weakHashSet.add(object);
+            EXPECT_EQ(s_baseWeakReferences, 1u);
+            EXPECT_EQ(weakHashSet.computeSize(), 1u);
+            weakHashSet.checkConsistency();
+        }
+        EXPECT_TRUE(weakHashSet.computesEmpty());
+        EXPECT_EQ(weakHashSet.computeSize(), 0u);
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+        EXPECT_TRUE(weakHashSet.computesEmpty());
+        weakHashSet.checkConsistency();
+    }
+
+    {
+        WeakHashSet<Base> weakHashSet;
+        {
+            Base object1;
+            EXPECT_EQ(s_baseWeakReferences, 0u);
+            weakHashSet.add(object1);
+            EXPECT_EQ(s_baseWeakReferences, 1u);
+            {
+                Base object2;
+                weakHashSet.add(object2);
+                EXPECT_EQ(s_baseWeakReferences, 2u);
+                EXPECT_EQ(weakHashSet.computeSize(), 2u);
+                weakHashSet.checkConsistency();
+            }
+            EXPECT_EQ(s_baseWeakReferences, 2u);
+            EXPECT_EQ(weakHashSet.computeSize(), 1u);
+            EXPECT_EQ(s_baseWeakReferences, 1u);
+            weakHashSet.checkConsistency();
+            weakHashSet.remove(object1);
+            EXPECT_EQ(s_baseWeakReferences, 1u);
+            EXPECT_EQ(weakHashSet.computeSize(), 0u);
+            EXPECT_EQ(s_baseWeakReferences, 1u);
+            weakHashSet.checkConsistency();
+        }
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+        weakHashSet.checkConsistency();
+    }
+
+    while (1) {
+        WeakHashSet<Base> weakHashSet;
+        auto firstObject = std::make_unique<Base>();
+        auto lastObject = std::make_unique<Base>();
+        weakHashSet.add(*firstObject);
+        weakHashSet.add(*lastObject);
+        if (weakHashSet.begin().get() != firstObject.get())
+            continue;
+        EXPECT_EQ(s_baseWeakReferences, 2u);
+        EXPECT_EQ(weakHashSet.computeSize(), 2u);
+        EXPECT_EQ(s_baseWeakReferences, 2u);
+        weakHashSet.checkConsistency();
+        firstObject = nullptr;
+        EXPECT_EQ(weakHashSet.computeSize(), 1u);
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        weakHashSet.checkConsistency();
+        lastObject = nullptr;
+        EXPECT_EQ(s_baseWeakReferences, 1u);
+        EXPECT_EQ(weakHashSet.computeSize(), 0u);
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+        weakHashSet.checkConsistency();
+        break;
+    }
+
+    {
+        WeakHashSet<Base> weakHashSet;
+        Vector<std::unique_ptr<Base>> objects;
+        auto nonFirstObject = std::make_unique<Base>();
+        weakHashSet.add(*nonFirstObject);
+        do {
+            auto object = std::make_unique<Base>();
+            weakHashSet.add(*object);
+            objects.append(WTFMove(object));
+        } while (weakHashSet.begin().get() == nonFirstObject.get());
+
+        unsigned objectsCount = objects.size();
+        EXPECT_EQ(s_baseWeakReferences, objectsCount + 1);
+        EXPECT_EQ(weakHashSet.computeSize(), objectsCount + 1);
+        EXPECT_EQ(s_baseWeakReferences, objectsCount + 1);
+        weakHashSet.checkConsistency();
+        nonFirstObject = nullptr;
+        EXPECT_EQ(weakHashSet.computeSize(), objectsCount);
+        EXPECT_EQ(s_baseWeakReferences, objectsCount);
+        weakHashSet.checkConsistency();
+        objects.clear();
+        EXPECT_EQ(s_baseWeakReferences, objectsCount);
+        EXPECT_EQ(weakHashSet.computeSize(), 0u);
+        EXPECT_EQ(s_baseWeakReferences, 0u);
+    }
+}
+
 } // namespace TestWebKitAPI

_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to