1 //===- llvm/unittest/ADT/OwningPtrTest.cpp - OwningPtr unit tests ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/OwningPtr.h"
11 #include "gtest/gtest.h"
16 struct TrackDestructor {
17 static unsigned Destructions;
19 explicit TrackDestructor(int val) : val(val) {}
20 ~TrackDestructor() { ++Destructions; }
21 static void ResetCounts() { Destructions = 0; }
24 TrackDestructor(const TrackDestructor &other) LLVM_DELETED_FUNCTION;
26 operator=(const TrackDestructor &other) LLVM_DELETED_FUNCTION;
27 TrackDestructor(TrackDestructor &&other) LLVM_DELETED_FUNCTION;
28 TrackDestructor &operator=(TrackDestructor &&other) LLVM_DELETED_FUNCTION;
31 unsigned TrackDestructor::Destructions = 0;
34 class OwningPtrTest : public testing::Test {};
36 TEST_F(OwningPtrTest, DefaultConstruction) {
37 TrackDestructor::ResetCounts();
39 OwningPtr<TrackDestructor> O;
42 EXPECT_FALSE(O.get());
43 EXPECT_FALSE(O.isValid());
45 EXPECT_EQ(0u, TrackDestructor::Destructions);
48 TEST_F(OwningPtrTest, PtrConstruction) {
49 TrackDestructor::ResetCounts();
51 OwningPtr<TrackDestructor> O(new TrackDestructor(3));
55 EXPECT_TRUE(O.isValid());
56 EXPECT_EQ(3, (*O).val);
58 EXPECT_EQ(0u, TrackDestructor::Destructions);
60 EXPECT_EQ(1u, TrackDestructor::Destructions);
63 TEST_F(OwningPtrTest, Reset) {
64 TrackDestructor::ResetCounts();
65 OwningPtr<TrackDestructor> O(new TrackDestructor(3));
66 EXPECT_EQ(0u, TrackDestructor::Destructions);
68 EXPECT_FALSE((bool)O);
70 EXPECT_FALSE(O.get());
71 EXPECT_FALSE(O.isValid());
72 EXPECT_EQ(1u, TrackDestructor::Destructions);
75 TEST_F(OwningPtrTest, Take) {
76 TrackDestructor::ResetCounts();
77 TrackDestructor *T = 0;
79 OwningPtr<TrackDestructor> O(new TrackDestructor(3));
81 EXPECT_FALSE((bool)O);
83 EXPECT_FALSE(O.get());
84 EXPECT_FALSE(O.isValid());
87 EXPECT_EQ(0u, TrackDestructor::Destructions);
90 EXPECT_EQ(1u, TrackDestructor::Destructions);
93 TEST_F(OwningPtrTest, Release) {
94 TrackDestructor::ResetCounts();
95 TrackDestructor *T = 0;
97 OwningPtr<TrackDestructor> O(new TrackDestructor(3));
99 EXPECT_FALSE((bool)O);
101 EXPECT_FALSE(O.get());
102 EXPECT_FALSE(O.isValid());
104 EXPECT_EQ(3, T->val);
105 EXPECT_EQ(0u, TrackDestructor::Destructions);
108 EXPECT_EQ(1u, TrackDestructor::Destructions);
111 TEST_F(OwningPtrTest, MoveConstruction) {
112 TrackDestructor::ResetCounts();
114 OwningPtr<TrackDestructor> A(new TrackDestructor(3));
115 OwningPtr<TrackDestructor> B = std::move(A);
116 EXPECT_FALSE((bool)A);
118 EXPECT_FALSE(A.get());
119 EXPECT_FALSE(A.isValid());
120 EXPECT_TRUE((bool)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);
128 EXPECT_EQ(1u, TrackDestructor::Destructions);
131 TEST_F(OwningPtrTest, MoveAssignment) {
132 TrackDestructor::ResetCounts();
134 OwningPtr<TrackDestructor> A(new TrackDestructor(3));
135 OwningPtr<TrackDestructor> B(new TrackDestructor(4));
139 EXPECT_FALSE(A.get());
140 EXPECT_FALSE(A.isValid());
141 EXPECT_TRUE((bool)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);
149 EXPECT_EQ(2u, TrackDestructor::Destructions);
152 TEST_F(OwningPtrTest, Swap) {
153 TrackDestructor::ResetCounts();
155 OwningPtr<TrackDestructor> A(new TrackDestructor(3));
156 OwningPtr<TrackDestructor> B(new TrackDestructor(4));
158 EXPECT_TRUE((bool)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);
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);
172 EXPECT_EQ(2u, TrackDestructor::Destructions);
173 TrackDestructor::ResetCounts();
175 OwningPtr<TrackDestructor> A(new TrackDestructor(3));
176 OwningPtr<TrackDestructor> B(new TrackDestructor(4));
178 EXPECT_TRUE((bool)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);
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);
192 EXPECT_EQ(2u, TrackDestructor::Destructions);
195 TEST_F(OwningPtrTest, UniqueToOwningConstruction) {
196 TrackDestructor::ResetCounts();
198 std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
199 OwningPtr<TrackDestructor> B = std::move(A);
202 EXPECT_FALSE(A.get());
203 EXPECT_TRUE((bool)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);
211 EXPECT_EQ(1u, TrackDestructor::Destructions);
214 TEST_F(OwningPtrTest, UniqueToOwningAssignment) {
215 TrackDestructor::ResetCounts();
217 std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
218 OwningPtr<TrackDestructor> B(new TrackDestructor(4));
222 EXPECT_FALSE(A.get());
223 EXPECT_TRUE((bool)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);
231 EXPECT_EQ(2u, TrackDestructor::Destructions);
234 TEST_F(OwningPtrTest, TakeUniqueConstruction) {
235 TrackDestructor::ResetCounts();
237 OwningPtr<TrackDestructor> A(new TrackDestructor(3));
238 std::unique_ptr<TrackDestructor> B = A.take_unique();
241 EXPECT_FALSE(A.get());
242 EXPECT_FALSE(A.isValid());
243 EXPECT_TRUE((bool)B);
245 EXPECT_TRUE(B.get());
246 EXPECT_EQ(3, (*B).val);
247 EXPECT_EQ(3, B->val);
248 EXPECT_EQ(0u, TrackDestructor::Destructions);
250 EXPECT_EQ(1u, TrackDestructor::Destructions);
253 #if LLVM_HAS_RVALUE_REFERENCE_THIS
254 TEST_F(OwningPtrTest, OwningToUniqueConstruction) {
255 TrackDestructor::ResetCounts();
257 OwningPtr<TrackDestructor> A(new TrackDestructor(3));
258 std::unique_ptr<TrackDestructor> B = std::move(A);
261 EXPECT_FALSE(A.get());
262 EXPECT_FALSE(A.isValid());
263 EXPECT_TRUE((bool)B);
265 EXPECT_TRUE(B.get());
266 EXPECT_EQ(3, (*B).val);
267 EXPECT_EQ(3, B->val);
268 EXPECT_EQ(0u, TrackDestructor::Destructions);
270 EXPECT_EQ(1u, TrackDestructor::Destructions);