Changeset 243965 in webkit


Ignore:
Timestamp:
Apr 6, 2019 8:55:59 PM (5 years ago)
Author:
rniwa@webkit.org
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):

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r243954 r243965  
     12019-04-06  Ryosuke Niwa  <rniwa@webkit.org>
     2
     3        Added tests for WeakHashSet::computesEmpty and WeakHashSet::computeSize
     4        https://bugs.webkit.org/show_bug.cgi?id=196669
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        Removed the superflous type names from forward declarations, and made WeakHashSet::add
     9        take a const object to match other container types in WTF.
     10
     11        * wtf/WeakHashSet.h:
     12        (WTF::WeakHashSet::add):
     13        * wtf/WeakPtr.h:
     14
    1152019-04-05  Ryosuke Niwa  <rniwa@webkit.org>
    216

  • trunk/Source/WTF/wtf/WeakHashSet.h

    r243954 r243965  
    7575
    7676    private:
    77         template <typename U> friend class WeakHashSet;
     77        template <typename> friend class WeakHashSet;
    7878
    7979        typename WeakReferenceSet::const_iterator m_position;
    … …  
    8787    const_iterator end() const { return WeakHashSetConstIterator(m_set, m_set.end()); }
    8888
    89     void add(T& value)
     89    template <typename U>
     90    void add(const U& value)
    9091    {
    91         m_set.add(*makeWeakPtr(value).m_ref);
     92        m_set.add(*makeWeakPtr<T>(const_cast<U&>(value)).m_ref);
    9293    }
    9394

  • trunk/Source/WTF/wtf/WeakPtr.h

    r243954 r243965  
    3434namespace WTF {
    3535
    36 template<typename U> class WeakHashSet;
    37 template<typename T> class WeakPtr;
    38 template<typename T> class WeakPtrFactory;
     36template<typename> class WeakHashSet;
     37template<typename> class WeakPtr;
     38template<typename> class WeakPtrFactory;
    3939
    4040// Note: WeakReference is an implementation detail, and should not be used directly.
    … …  
    8787
    8888private:
    89     template<typename U> friend class WeakHashSet;
    90     template<typename U> friend class WeakPtr;
     89    template<typename> friend class WeakHashSet;
     90    template<typename> friend class WeakPtr;
    9191    template<typename U> friend WeakPtr<U> makeWeakPtr(U&);
    9292
    … …  
    132132
    133133private:
    134     template<typename U> friend class WeakHashSet;
     134    template<typename> friend class WeakHashSet;
    135135
    136136    mutable RefPtr<WeakReference<T>> m_ref;

  • trunk/Tools/ChangeLog

    r243963 r243965  
     12019-04-06  Ryosuke Niwa  <rniwa@webkit.org>
     2
     3        Added tests for WeakHashSet::computesEmpty and WeakHashSet::computeSize
     4        https://bugs.webkit.org/show_bug.cgi?id=196669
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        Added three new unit tests for WeakHashSet.
     9
     10        * TestWebKitAPI/Tests/WTF/WeakPtr.cpp:
     11        (WTF_WeakPtr.WeakHashSetConstObjects):
     12        (WTF_WeakPtr.WeakHashSetComputesEmpty):
     13        (WTF_WeakPtr.WeakHashSetComputeSize):
     14
    1152019-04-06  Wenson Hsieh  <wenson_hsieh@apple.com>
    216

  • trunk/Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp

    r242387 r243965  
    493493}
    494494
     495TEST(WTF_WeakPtr, WeakHashSetConstObjects)
     496{
     497    {
     498        WeakHashSet<Base> weakHashSet;
     499        const Base object;
     500        EXPECT_FALSE(weakHashSet.contains(object));
     501        EXPECT_EQ(s_baseWeakReferences, 0u);
     502        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
     503        weakHashSet.add(object);
     504        EXPECT_EQ(s_baseWeakReferences, 1u);
     505        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
     506        EXPECT_TRUE(weakHashSet.contains(object));
     507        weakHashSet.checkConsistency();
     508        weakHashSet.add(object);
     509        EXPECT_TRUE(weakHashSet.contains(object));
     510        EXPECT_EQ(s_baseWeakReferences, 1u);
     511        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
     512        weakHashSet.checkConsistency();
     513        weakHashSet.remove(object);
     514        EXPECT_EQ(s_baseWeakReferences, 1u);
     515        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
     516    }
     517
     518    {
     519        WeakHashSet<Base> weakHashSet;
     520        const Derived object;
     521        EXPECT_FALSE(weakHashSet.contains(object));
     522        EXPECT_EQ(s_baseWeakReferences, 0u);
     523        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
     524        weakHashSet.add(object);
     525        EXPECT_EQ(s_baseWeakReferences, 1u);
     526        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
     527        EXPECT_TRUE(weakHashSet.contains(object));
     528        weakHashSet.checkConsistency();
     529        weakHashSet.add(object);
     530        EXPECT_TRUE(weakHashSet.contains(object));
     531        EXPECT_EQ(s_baseWeakReferences, 1u);
     532        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
     533        weakHashSet.checkConsistency();
     534        weakHashSet.remove(object);
     535        EXPECT_EQ(s_baseWeakReferences, 1u);
     536        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
     537    }
     538
     539    {
     540        WeakHashSet<Derived> weakHashSet;
     541        const Derived object;
     542        EXPECT_FALSE(weakHashSet.contains(object));
     543        EXPECT_EQ(s_baseWeakReferences, 0u);
     544        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
     545        weakHashSet.add(object);
     546        EXPECT_EQ(s_baseWeakReferences, 1u);
     547        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
     548        EXPECT_TRUE(weakHashSet.contains(object));
     549        weakHashSet.checkConsistency();
     550        weakHashSet.add(object);
     551        EXPECT_TRUE(weakHashSet.contains(object));
     552        EXPECT_EQ(s_baseWeakReferences, 1u);
     553        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 1u);
     554        weakHashSet.checkConsistency();
     555        weakHashSet.remove(object);
     556        EXPECT_EQ(s_baseWeakReferences, 1u);
     557        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), 0u);
     558    }
     559}
     560
    495561TEST(WTF_WeakPtr, WeakHashSetExpansion)
    496562{
    … …  
    570636}
    571637
     638TEST(WTF_WeakPtr, WeakHashSetComputesEmpty)
     639{
     640    {
     641        WeakHashSet<Base> weakHashSet;
     642        {
     643            Base object;
     644            EXPECT_EQ(s_baseWeakReferences, 0u);
     645            weakHashSet.add(object);
     646            EXPECT_FALSE(weakHashSet.computesEmpty());
     647        }
     648        EXPECT_EQ(s_baseWeakReferences, 1u);
     649        EXPECT_TRUE(weakHashSet.computesEmpty());
     650    }
     651
     652    {
     653        WeakHashSet<Base> weakHashSet;
     654        Base object1;
     655        EXPECT_EQ(s_baseWeakReferences, 0u);
     656        weakHashSet.add(object1);
     657        EXPECT_EQ(s_baseWeakReferences, 1u);
     658        {
     659            Base object2;
     660            weakHashSet.add(object2);
     661            EXPECT_FALSE(weakHashSet.computesEmpty());
     662        }
     663        EXPECT_EQ(s_baseWeakReferences, 2u);
     664        EXPECT_FALSE(weakHashSet.computesEmpty());
     665        weakHashSet.remove(object1);
     666        EXPECT_TRUE(weakHashSet.computesEmpty());
     667    }
     668
     669    {
     670        WeakHashSet<Base> weakHashSet;
     671        Vector<std::unique_ptr<Base>> objects;
     672        auto firstObject = std::make_unique<Base>();
     673        weakHashSet.add(*firstObject);
     674        do {
     675            auto object = std::make_unique<Base>();
     676            weakHashSet.add(*object);
     677            objects.append(WTFMove(object));
     678        } while (weakHashSet.begin().get() == firstObject.get());
     679
     680        EXPECT_EQ(s_baseWeakReferences, objects.size() + 1);
     681        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), objects.size() + 1);
     682        EXPECT_FALSE(weakHashSet.computesEmpty());
     683        firstObject = nullptr;
     684        EXPECT_FALSE(weakHashSet.computesEmpty());
     685        EXPECT_EQ(s_baseWeakReferences, objects.size() + 1);
     686        EXPECT_EQ(computeSizeOfWeakHashSet(weakHashSet), objects.size());
     687    }
     688}
     689
     690TEST(WTF_WeakPtr, WeakHashSetComputeSize)
     691{
     692    {
     693        WeakHashSet<Base> weakHashSet;
     694        {
     695            Base object;
     696            EXPECT_EQ(s_baseWeakReferences, 0u);
     697            weakHashSet.add(object);
     698            EXPECT_EQ(s_baseWeakReferences, 1u);
     699            EXPECT_EQ(weakHashSet.computeSize(), 1u);
     700            weakHashSet.checkConsistency();
     701        }
     702        EXPECT_TRUE(weakHashSet.computesEmpty());
     703        EXPECT_EQ(weakHashSet.computeSize(), 0u);
     704        EXPECT_EQ(s_baseWeakReferences, 0u);
     705        EXPECT_TRUE(weakHashSet.computesEmpty());
     706        weakHashSet.checkConsistency();
     707    }
     708
     709    {
     710        WeakHashSet<Base> weakHashSet;
     711        {
     712            Base object1;
     713            EXPECT_EQ(s_baseWeakReferences, 0u);
     714            weakHashSet.add(object1);
     715            EXPECT_EQ(s_baseWeakReferences, 1u);
     716            {
     717                Base object2;
     718                weakHashSet.add(object2);
     719                EXPECT_EQ(s_baseWeakReferences, 2u);
     720                EXPECT_EQ(weakHashSet.computeSize(), 2u);
     721                weakHashSet.checkConsistency();
     722            }
     723            EXPECT_EQ(s_baseWeakReferences, 2u);
     724            EXPECT_EQ(weakHashSet.computeSize(), 1u);
     725            EXPECT_EQ(s_baseWeakReferences, 1u);
     726            weakHashSet.checkConsistency();
     727            weakHashSet.remove(object1);
     728            EXPECT_EQ(s_baseWeakReferences, 1u);
     729            EXPECT_EQ(weakHashSet.computeSize(), 0u);
     730            EXPECT_EQ(s_baseWeakReferences, 1u);
     731            weakHashSet.checkConsistency();
     732        }
     733        EXPECT_EQ(s_baseWeakReferences, 0u);
     734        weakHashSet.checkConsistency();
     735    }
     736
     737    while (1) {
     738        WeakHashSet<Base> weakHashSet;
     739        auto firstObject = std::make_unique<Base>();
     740        auto lastObject = std::make_unique<Base>();
     741        weakHashSet.add(*firstObject);
     742        weakHashSet.add(*lastObject);
     743        if (weakHashSet.begin().get() != firstObject.get())
     744            continue;
     745        EXPECT_EQ(s_baseWeakReferences, 2u);
     746        EXPECT_EQ(weakHashSet.computeSize(), 2u);
     747        EXPECT_EQ(s_baseWeakReferences, 2u);
     748        weakHashSet.checkConsistency();
     749        firstObject = nullptr;
     750        EXPECT_EQ(weakHashSet.computeSize(), 1u);
     751        EXPECT_EQ(s_baseWeakReferences, 1u);
     752        weakHashSet.checkConsistency();
     753        lastObject = nullptr;
     754        EXPECT_EQ(s_baseWeakReferences, 1u);
     755        EXPECT_EQ(weakHashSet.computeSize(), 0u);
     756        EXPECT_EQ(s_baseWeakReferences, 0u);
     757        weakHashSet.checkConsistency();
     758        break;
     759    }
     760
     761    {
     762        WeakHashSet<Base> weakHashSet;
     763        Vector<std::unique_ptr<Base>> objects;
     764        auto nonFirstObject = std::make_unique<Base>();
     765        weakHashSet.add(*nonFirstObject);
     766        do {
     767            auto object = std::make_unique<Base>();
     768            weakHashSet.add(*object);
     769            objects.append(WTFMove(object));
     770        } while (weakHashSet.begin().get() == nonFirstObject.get());
     771
     772        unsigned objectsCount = objects.size();
     773        EXPECT_EQ(s_baseWeakReferences, objectsCount + 1);
     774        EXPECT_EQ(weakHashSet.computeSize(), objectsCount + 1);
     775        EXPECT_EQ(s_baseWeakReferences, objectsCount + 1);
     776        weakHashSet.checkConsistency();
     777        nonFirstObject = nullptr;
     778        EXPECT_EQ(weakHashSet.computeSize(), objectsCount);
     779        EXPECT_EQ(s_baseWeakReferences, objectsCount);
     780        weakHashSet.checkConsistency();
     781        objects.clear();
     782        EXPECT_EQ(s_baseWeakReferences, objectsCount);
     783        EXPECT_EQ(weakHashSet.computeSize(), 0u);
     784        EXPECT_EQ(s_baseWeakReferences, 0u);
     785    }
     786}
     787
    572788} // namespace TestWebKitAPI
Note: See TracChangeset for help on using the changeset viewer.