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 = 0;
  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, MoveConstruction) {
  94   TrackDestructor::ResetCounts();
  95   {
  96     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
  97     OwningPtr<TrackDestructor> B = std::move(A);
  98     EXPECT_FALSE((bool)A);
  99     EXPECT_TRUE(!A);
 100     EXPECT_FALSE(A.get());
 101     EXPECT_FALSE(A.isValid());
 102     EXPECT_TRUE((bool)B);
 103     EXPECT_FALSE(!B);
 104     EXPECT_TRUE(B.get());
 105     EXPECT_TRUE(B.isValid());
 106     EXPECT_EQ(3, (*B).val);
 107     EXPECT_EQ(3, B->val);
 108     EXPECT_EQ(0u, TrackDestructor::Destructions);
 109   }
 110   EXPECT_EQ(1u, TrackDestructor::Destructions);
 111 }
 112
 113 TEST_F(OwningPtrTest, MoveAssignment) {
 114   TrackDestructor::ResetCounts();
 115   {
 116     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 117     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 118     B = std::move(A);
 119     EXPECT_FALSE(A);
 120     EXPECT_TRUE(!A);
 121     EXPECT_FALSE(A.get());
 122     EXPECT_FALSE(A.isValid());
 123     EXPECT_TRUE((bool)B);
 124     EXPECT_FALSE(!B);
 125     EXPECT_TRUE(B.get());
 126     EXPECT_TRUE(B.isValid());
 127     EXPECT_EQ(3, (*B).val);
 128     EXPECT_EQ(3, B->val);
 129     EXPECT_EQ(1u, TrackDestructor::Destructions);
 130   }
 131   EXPECT_EQ(2u, TrackDestructor::Destructions);
 132 }
 133
 134 TEST_F(OwningPtrTest, Swap) {
 135   TrackDestructor::ResetCounts();
 136   {
 137     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 138     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 139     B.swap(A);
 140     EXPECT_TRUE((bool)A);
 141     EXPECT_FALSE(!A);
 142     EXPECT_TRUE(A.get());
 143     EXPECT_TRUE(A.isValid());
 144     EXPECT_EQ(4, (*A).val);
 145     EXPECT_EQ(4, A->val);
 146     EXPECT_TRUE((bool)B);
 147     EXPECT_FALSE(!B);
 148     EXPECT_TRUE(B.get());
 149     EXPECT_TRUE(B.isValid());
 150     EXPECT_EQ(3, (*B).val);
 151     EXPECT_EQ(3, B->val);
 152     EXPECT_EQ(0u, TrackDestructor::Destructions);
 153   }
 154   EXPECT_EQ(2u, TrackDestructor::Destructions);
 155   TrackDestructor::ResetCounts();
 156   {
 157     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 158     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 159     swap(A, B);
 160     EXPECT_TRUE((bool)A);
 161     EXPECT_FALSE(!A);
 162     EXPECT_TRUE(A.get());
 163     EXPECT_TRUE(A.isValid());
 164     EXPECT_EQ(4, (*A).val);
 165     EXPECT_EQ(4, A->val);
 166     EXPECT_TRUE((bool)B);
 167     EXPECT_FALSE(!B);
 168     EXPECT_TRUE(B.get());
 169     EXPECT_TRUE(B.isValid());
 170     EXPECT_EQ(3, (*B).val);
 171     EXPECT_EQ(3, B->val);
 172     EXPECT_EQ(0u, TrackDestructor::Destructions);
 173   }
 174   EXPECT_EQ(2u, TrackDestructor::Destructions);
 175 }
 176
 177 TEST_F(OwningPtrTest, UniqueToOwningConstruction) {
 178   TrackDestructor::ResetCounts();
 179   {
 180     std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
 181     OwningPtr<TrackDestructor> B = std::move(A);
 182     EXPECT_FALSE(A);
 183     EXPECT_TRUE(!A);
 184     EXPECT_FALSE(A.get());
 185     EXPECT_TRUE((bool)B);
 186     EXPECT_FALSE(!B);
 187     EXPECT_TRUE(B.get());
 188     EXPECT_TRUE(B.isValid());
 189     EXPECT_EQ(3, (*B).val);
 190     EXPECT_EQ(3, B->val);
 191     EXPECT_EQ(0u, TrackDestructor::Destructions);
 192   }
 193   EXPECT_EQ(1u, TrackDestructor::Destructions);
 194 }
 195
 196 TEST_F(OwningPtrTest, UniqueToOwningAssignment) {
 197   TrackDestructor::ResetCounts();
 198   {
 199     std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
 200     OwningPtr<TrackDestructor> B(new TrackDestructor(4));
 201     B = std::move(A);
 202     EXPECT_FALSE(A);
 203     EXPECT_TRUE(!A);
 204     EXPECT_FALSE(A.get());
 205     EXPECT_TRUE((bool)B);
 206     EXPECT_FALSE(!B);
 207     EXPECT_TRUE(B.get());
 208     EXPECT_TRUE(B.isValid());
 209     EXPECT_EQ(3, (*B).val);
 210     EXPECT_EQ(3, B->val);
 211     EXPECT_EQ(1u, TrackDestructor::Destructions);
 212   }
 213   EXPECT_EQ(2u, TrackDestructor::Destructions);
 214 }
 215
 216 TEST_F(OwningPtrTest, TakeUniqueConstruction) {
 217   TrackDestructor::ResetCounts();
 218   {
 219     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 220     std::unique_ptr<TrackDestructor> B = A.take_unique();
 221     EXPECT_FALSE(A);
 222     EXPECT_TRUE(!A);
 223     EXPECT_FALSE(A.get());
 224     EXPECT_FALSE(A.isValid());
 225     EXPECT_TRUE((bool)B);
 226     EXPECT_FALSE(!B);
 227     EXPECT_TRUE(B.get());
 228     EXPECT_EQ(3, (*B).val);
 229     EXPECT_EQ(3, B->val);
 230     EXPECT_EQ(0u, TrackDestructor::Destructions);
 231   }
 232   EXPECT_EQ(1u, TrackDestructor::Destructions);
 233 }
 234
 235 #if LLVM_HAS_RVALUE_REFERENCE_THIS
 236 TEST_F(OwningPtrTest, OwningToUniqueConstruction) {
 237   TrackDestructor::ResetCounts();
 238   {
 239     OwningPtr<TrackDestructor> A(new TrackDestructor(3));
 240     std::unique_ptr<TrackDestructor> B = std::move(A);
 241     EXPECT_FALSE(A);
 242     EXPECT_TRUE(!A);
 243     EXPECT_FALSE(A.get());
 244     EXPECT_FALSE(A.isValid());
 245     EXPECT_TRUE((bool)B);
 246     EXPECT_FALSE(!B);
 247     EXPECT_TRUE(B.get());
 248     EXPECT_EQ(3, (*B).val);
 249     EXPECT_EQ(3, B->val);
 250     EXPECT_EQ(0u, TrackDestructor::Destructions);
 251   }
 252   EXPECT_EQ(1u, TrackDestructor::Destructions);
 253 }
 254 #endif
 255 }