1 //===- llvm/unittest/ADT/OptionalTest.cpp - Optional 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 "gtest/gtest.h"
11 #include "llvm/ADT/Optional.h"
16 struct NonDefaultConstructible {
17 static unsigned CopyConstructions;
18 static unsigned Destructions;
19 static unsigned CopyAssignments;
20 explicit NonDefaultConstructible(int) {
22 NonDefaultConstructible(const NonDefaultConstructible&) {
25 NonDefaultConstructible &operator=(const NonDefaultConstructible&) {
29 ~NonDefaultConstructible() {
32 static void ResetCounts() {
33 CopyConstructions = 0;
39 unsigned NonDefaultConstructible::CopyConstructions = 0;
40 unsigned NonDefaultConstructible::Destructions = 0;
41 unsigned NonDefaultConstructible::CopyAssignments = 0;
44 class OptionalTest : public testing::Test {
47 TEST_F(OptionalTest, NonDefaultConstructibleTest) {
48 Optional<NonDefaultConstructible> O;
52 TEST_F(OptionalTest, ResetTest) {
53 NonDefaultConstructible::ResetCounts();
54 Optional<NonDefaultConstructible> O(NonDefaultConstructible(3));
55 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
56 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
57 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
58 NonDefaultConstructible::ResetCounts();
60 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
61 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
62 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
65 TEST_F(OptionalTest, InitializationLeakTest) {
66 NonDefaultConstructible::ResetCounts();
67 Optional<NonDefaultConstructible>(NonDefaultConstructible(3));
68 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
69 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
70 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
73 TEST_F(OptionalTest, CopyConstructionTest) {
74 NonDefaultConstructible::ResetCounts();
76 Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
77 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
78 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
79 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
80 NonDefaultConstructible::ResetCounts();
81 Optional<NonDefaultConstructible> B(A);
82 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
83 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
84 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
85 NonDefaultConstructible::ResetCounts();
87 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
88 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
89 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
92 TEST_F(OptionalTest, ConstructingCopyAssignmentTest) {
93 NonDefaultConstructible::ResetCounts();
95 Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
96 Optional<NonDefaultConstructible> B;
97 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
98 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
99 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
100 NonDefaultConstructible::ResetCounts();
102 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
103 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
104 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
105 NonDefaultConstructible::ResetCounts();
107 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
108 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
109 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
112 TEST_F(OptionalTest, CopyingCopyAssignmentTest) {
113 NonDefaultConstructible::ResetCounts();
115 Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
116 Optional<NonDefaultConstructible> B(NonDefaultConstructible(4));
117 EXPECT_EQ(2u, NonDefaultConstructible::CopyConstructions);
118 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
119 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
120 NonDefaultConstructible::ResetCounts();
122 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
123 EXPECT_EQ(1u, NonDefaultConstructible::CopyAssignments);
124 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
125 NonDefaultConstructible::ResetCounts();
127 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
128 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
129 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
132 TEST_F(OptionalTest, DeletingCopyAssignmentTest) {
133 NonDefaultConstructible::ResetCounts();
135 Optional<NonDefaultConstructible> A;
136 Optional<NonDefaultConstructible> B(NonDefaultConstructible(3));
137 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
138 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
139 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
140 NonDefaultConstructible::ResetCounts();
142 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
143 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
144 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
145 NonDefaultConstructible::ResetCounts();
147 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
148 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
149 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
152 TEST_F(OptionalTest, NullCopyConstructionTest) {
153 NonDefaultConstructible::ResetCounts();
155 Optional<NonDefaultConstructible> A;
156 Optional<NonDefaultConstructible> B;
157 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
158 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
159 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
160 NonDefaultConstructible::ResetCounts();
162 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
163 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
164 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
165 NonDefaultConstructible::ResetCounts();
167 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
168 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
169 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
172 TEST_F(OptionalTest, GetValueOr) {
174 EXPECT_EQ(42, A.getValueOr(42));
177 EXPECT_EQ(5, A.getValueOr(42));
180 struct MultiArgConstructor {
182 MultiArgConstructor(int x, int y) : x(x), y(y) {}
183 explicit MultiArgConstructor(int x, bool positive)
184 : x(x), y(positive ? x : -x) {}
186 MultiArgConstructor(const MultiArgConstructor &) LLVM_DELETED_FUNCTION;
187 MultiArgConstructor(MultiArgConstructor &&) LLVM_DELETED_FUNCTION;
188 MultiArgConstructor &operator=(const MultiArgConstructor &) LLVM_DELETED_FUNCTION;
189 MultiArgConstructor &operator=(MultiArgConstructor &&) LLVM_DELETED_FUNCTION;
191 static unsigned Destructions;
192 ~MultiArgConstructor() {
195 static void ResetCounts() {
199 unsigned MultiArgConstructor::Destructions = 0;
201 TEST_F(OptionalTest, Emplace) {
202 MultiArgConstructor::ResetCounts();
203 Optional<MultiArgConstructor> A;
206 EXPECT_TRUE(A.hasValue());
209 EXPECT_EQ(0u, MultiArgConstructor::Destructions);
212 EXPECT_TRUE(A.hasValue());
215 EXPECT_EQ(1u, MultiArgConstructor::Destructions);
219 static unsigned MoveConstructions;
220 static unsigned Destructions;
221 static unsigned MoveAssignments;
223 explicit MoveOnly(int val) : val(val) {
225 MoveOnly(MoveOnly&& other) {
229 MoveOnly &operator=(MoveOnly&& other) {
237 static void ResetCounts() {
238 MoveConstructions = 0;
244 unsigned MoveOnly::MoveConstructions = 0;
245 unsigned MoveOnly::Destructions = 0;
246 unsigned MoveOnly::MoveAssignments = 0;
248 TEST_F(OptionalTest, MoveOnlyNull) {
249 MoveOnly::ResetCounts();
250 Optional<MoveOnly> O;
251 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
252 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
253 EXPECT_EQ(0u, MoveOnly::Destructions);
256 TEST_F(OptionalTest, MoveOnlyConstruction) {
257 MoveOnly::ResetCounts();
258 Optional<MoveOnly> O(MoveOnly(3));
259 EXPECT_TRUE((bool)O);
260 EXPECT_EQ(3, O->val);
261 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
262 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
263 EXPECT_EQ(1u, MoveOnly::Destructions);
266 TEST_F(OptionalTest, MoveOnlyMoveConstruction) {
267 Optional<MoveOnly> A(MoveOnly(3));
268 MoveOnly::ResetCounts();
269 Optional<MoveOnly> B(std::move(A));
270 EXPECT_FALSE((bool)A);
271 EXPECT_TRUE((bool)B);
272 EXPECT_EQ(3, B->val);
273 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
274 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
275 EXPECT_EQ(1u, MoveOnly::Destructions);
278 TEST_F(OptionalTest, MoveOnlyAssignment) {
279 MoveOnly::ResetCounts();
280 Optional<MoveOnly> O;
282 EXPECT_TRUE((bool)O);
283 EXPECT_EQ(3, O->val);
284 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
285 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
286 EXPECT_EQ(1u, MoveOnly::Destructions);
289 TEST_F(OptionalTest, MoveOnlyInitializingAssignment) {
290 Optional<MoveOnly> A(MoveOnly(3));
291 Optional<MoveOnly> B;
292 MoveOnly::ResetCounts();
294 EXPECT_FALSE((bool)A);
295 EXPECT_TRUE((bool)B);
296 EXPECT_EQ(3, B->val);
297 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
298 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
299 EXPECT_EQ(1u, MoveOnly::Destructions);
302 TEST_F(OptionalTest, MoveOnlyNullingAssignment) {
303 Optional<MoveOnly> A;
304 Optional<MoveOnly> B(MoveOnly(3));
305 MoveOnly::ResetCounts();
307 EXPECT_FALSE((bool)A);
308 EXPECT_FALSE((bool)B);
309 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
310 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
311 EXPECT_EQ(1u, MoveOnly::Destructions);
314 TEST_F(OptionalTest, MoveOnlyAssigningAssignment) {
315 Optional<MoveOnly> A(MoveOnly(3));
316 Optional<MoveOnly> B(MoveOnly(4));
317 MoveOnly::ResetCounts();
319 EXPECT_FALSE((bool)A);
320 EXPECT_TRUE((bool)B);
321 EXPECT_EQ(3, B->val);
322 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
323 EXPECT_EQ(1u, MoveOnly::MoveAssignments);
324 EXPECT_EQ(1u, MoveOnly::Destructions);
328 static unsigned Constructions;
329 static unsigned Destructions;
331 explicit Immovable(int val) : val(val) {
337 static void ResetCounts() {
342 // This should disable all move/copy operations.
343 Immovable(Immovable&& other) LLVM_DELETED_FUNCTION;
346 unsigned Immovable::Constructions = 0;
347 unsigned Immovable::Destructions = 0;
349 TEST_F(OptionalTest, ImmovableEmplace) {
350 Optional<Immovable> A;
351 Immovable::ResetCounts();
353 EXPECT_TRUE((bool)A);
354 EXPECT_EQ(4, A->val);
355 EXPECT_EQ(1u, Immovable::Constructions);
356 EXPECT_EQ(0u, Immovable::Destructions);
359 #if LLVM_HAS_RVALUE_REFERENCE_THIS
361 TEST_F(OptionalTest, MoveGetValueOr) {
362 Optional<MoveOnly> A;
364 MoveOnly::ResetCounts();
365 EXPECT_EQ(42, std::move(A).getValueOr(MoveOnly(42)).val);
366 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
367 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
368 EXPECT_EQ(2u, MoveOnly::Destructions);
371 MoveOnly::ResetCounts();
372 EXPECT_EQ(5, std::move(A).getValueOr(MoveOnly(42)).val);
373 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
374 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
375 EXPECT_EQ(2u, MoveOnly::Destructions);
378 #endif // LLVM_HAS_RVALUE_REFERENCE_THIS
380 } // end anonymous namespace