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);
173 static unsigned MoveConstructions;
174 static unsigned Destructions;
175 static unsigned MoveAssignments;
177 explicit MoveOnly(int val) : val(val) {
179 MoveOnly(MoveOnly&& other) {
183 MoveOnly &operator=(MoveOnly&& other) {
191 static void ResetCounts() {
192 MoveConstructions = 0;
198 unsigned MoveOnly::MoveConstructions = 0;
199 unsigned MoveOnly::Destructions = 0;
200 unsigned MoveOnly::MoveAssignments = 0;
202 TEST_F(OptionalTest, MoveOnlyNull) {
203 MoveOnly::ResetCounts();
204 Optional<MoveOnly> O;
205 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
206 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
207 EXPECT_EQ(0u, MoveOnly::Destructions);
210 TEST_F(OptionalTest, MoveOnlyConstruction) {
211 MoveOnly::ResetCounts();
212 Optional<MoveOnly> O(MoveOnly(3));
213 EXPECT_TRUE((bool)O);
214 EXPECT_EQ(3, O->val);
215 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
216 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
217 EXPECT_EQ(1u, MoveOnly::Destructions);
220 TEST_F(OptionalTest, MoveOnlyMoveConstruction) {
221 Optional<MoveOnly> A(MoveOnly(3));
222 MoveOnly::ResetCounts();
223 Optional<MoveOnly> B(std::move(A));
224 EXPECT_FALSE((bool)A);
225 EXPECT_TRUE((bool)B);
226 EXPECT_EQ(3, B->val);
227 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
228 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
229 EXPECT_EQ(1u, MoveOnly::Destructions);
232 TEST_F(OptionalTest, MoveOnlyAssignment) {
233 MoveOnly::ResetCounts();
234 Optional<MoveOnly> O;
236 EXPECT_TRUE((bool)O);
237 EXPECT_EQ(3, O->val);
238 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
239 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
240 EXPECT_EQ(1u, MoveOnly::Destructions);
243 TEST_F(OptionalTest, MoveOnlyInitializingAssignment) {
244 Optional<MoveOnly> A(MoveOnly(3));
245 Optional<MoveOnly> B;
246 MoveOnly::ResetCounts();
248 EXPECT_FALSE((bool)A);
249 EXPECT_TRUE((bool)B);
250 EXPECT_EQ(3, B->val);
251 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
252 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
253 EXPECT_EQ(1u, MoveOnly::Destructions);
256 TEST_F(OptionalTest, MoveOnlyNullingAssignment) {
257 Optional<MoveOnly> A;
258 Optional<MoveOnly> B(MoveOnly(3));
259 MoveOnly::ResetCounts();
261 EXPECT_FALSE((bool)A);
262 EXPECT_FALSE((bool)B);
263 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
264 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
265 EXPECT_EQ(1u, MoveOnly::Destructions);
268 TEST_F(OptionalTest, MoveOnlyAssigningAssignment) {
269 Optional<MoveOnly> A(MoveOnly(3));
270 Optional<MoveOnly> B(MoveOnly(4));
271 MoveOnly::ResetCounts();
273 EXPECT_FALSE((bool)A);
274 EXPECT_TRUE((bool)B);
275 EXPECT_EQ(3, B->val);
276 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
277 EXPECT_EQ(1u, MoveOnly::MoveAssignments);
278 EXPECT_EQ(1u, MoveOnly::Destructions);
281 } // end anonymous namespace