Enable WTF::HashSet<OwnPtr<> >

Source/wtf/HashSetTest.cpp

Index: Source/wtf/HashSetTest.cpp
diff --git a/Source/wtf/HashSetTest.cpp b/Source/wtf/HashSetTest.cpp
index 3b200f6994c8254128e7d0caaceb5f7386e41172..2d8ad90ab2596b34424fb0497df102626f5906cc 100644
--- a/Source/wtf/HashSetTest.cpp
+++ b/Source/wtf/HashSetTest.cpp
@@ -26,6 +26,9 @@
 #include "config.h"
 
 #include "wtf/HashSet.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
+#include "wtf/RefCounted.h"
 #include <gtest/gtest.h>
 
 namespace {
@@ -77,4 +80,102 @@ TEST(HashSetTest, InitialCapacity)
     generateTestCapacityUpToSize<128>();
 }
 
+struct Dummy {
+    Dummy(bool& deleted) : deleted(deleted) { }
+
+    ~Dummy()
+    {
+        deleted = true;
+    }
+
+    bool& deleted;
+};
+
+TEST(HashSetTest, HashSetOwnPtr)
+{
+    bool deleted1 = false, deleted2 = false;
+
+    typedef HashSet<OwnPtr<Dummy> > OwnPtrSet;
+    HashSet<OwnPtr<Dummy> > set;
+
+    Dummy* ptr1 = new Dummy(deleted1);
+    {
+        // AddResult in a separate scope to avoid assertion hit,
+        // since we modify the container further.
+        HashSet<OwnPtr<Dummy> >::AddResult res1 = set.add(adoptPtr(ptr1));
+        EXPECT_EQ(ptr1, res1.storedValue->get());
+    }
+
+    EXPECT_FALSE(deleted1);
+    EXPECT_EQ(1UL, set.size());
+    OwnPtrSet::iterator it1 = set.find(ptr1);
+    EXPECT_NE(set.end(), it1);
+    EXPECT_EQ(ptr1, (*it1));
+
+    Dummy* ptr2 = new Dummy(deleted2);
+    {
+        HashSet<OwnPtr<Dummy> >::AddResult res2 = set.add(adoptPtr(ptr2));
+        EXPECT_EQ(res2.storedValue->get(), ptr2);
+    }
+
+    EXPECT_FALSE(deleted2);
+    EXPECT_EQ(2UL, set.size());
+    OwnPtrSet::iterator it2 = set.find(ptr2);
+    EXPECT_NE(set.end(), it2);
+    EXPECT_EQ(ptr2, (*it2));
+
+    set.remove(ptr1);
+    EXPECT_TRUE(deleted1);
+
+    set.clear();

[Erik Corry, 2014/04/28 07:53:03]

It would be great if you could make the test also test that calling the
destructor of a non-empty set calls the destructor of the ownptr.

[Mikhail, 2014/04/28 08:00:40]

Will add.

+    EXPECT_TRUE(deleted2);
+    EXPECT_TRUE(set.isEmpty());
+}
+
+class DummyRefCounted: public WTF::RefCounted<DummyRefCounted> {
+public:
+    DummyRefCounted(bool& isDeleted) : m_isDeleted(isDeleted) { m_isDeleted = false; }
+    ~DummyRefCounted() { m_isDeleted = true; }
+
+    void ref()
+    {
+        WTF::RefCounted<DummyRefCounted>::ref();
+        ++m_refInvokesCount;
+    }
+
+    static int m_refInvokesCount;

[Erik Corry, 2014/04/28 07:53:03]

Should be called s_refInvokesCount.

+
+private:
+    bool& m_isDeleted;
+};
+
+int DummyRefCounted::m_refInvokesCount = 0;
+
+TEST(HashSetTest, HashSetRefPtr)
+{
+    bool isDeleted;
+    RefPtr<DummyRefCounted> ptr = adoptRef(new DummyRefCounted(isDeleted));
+    EXPECT_EQ(0, DummyRefCounted::m_refInvokesCount);
+    HashSet<RefPtr<DummyRefCounted> > set;
+    set.add(ptr);
+    // Referenced only once (to store a copy in the container).
+    EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
+
+    DummyRefCounted* rawPtr = ptr.get();
+
+    EXPECT_TRUE(set.contains(rawPtr));
+    EXPECT_NE(set.end(), set.find(rawPtr));
+    EXPECT_TRUE(set.contains(ptr));
+    EXPECT_NE(set.end(), set.find(ptr));
+
+    ptr.clear();
+    EXPECT_FALSE(isDeleted);
+
+    set.remove(rawPtr);
+    EXPECT_TRUE(isDeleted);
+    EXPECT_TRUE(set.isEmpty());
+    EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
+}
+
+
 } // namespace