unittests/ADT/OwningPtrTest.cpp

   1 //===- llvm/unittest/ADT/OwningPtrTest.cpp - OwningPtr unit tests ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/OwningPtr.h"
  11 #include "gtest/gtest.h"
  12 using namespace llvm;
  13
  14 namespace {
  15
  16 struct TrackDestructor {
  17   static unsigned Destructions;
  18   int val;
  19   explicit TrackDestructor(int val) : val(val) {}
  20   ~TrackDestructor() { ++Destructions; }
  21   static void ResetCounts() { Destructions = 0; }
  22
  23 private:
  24   TrackDestructor(const TrackDestructor &other) LLVM_DELETED_FUNCTION;
  25   TrackDestructor &
  26   operator=(const TrackDestructor &other) LLVM_DELETED_FUNCTION;
  27   TrackDestructor(TrackDestructor &&other) LLVM_DELETED_FUNCTION;
  28   TrackDestructor &operator=(TrackDestructor &&other) LLVM_DELETED_FUNCTION;
  29 };
  30
  31 unsigned TrackDestructor::Destructions = 0;
  32
  33 // Test fixture
  34 class OwningPtrTest : public testing::Test {};
  35
  36 TEST_F(OwningPtrTest, DefaultConstruction) {
  37   TrackDestructor::ResetCounts();
  38   {
  39     OwningPtr<TrackDestructor> O;
  40     EXPECT_FALSE(O);
  41     EXPECT_TRUE(!O);
  42     EXPECT_FALSE(O.get());
  43     EXPECT_FALSE(O.isValid());
  44   }
  45   EXPECT_EQ(0u, TrackDestructor::Destructions);
  46 }
  47
  48 TEST_F(OwningPtrTest, PtrConstruction) {
  49   TrackDestructor::ResetCounts();
  50   {
  51     OwningPtr<TrackDestructor> O(new TrackDestructor(3));
  52     EXPECT_TRUE((bool)O);
  53     EXPECT_FALSE(!O);
  54     EXPECT_TRUE(O.get());
  55     EXPECT_TRUE(O.isValid());
  56     EXPECT_EQ(3, (*O).val);
  57     EXPECT_EQ(3, O->val);
  58     EXPECT_EQ(0u, TrackDestructor::Destructions);
  59   }
  60   EXPECT_EQ(1u, TrackDestructor::Destructions);
  61 }
  62
  63 TEST_F(OwningPtrTest, Reset) {
  64   TrackDestructor::ResetCounts();
  65   OwningPtr<TrackDestructor> O(new TrackDestructor(3));
  66   EXPECT_EQ(0u, TrackDestructor::Destructions);
  67   O.reset();
  68   EXPECT_FALSE((bool)O);
  69   EXPECT_TRUE(!O);
  70   EXPECT_FALSE(O.get());
  71   EXPECT_FALSE(O.isValid());
  72   EXPECT_EQ(1u, TrackDestructor::Destructions);
  73 }
  74
  75 TEST_F(OwningPtrTest, Take) {
  76   TrackDestructor::ResetCounts();
  77   TrackDestructor *T = nullptr;
  78   {
  79     OwningPtr<TrackDestructor> O(new TrackDestructor(3));
  80     T = O.take();
  81     EXPECT_FALSE((bool)O);
  82     EXPECT_TRUE(!O);
  83     EXPECT_FALSE(O.get());
  84     EXPECT_FALSE(O.isValid());
  85     EXPECT_TRUE(T);
  86     EXPECT_EQ(3, T->val);
  87     EXPECT_EQ(0u, TrackDestructor::Destructions);
  88   }
  89   delete T;
  90   EXPECT_EQ(1u, TrackDestructor::Destructions);
  91 }
  92
  93 TEST_F(OwningPtrTest, Release) {
  94   TrackDestructor::ResetCounts();
  95   TrackDestructor *T = nullptr;
  96   {
  97     OwningPtr<TrackDestructor> O(new TrackDestructor(3));
  98     T = O.release();
  99     EXPECT_FALSE((bool)O);
 100     EXPECT_TRUE(!O);
 101     EXPECT_FALSE(O.get());
 102     EXPECT_FALSE(O.isValid());
 103     EXPECT_TRUE(T);
 104     EXPECT_EQ(3, T->val);
 105     EXPECT_EQ(0u, TrackDestructor::Destructions);
 106   }
 107   delete T;
 108   EXPECT_EQ(1u, TrackDestructor::Destructions);
 109 }
 110
 111 TEST_F(OwningPtrTest, MoveConstruction) {
 112   TrackDestructor::ResetCounts();
 113   {
 114     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 115     OwningPtr<TrackDestructor> B = std::move(A);
 116     EXPECT_FALSE((bool)A);
 117     EXPECT_TRUE(!A);
 118     EXPECT_FALSE(A.get());
 119     EXPECT_FALSE(A.isValid());
 120     EXPECT_TRUE((bool)B);
 121     EXPECT_FALSE(!B);
 122     EXPECT_TRUE(B.get());
 123     EXPECT_TRUE(B.isValid());
 124     EXPECT_EQ(3, (*B).val);
 125     EXPECT_EQ(3, B->val);
 126     EXPECT_EQ(0u, TrackDestructor::Destructions);
 127   }
 128   EXPECT_EQ(1u, TrackDestructor::Destructions);
 129 }
 130
 131 TEST_F(OwningPtrTest, MoveAssignment) {
 132   TrackDestructor::ResetCounts();
 133   {
 134     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 135     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 136     B = std::move(A);
 137     EXPECT_FALSE(A);
 138     EXPECT_TRUE(!A);
 139     EXPECT_FALSE(A.get());
 140     EXPECT_FALSE(A.isValid());
 141     EXPECT_TRUE((bool)B);
 142     EXPECT_FALSE(!B);
 143     EXPECT_TRUE(B.get());
 144     EXPECT_TRUE(B.isValid());
 145     EXPECT_EQ(3, (*B).val);
 146     EXPECT_EQ(3, B->val);
 147     EXPECT_EQ(1u, TrackDestructor::Destructions);
 148   }
 149   EXPECT_EQ(2u, TrackDestructor::Destructions);
 150 }
 151
 152 TEST_F(OwningPtrTest, Swap) {
 153   TrackDestructor::ResetCounts();
 154   {
 155     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 156     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 157     B.swap(A);
 158     EXPECT_TRUE((bool)A);
 159     EXPECT_FALSE(!A);
 160     EXPECT_TRUE(A.get());
 161     EXPECT_TRUE(A.isValid());
 162     EXPECT_EQ(4, (*A).val);
 163     EXPECT_EQ(4, A->val);
 164     EXPECT_TRUE((bool)B);
 165     EXPECT_FALSE(!B);
 166     EXPECT_TRUE(B.get());
 167     EXPECT_TRUE(B.isValid());
 168     EXPECT_EQ(3, (*B).val);
 169     EXPECT_EQ(3, B->val);
 170     EXPECT_EQ(0u, TrackDestructor::Destructions);
 171   }
 172   EXPECT_EQ(2u, TrackDestructor::Destructions);
 173   TrackDestructor::ResetCounts();
 174   {
 175     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 176     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 177     swap(A, B);
 178     EXPECT_TRUE((bool)A);
 179     EXPECT_FALSE(!A);
 180     EXPECT_TRUE(A.get());
 181     EXPECT_TRUE(A.isValid());
 182     EXPECT_EQ(4, (*A).val);
 183     EXPECT_EQ(4, A->val);
 184     EXPECT_TRUE((bool)B);
 185     EXPECT_FALSE(!B);
 186     EXPECT_TRUE(B.get());
 187     EXPECT_TRUE(B.isValid());
 188     EXPECT_EQ(3, (*B).val);
 189     EXPECT_EQ(3, B->val);
 190     EXPECT_EQ(0u, TrackDestructor::Destructions);
 191   }
 192   EXPECT_EQ(2u, TrackDestructor::Destructions);
 193 }
 194
 195 TEST_F(OwningPtrTest, UniqueToOwningConstruction) {
 196   TrackDestructor::ResetCounts();
 197   {
 198     std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
 199     OwningPtr<TrackDestructor> B = std::move(A);
 200     EXPECT_FALSE(A);
 201     EXPECT_TRUE(!A);
 202     EXPECT_FALSE(A.get());
 203     EXPECT_TRUE((bool)B);
 204     EXPECT_FALSE(!B);
 205     EXPECT_TRUE(B.get());
 206     EXPECT_TRUE(B.isValid());
 207     EXPECT_EQ(3, (*B).val);
 208     EXPECT_EQ(3, B->val);
 209     EXPECT_EQ(0u, TrackDestructor::Destructions);
 210   }
 211   EXPECT_EQ(1u, TrackDestructor::Destructions);
 212 }
 213
 214 TEST_F(OwningPtrTest, UniqueToOwningAssignment) {
 215   TrackDestructor::ResetCounts();
 216   {
 217     std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
 218     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 219     B = std::move(A);
 220     EXPECT_FALSE(A);
 221     EXPECT_TRUE(!A);
 222     EXPECT_FALSE(A.get());
 223     EXPECT_TRUE((bool)B);
 224     EXPECT_FALSE(!B);
 225     EXPECT_TRUE(B.get());
 226     EXPECT_TRUE(B.isValid());
 227     EXPECT_EQ(3, (*B).val);
 228     EXPECT_EQ(3, B->val);
 229     EXPECT_EQ(1u, TrackDestructor::Destructions);
 230   }
 231   EXPECT_EQ(2u, TrackDestructor::Destructions);
 232 }
 233
 234 TEST_F(OwningPtrTest, TakeUniqueConstruction) {
 235   TrackDestructor::ResetCounts();
 236   {
 237     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 238     std::unique_ptr<TrackDestructor> B = A.take_unique();
 239     EXPECT_FALSE(A);
 240     EXPECT_TRUE(!A);
 241     EXPECT_FALSE(A.get());
 242     EXPECT_FALSE(A.isValid());
 243     EXPECT_TRUE((bool)B);
 244     EXPECT_FALSE(!B);
 245     EXPECT_TRUE(B.get());
 246     EXPECT_EQ(3, (*B).val);
 247     EXPECT_EQ(3, B->val);
 248     EXPECT_EQ(0u, TrackDestructor::Destructions);
 249   }
 250   EXPECT_EQ(1u, TrackDestructor::Destructions);
 251 }
 252
 253 #if LLVM_HAS_RVALUE_REFERENCE_THIS
 254 TEST_F(OwningPtrTest, OwningToUniqueConstruction) {
 255   TrackDestructor::ResetCounts();
 256   {
 257     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 258     std::unique_ptr<TrackDestructor> B = std::move(A);
 259     EXPECT_FALSE(A);
 260     EXPECT_TRUE(!A);
 261     EXPECT_FALSE(A.get());
 262     EXPECT_FALSE(A.isValid());
 263     EXPECT_TRUE((bool)B);
 264     EXPECT_FALSE(!B);
 265     EXPECT_TRUE(B.get());
 266     EXPECT_EQ(3, (*B).val);
 267     EXPECT_EQ(3, B->val);
 268     EXPECT_EQ(0u, TrackDestructor::Destructions);
 269   }
 270   EXPECT_EQ(1u, TrackDestructor::Destructions);
 271 }
 272 #endif
 273 }