| // Copyright 2019 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "util/weak_ptr.h" |
| |
| #include "gtest/gtest.h" |
| |
| namespace openscreen { |
| namespace { |
| |
| class SomeClass { |
| public: |
| virtual ~SomeClass() = default; |
| virtual int GetValue() const { return 42; } |
| }; |
| |
| struct SomeSubclass final : public SomeClass { |
| public: |
| ~SomeSubclass() final = default; |
| int GetValue() const override { return 999; } |
| }; |
| |
| TEST(WeakPtrTest, InteractsWithNullptr) { |
| WeakPtr<const int> default_constructed; // Invoke default constructor. |
| EXPECT_TRUE(default_constructed == nullptr); |
| EXPECT_TRUE(nullptr == default_constructed); |
| EXPECT_FALSE(default_constructed != nullptr); |
| EXPECT_FALSE(nullptr != default_constructed); |
| |
| WeakPtr<const int> null_constructed = nullptr; // Invoke construct-from-null. |
| EXPECT_TRUE(null_constructed == nullptr); |
| EXPECT_TRUE(nullptr == null_constructed); |
| EXPECT_FALSE(null_constructed != nullptr); |
| EXPECT_FALSE(nullptr != null_constructed); |
| |
| const int foo = 42; |
| WeakPtrFactory<const int> factory(&foo); |
| WeakPtr<const int> not_null = factory.GetWeakPtr(); |
| EXPECT_TRUE(not_null != nullptr); |
| EXPECT_TRUE(nullptr != not_null); |
| EXPECT_FALSE(not_null == nullptr); |
| EXPECT_FALSE(nullptr == not_null); |
| } |
| |
| TEST(WeakPtrTest, CopyConstructsAndAssigns) { |
| SomeSubclass foo; |
| WeakPtrFactory<SomeSubclass> factory(&foo); |
| |
| WeakPtr<SomeSubclass> weak_ptr = factory.GetWeakPtr(); |
| EXPECT_TRUE(weak_ptr); |
| EXPECT_EQ(&foo, weak_ptr.get()); |
| |
| // Normal copy constructor. |
| WeakPtr<SomeSubclass> copied0 = weak_ptr; |
| EXPECT_EQ(&foo, weak_ptr.get()); // Did not mutate original. |
| EXPECT_TRUE(copied0); |
| EXPECT_EQ(&foo, copied0.get()); |
| |
| // Copy constructor, adding const qualifier. |
| WeakPtr<const SomeSubclass> copied1 = weak_ptr; |
| EXPECT_EQ(&foo, weak_ptr.get()); // Did not mutate original. |
| EXPECT_TRUE(copied1); |
| EXPECT_EQ(&foo, copied1.get()); |
| |
| // Normal copy assignment. |
| WeakPtr<SomeSubclass> assigned0; |
| EXPECT_FALSE(assigned0); |
| assigned0 = copied0; |
| EXPECT_EQ(&foo, copied0.get()); // Did not mutate original. |
| EXPECT_TRUE(assigned0); |
| EXPECT_EQ(&foo, assigned0.get()); |
| |
| // Copy assignment, adding const qualifier. |
| WeakPtr<const SomeSubclass> assigned1; |
| EXPECT_FALSE(assigned1); |
| assigned1 = copied0; |
| EXPECT_EQ(&foo, copied0.get()); // Did not mutate original. |
| EXPECT_TRUE(assigned1); |
| EXPECT_EQ(&foo, assigned1.get()); |
| |
| // Upcast copy constructor. |
| WeakPtr<SomeClass> copied2 = weak_ptr; |
| EXPECT_EQ(&foo, weak_ptr.get()); // Did not mutate original. |
| EXPECT_TRUE(copied2); |
| EXPECT_EQ(&foo, copied2.get()); |
| EXPECT_EQ(999, (*copied2).GetValue()); |
| EXPECT_EQ(999, copied2->GetValue()); |
| |
| // Upcast copy assignment. |
| WeakPtr<SomeClass> assigned2; |
| EXPECT_FALSE(assigned2); |
| assigned2 = weak_ptr; |
| EXPECT_EQ(&foo, weak_ptr.get()); // Did not mutate original. |
| EXPECT_TRUE(assigned2); |
| EXPECT_EQ(&foo, assigned2.get()); |
| EXPECT_EQ(999, (*assigned2).GetValue()); |
| EXPECT_EQ(999, assigned2->GetValue()); |
| } |
| |
| TEST(WeakPtrTest, MoveConstructsAndAssigns) { |
| SomeSubclass foo; |
| WeakPtrFactory<SomeSubclass> factory(&foo); |
| |
| // Normal move constructor. |
| WeakPtr<SomeSubclass> weak_ptr = factory.GetWeakPtr(); |
| WeakPtr<SomeSubclass> moved0 = std::move(weak_ptr); |
| EXPECT_FALSE(weak_ptr); // Original becomes null. |
| EXPECT_TRUE(moved0); |
| EXPECT_EQ(&foo, moved0.get()); |
| |
| // Move constructor, adding const qualifier. |
| weak_ptr = factory.GetWeakPtr(); |
| WeakPtr<const SomeSubclass> moved1 = std::move(weak_ptr); |
| EXPECT_FALSE(weak_ptr); // Original becomes null. |
| EXPECT_TRUE(moved1); |
| EXPECT_EQ(&foo, moved1.get()); |
| |
| // Normal move assignment. |
| weak_ptr = factory.GetWeakPtr(); |
| WeakPtr<SomeSubclass> assigned0; |
| EXPECT_FALSE(assigned0); |
| assigned0 = std::move(weak_ptr); |
| EXPECT_FALSE(weak_ptr); // Original becomes null. |
| EXPECT_TRUE(assigned0); |
| EXPECT_EQ(&foo, assigned0.get()); |
| |
| // Move assignment, adding const qualifier. |
| weak_ptr = factory.GetWeakPtr(); |
| WeakPtr<const SomeSubclass> assigned1; |
| EXPECT_FALSE(assigned1); |
| assigned1 = std::move(weak_ptr); |
| EXPECT_FALSE(weak_ptr); // Original becomes null. |
| EXPECT_TRUE(assigned1); |
| EXPECT_EQ(&foo, assigned1.get()); |
| |
| // Upcast move constructor. |
| weak_ptr = factory.GetWeakPtr(); |
| WeakPtr<SomeClass> moved2 = std::move(weak_ptr); |
| EXPECT_FALSE(weak_ptr); // Original becomes null. |
| EXPECT_TRUE(moved2); |
| EXPECT_EQ(&foo, moved2.get()); |
| EXPECT_EQ(999, (*moved2).GetValue()); // Result from subclass's GetValue(). |
| EXPECT_EQ(999, moved2->GetValue()); // Result from subclass's GetValue(). |
| |
| // Upcast move assignment. |
| weak_ptr = factory.GetWeakPtr(); |
| WeakPtr<SomeClass> assigned2; |
| EXPECT_FALSE(assigned2); |
| assigned2 = std::move(weak_ptr); |
| EXPECT_FALSE(weak_ptr); // Original becomes null. |
| EXPECT_TRUE(assigned2); |
| EXPECT_EQ(&foo, assigned2.get()); |
| EXPECT_EQ(999, |
| (*assigned2).GetValue()); // Result from subclass's GetValue(). |
| EXPECT_EQ(999, assigned2->GetValue()); // Result from subclass's GetValue(). |
| } |
| |
| TEST(WeakPtrTest, InvalidatesWeakPtrs) { |
| const int foo = 1337; |
| WeakPtrFactory<const int> factory(&foo); |
| |
| // Thrice: Create weak pointers and invalidate them. This is done more than |
| // once to confirm the factory can create valid WeakPtrs again after each |
| // InvalidateWeakPtrs() call. |
| for (int i = 0; i < 3; ++i) { |
| // Create three WeakPtrs, two from the factory, one as a copy of another |
| // WeakPtr. |
| WeakPtr<const int> ptr0 = factory.GetWeakPtr(); |
| WeakPtr<const int> ptr1 = factory.GetWeakPtr(); |
| WeakPtr<const int> ptr2 = ptr1; |
| EXPECT_EQ(&foo, ptr0.get()); |
| EXPECT_EQ(&foo, ptr1.get()); |
| EXPECT_EQ(&foo, ptr2.get()); |
| |
| // Invalidate all outstanding WeakPtrs from the factory, and confirm all |
| // outstanding WeakPtrs become null. |
| factory.InvalidateWeakPtrs(); |
| EXPECT_FALSE(ptr0); |
| EXPECT_FALSE(ptr1); |
| EXPECT_FALSE(ptr2); |
| } |
| } |
| |
| } // namespace |
| } // namespace openscreen |