tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TestUniqueOrNonOwningPtr.cpp (2008B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 #include "UniqueOrNonOwningPtr.h"
      6 #include "gtest/gtest.h"
      7 
      8 using mozilla::MakeUniqueOfUniqueOrNonOwning;
      9 using mozilla::UniqueOrNonOwningPtr;
     10 
     11 TEST(UniqueOrNonOwningPtrTest, Empty)
     12 {
     13 #ifdef HAVE_64BIT_BUILD
     14  using T = uint64_t;
     15 #else
     16  using T = uint32_t;
     17 #endif
     18  using Ptr = UniqueOrNonOwningPtr<T>;
     19 
     20  static_assert(sizeof(Ptr) == sizeof(T), "Unexpected size bloat");
     21 
     22  Ptr ptr;
     23  EXPECT_FALSE(ptr);
     24  EXPECT_EQ(ptr.get(), nullptr);
     25 }
     26 
     27 struct Foo {
     28  uint64_t mA;
     29  uint32_t mB;
     30 
     31  Foo(uint64_t aA, uint32_t aB) : mA{aA}, mB{aB} {}
     32  Foo(const Foo& aOther) = default;
     33 
     34  bool operator==(const Foo& aOther) const {
     35    return mA == aOther.mA && mB == aOther.mB;
     36  }
     37 };
     38 
     39 TEST(UniqueOrNonOwningPtrTest, NonOwningStruct)
     40 {
     41  using T = Foo;
     42  using Ptr = UniqueOrNonOwningPtr<T>;
     43 
     44  T val{12, 918};
     45  Ptr ptr = Ptr::NonOwning(&val);
     46  EXPECT_TRUE(ptr);
     47  EXPECT_EQ(ptr.get(), &val);
     48  EXPECT_EQ(*ptr, val);
     49  EXPECT_EQ(ptr->mA, val.mA);
     50  EXPECT_EQ(ptr->mB, val.mB);
     51 
     52  Ptr ptr2 = std::move(ptr);
     53  EXPECT_FALSE(ptr);
     54  EXPECT_EQ(ptr.get(), nullptr);
     55  EXPECT_TRUE(ptr2);
     56  EXPECT_EQ(ptr2.get(), &val);
     57  EXPECT_EQ(*ptr2, val);
     58  EXPECT_EQ(ptr2->mA, val.mA);
     59  EXPECT_EQ(ptr2->mB, val.mB);
     60 }
     61 
     62 TEST(UniqueOrNonOwningPtrTest, OwnedStruct)
     63 {
     64  using T = Foo;
     65  using Ptr = UniqueOrNonOwningPtr<T>;
     66 
     67  T copy{12, 918};
     68  Ptr ptr = MakeUniqueOfUniqueOrNonOwning<T>(copy);
     69  EXPECT_TRUE(ptr);
     70  EXPECT_NE(ptr.get(), nullptr);
     71  EXPECT_NE(ptr.get(), &copy);
     72  EXPECT_EQ(*ptr, copy);
     73  EXPECT_EQ(ptr->mA, copy.mA);
     74  EXPECT_EQ(ptr->mB, copy.mB);
     75 
     76  Ptr ptr2 = std::move(ptr);
     77  EXPECT_FALSE(ptr);
     78  EXPECT_EQ(ptr.get(), nullptr);
     79  EXPECT_TRUE(ptr2);
     80  EXPECT_NE(ptr2.get(), nullptr);
     81  EXPECT_NE(ptr2.get(), &copy);
     82  EXPECT_EQ(*ptr2, copy);
     83  EXPECT_EQ(ptr2->mA, copy.mA);
     84  EXPECT_EQ(ptr2->mB, copy.mB);
     85 }