Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/util/UnitTestCSet.cpp

raw
1 // Copyright 2002 - 2008, 2010, 2011 National Technology Engineering
2 // Solutions of Sandia, LLC (NTESS). Under the terms of Contract
3 // DE-NA0003525 with NTESS, the U.S. Government retains certain rights
4 // in this software.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
8 // met:
9 //
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 //
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following
15 // disclaimer in the documentation and/or other materials provided
16 // with the distribution.
17 //
18 // * Neither the name of NTESS nor the names of its contributors
19 // may be used to endorse or promote products derived from this
20 // software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 //
34
35 #include "gtest/gtest.h"
36 #include "stk_util/util/CSet.hpp" // for CSet, stk
37
38
39 namespace {
40
41 static int g_objectLifetimeSpy_numConstructions;
42 static int g_objectLifetimeSpy_numCopyConstructions;
43 static int g_objectLifetimeSpy_numMoveConstructions;
44 static int g_objectLifetimeSpy_numCopyAssignments;
45 static int g_objectLifetimeSpy_numMoveAssignments;
46 static int g_objectLifetimeSpy_numDestructions;
47
48 int objectLifetimeSpy_getNumConstructions() {
49 return g_objectLifetimeSpy_numConstructions;
50 }
51
52 int objectLifetimeSpy_getNumCopyConstructions() {
53 return g_objectLifetimeSpy_numCopyConstructions;
54 }
55
56 int objectLifetimeSpy_getNumMoveConstructions() {
57 return g_objectLifetimeSpy_numMoveConstructions;
58 }
59
60 int objectLifetimeSpy_getNumCopyAssignments() {
61 return g_objectLifetimeSpy_numCopyAssignments;
62 }
63
64 int objectLifetimeSpy_getNumMoveAssignments() {
65 return g_objectLifetimeSpy_numMoveAssignments;
66 }
67
68 int objectLifetimeSpy_getNumDestructions() {
69 return g_objectLifetimeSpy_numDestructions;
70 }
71
72
73 class ObjectLifetimeSpy
74 {
75 public:
76 explicit ObjectLifetimeSpy(int i = 0)
77 : m_i(i)
78 {
79 ++g_objectLifetimeSpy_numConstructions;
80 }
81
82 virtual ~ObjectLifetimeSpy()
83 {
84 ++g_objectLifetimeSpy_numDestructions;
85 }
86
87 ObjectLifetimeSpy(const ObjectLifetimeSpy & rhs)
88 {
89 ++g_objectLifetimeSpy_numCopyConstructions;
90 m_i = rhs.m_i;
91 }
92
93 ObjectLifetimeSpy(ObjectLifetimeSpy && rhs) noexcept
94 {
95 ++g_objectLifetimeSpy_numMoveConstructions;
96 m_i = rhs.m_i;
97 rhs.m_i = 0;
98 }
99
100 ObjectLifetimeSpy & operator=(const ObjectLifetimeSpy & rhs)
101 {
102 ++g_objectLifetimeSpy_numCopyAssignments;
103 m_i = rhs.m_i;
104 return *this;
105 }
106
107 ObjectLifetimeSpy & operator=(ObjectLifetimeSpy && rhs)
108 {
109 ++g_objectLifetimeSpy_numMoveAssignments;
110 m_i = rhs.m_i;
111 rhs.m_i = 0;
112 return *this;
113 }
114
115 int value() const
116 {
117 return m_i;
118 }
119
120 private:
121 int m_i;
122 };
123
124
125 class ObjectLifetimeSpyA : public ObjectLifetimeSpy
126 {
127 public:
128 ObjectLifetimeSpyA(int value)
129 : ObjectLifetimeSpy(value)
130 {}
131 };
132
133 class ObjectLifetimeSpyB : public ObjectLifetimeSpy
134 {
135 public:
136 ObjectLifetimeSpyB(int value)
137 : ObjectLifetimeSpy(value)
138 {}
139 };
140
141
142 TEST(TestCSetComparison, NotEqual) {
143 const std::type_info * intType = &typeid(int);
144 const std::type_info * unsignedType = &typeid(unsigned);
145
146 stk::cset::less_cset compare;
147 EXPECT_TRUE(compare(intType, unsignedType));
148 EXPECT_FALSE(compare(unsignedType, intType));
149 }
150
151 TEST(TestCSetComparison, Equal) {
152 const std::type_info * intType1 = &typeid(int);
153 const std::type_info * intType2 = &typeid(int);
154
155 stk::cset::less_cset compare;
156 EXPECT_FALSE(compare(intType1, intType2));
157 EXPECT_FALSE(compare(intType2, intType1));
158 }
159
160
161 class TestCSet : public ::testing::Test
162 {
163 protected:
164 virtual void SetUp() override {
165 g_objectLifetimeSpy_numConstructions = 0;
166 g_objectLifetimeSpy_numCopyConstructions = 0;
167 g_objectLifetimeSpy_numMoveConstructions = 0;
168 g_objectLifetimeSpy_numCopyAssignments = 0;
169 g_objectLifetimeSpy_numMoveAssignments = 0;
170 g_objectLifetimeSpy_numDestructions = 0;
171 }
172
173 virtual void TearDown() override {}
174 };
175
176
177 TEST_F(TestCSet, NoDelete_InsertSingleObject)
178 {
179 {
180 stk::CSet cs;
181 ObjectLifetimeSpy obj(1);
182 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
183 EXPECT_EQ(insertedObj->value(), 1);
184 }
185
186 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
187 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
188 }
189
190 TEST_F(TestCSet, NoDelete_InsertTwoObjects)
191 {
192 {
193 stk::CSet cs;
194 ObjectLifetimeSpyA objA(1);
195 ObjectLifetimeSpyB objB(2);
196 const ObjectLifetimeSpyA* insertedObjA = cs.insert_no_delete<ObjectLifetimeSpyA>(&objA);
197 const ObjectLifetimeSpyB* insertedObjB = cs.insert_no_delete<ObjectLifetimeSpyB>(&objB);
198 EXPECT_EQ(insertedObjA->value(), 1);
199 EXPECT_EQ(insertedObjB->value(), 2);
200 }
201
202 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
203 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
204 }
205
206 TEST_F(TestCSet, NoDelete_DoubleInsert_NoReplace)
207 {
208 {
209 stk::CSet cs;
210 ObjectLifetimeSpy obj1(1);
211 ObjectLifetimeSpy obj2(2);
212 const ObjectLifetimeSpy* insertedObjFirst = cs.insert_no_delete<ObjectLifetimeSpy>(&obj1);
213 const ObjectLifetimeSpy* insertedObjSecond = cs.insert_no_delete<ObjectLifetimeSpy>(&obj2);
214 EXPECT_EQ(insertedObjFirst->value(), 1);
215 EXPECT_EQ(insertedObjSecond->value(), 1);
216 EXPECT_EQ(insertedObjFirst, insertedObjSecond);
217 }
218
219 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
220 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
221 }
222
223 TEST_F(TestCSet, GetNotFound)
224 {
225 {
226 stk::CSet cs;
227 ObjectLifetimeSpy obj(1);
228 const ObjectLifetimeSpy* getObj = cs.get<ObjectLifetimeSpy>();
229 EXPECT_EQ(getObj, nullptr);
230 }
231
232 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
233 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
234 }
235
236 TEST_F(TestCSet, NoDelete_GetSingleObject)
237 {
238 {
239 stk::CSet cs;
240 ObjectLifetimeSpy obj(1);
241 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
242 EXPECT_EQ(insertedObj->value(), 1);
243
244 const ObjectLifetimeSpy* getObj = cs.get<ObjectLifetimeSpy>();
245 EXPECT_EQ(getObj->value(), 1);
246 }
247
248 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
249 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
250 }
251
252 TEST_F(TestCSet, NoDelete_GetTwoObjects)
253 {
254 {
255 stk::CSet cs;
256 ObjectLifetimeSpyA objA(1);
257 ObjectLifetimeSpyB objB(2);
258 const ObjectLifetimeSpyA* insertedObjA = cs.insert_no_delete<ObjectLifetimeSpyA>(&objA);
259 const ObjectLifetimeSpyB* insertedObjB = cs.insert_no_delete<ObjectLifetimeSpyB>(&objB);
260 EXPECT_EQ(insertedObjA->value(), 1);
261 EXPECT_EQ(insertedObjB->value(), 2);
262
263 const ObjectLifetimeSpyA* getObjA = cs.get<ObjectLifetimeSpyA>();
264 const ObjectLifetimeSpyB* getObjB = cs.get<ObjectLifetimeSpyB>();
265 EXPECT_EQ(getObjA->value(), 1);
266 EXPECT_EQ(getObjB->value(), 2);
267 }
268
269 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
270 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
271 }
272
273 TEST_F(TestCSet, RemoveFromEmpty)
274 {
275 {
276 stk::CSet cs;
277 ObjectLifetimeSpy obj(1);
278 EXPECT_FALSE(cs.remove<ObjectLifetimeSpy>(&obj));
279 }
280
281 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
282 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
283 }
284
285 TEST_F(TestCSet, NoDelete_Remove)
286 {
287 {
288 stk::CSet cs;
289 ObjectLifetimeSpy obj(1);
290 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
291 EXPECT_EQ(insertedObj->value(), 1);
292
293 EXPECT_TRUE(cs.remove<ObjectLifetimeSpy>(&obj));
294 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
295 }
296
297 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
298 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
299 }
300
301 TEST_F(TestCSet, NoDelete_RemoveSameTwice)
302 {
303 {
304 stk::CSet cs;
305 ObjectLifetimeSpy obj(1);
306 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
307 EXPECT_EQ(insertedObj->value(), 1);
308
309 EXPECT_TRUE (cs.remove<ObjectLifetimeSpy>(&obj));
310 EXPECT_FALSE(cs.remove<ObjectLifetimeSpy>(&obj));
311 }
312
313 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
314 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
315 }
316
317 TEST_F(TestCSet, NoDelete_RemoveTwoObjects)
318 {
319 {
320 stk::CSet cs;
321 ObjectLifetimeSpyA objA(1);
322 ObjectLifetimeSpyB objB(2);
323 const ObjectLifetimeSpyA* insertedObjA = cs.insert_no_delete<ObjectLifetimeSpyA>(&objA);
324 const ObjectLifetimeSpyB* insertedObjB = cs.insert_no_delete<ObjectLifetimeSpyB>(&objB);
325 EXPECT_EQ(insertedObjA->value(), 1);
326 EXPECT_EQ(insertedObjB->value(), 2);
327
328 EXPECT_TRUE(cs.remove<ObjectLifetimeSpyA>(&objA));
329 EXPECT_TRUE(cs.remove<ObjectLifetimeSpyB>(&objB));
330 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
331 }
332
333 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
334 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
335 }
336
337
338 TEST_F(TestCSet, WithDelete_InsertSingleObject)
339 {
340 {
341 stk::CSet cs;
342 ObjectLifetimeSpy* obj = new ObjectLifetimeSpy(1);
343 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
344 EXPECT_EQ(insertedObj->value(), 1);
345 }
346
347 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
348 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
349 }
350
351 TEST_F(TestCSet, WithDelete_InsertTwoObjects)
352 {
353 {
354 stk::CSet cs;
355 ObjectLifetimeSpyA* objA = new ObjectLifetimeSpyA(1);
356 ObjectLifetimeSpyB* objB = new ObjectLifetimeSpyB(2);
357 const ObjectLifetimeSpyA* insertedObjA = cs.insert_with_delete<ObjectLifetimeSpyA>(objA);
358 const ObjectLifetimeSpyB* insertedObjB = cs.insert_with_delete<ObjectLifetimeSpyB>(objB);
359 EXPECT_EQ(insertedObjA->value(), 1);
360 EXPECT_EQ(insertedObjB->value(), 2);
361 }
362
363 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
364 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
365 }
366
367 TEST_F(TestCSet, WithDelete_DoubleInsert_NoReplace)
368 {
369 {
370 stk::CSet cs;
371 ObjectLifetimeSpy* obj1 = new ObjectLifetimeSpy(1);
372 ObjectLifetimeSpy* obj2 = new ObjectLifetimeSpy(2);
373 const ObjectLifetimeSpy* insertedObjFirst = cs.insert_with_delete<ObjectLifetimeSpy>(obj1);
374 const ObjectLifetimeSpy* insertedObjSecond = cs.insert_with_delete<ObjectLifetimeSpy>(obj2);
375 EXPECT_EQ(insertedObjFirst->value(), 1);
376 EXPECT_EQ(insertedObjSecond->value(), 1);
377 EXPECT_EQ(insertedObjFirst, insertedObjSecond);
378 delete obj2;
379 }
380
381 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
382 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
383 }
384
385 TEST_F(TestCSet, WithDelete_GetSingleObject)
386 {
387 {
388 stk::CSet cs;
389 ObjectLifetimeSpy* obj = new ObjectLifetimeSpy(1);
390 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
391 EXPECT_EQ(insertedObj->value(), 1);
392
393 const ObjectLifetimeSpy* getObj = cs.get<ObjectLifetimeSpy>();
394 EXPECT_EQ(getObj->value(), 1);
395 }
396
397 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
398 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
399 }
400
401 TEST_F(TestCSet, WithDelete_GetTwoObjects)
402 {
403 {
404 stk::CSet cs;
405 ObjectLifetimeSpyA* objA = new ObjectLifetimeSpyA(1);
406 ObjectLifetimeSpyB* objB = new ObjectLifetimeSpyB(2);
407 const ObjectLifetimeSpyA* insertedObjA = cs.insert_with_delete<ObjectLifetimeSpyA>(objA);
408 const ObjectLifetimeSpyB* insertedObjB = cs.insert_with_delete<ObjectLifetimeSpyB>(objB);
409 EXPECT_EQ(insertedObjA->value(), 1);
410 EXPECT_EQ(insertedObjB->value(), 2);
411
412 const ObjectLifetimeSpyA* getObjA = cs.get<ObjectLifetimeSpyA>();
413 const ObjectLifetimeSpyB* getObjB = cs.get<ObjectLifetimeSpyB>();
414 EXPECT_EQ(getObjA->value(), 1);
415 EXPECT_EQ(getObjB->value(), 2);
416 }
417
418 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
419 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
420 }
421
422 TEST_F(TestCSet, WithDelete_Remove)
423 {
424 {
425 stk::CSet cs;
426 ObjectLifetimeSpy* obj = new ObjectLifetimeSpy(1);
427 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
428 EXPECT_EQ(insertedObj->value(), 1);
429
430 EXPECT_TRUE(cs.remove<ObjectLifetimeSpy>(obj));
431 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
432 delete obj;
433 }
434
435 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
436 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
437 }
438
439 TEST_F(TestCSet, WithDelete_RemoveSameTwice)
440 {
441 {
442 stk::CSet cs;
443 ObjectLifetimeSpy* obj = new ObjectLifetimeSpy(1);
444 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
445 EXPECT_EQ(insertedObj->value(), 1);
446
447 EXPECT_TRUE (cs.remove<ObjectLifetimeSpy>(obj));
448 EXPECT_FALSE(cs.remove<ObjectLifetimeSpy>(obj));
449 delete obj;
450 }
451
452 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
453 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
454 }
455
456 TEST_F(TestCSet, WithDelete_RemoveTwoObjects)
457 {
458 {
459 stk::CSet cs;
460 ObjectLifetimeSpyA* objA = new ObjectLifetimeSpyA(1);
461 ObjectLifetimeSpyB* objB = new ObjectLifetimeSpyB(2);
462 const ObjectLifetimeSpyA* insertedObjA = cs.insert_with_delete<ObjectLifetimeSpyA>(objA);
463 const ObjectLifetimeSpyB* insertedObjB = cs.insert_with_delete<ObjectLifetimeSpyB>(objB);
464 EXPECT_EQ(insertedObjA->value(), 1);
465 EXPECT_EQ(insertedObjB->value(), 2);
466
467 EXPECT_TRUE(cs.remove<ObjectLifetimeSpyA>(objA));
468 EXPECT_TRUE(cs.remove<ObjectLifetimeSpyB>(objB));
469 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
470 delete objA;
471 delete objB;
472 }
473
474 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 2);
475 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 2);
476 }
477
478
479 TEST_F(TestCSet, CopyConstructEmpty)
480 {
481 {
482 stk::CSet cs;
483 stk::CSet csCopy = cs;
484 }
485
486 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 0);
487 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
488 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
489 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
490 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
491 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
492 }
493
494 TEST_F(TestCSet, CopyConstructNoDelete)
495 {
496 {
497 stk::CSet cs;
498 ObjectLifetimeSpy obj(1);
499 {
500 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
501 EXPECT_EQ(insertedObj->value(), 1);
502
503 stk::CSet csCopy = cs;
504
505 const ObjectLifetimeSpy* copiedGetObj = csCopy.get<ObjectLifetimeSpy>();
506 EXPECT_EQ(copiedGetObj->value(), 1);
507 EXPECT_EQ(insertedObj, copiedGetObj);
508 }
509
510 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
511 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
512 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
513 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
514 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
515 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
516 }
517
518 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
519 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
520 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
521 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
522 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
523 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
524 }
525
526 TEST_F(TestCSet, CopyConstructWithDelete)
527 {
528 {
529 stk::CSet cs;
530 ObjectLifetimeSpy * obj = new ObjectLifetimeSpy(1);
531 {
532 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
533 EXPECT_EQ(insertedObj->value(), 1);
534
535 stk::CSet csCopy = cs;
536
537 const ObjectLifetimeSpy* copiedGetObj = csCopy.get<ObjectLifetimeSpy>();
538 EXPECT_EQ(copiedGetObj->value(), 1);
539 EXPECT_EQ(insertedObj, copiedGetObj);
540 }
541
542 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
543 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
544 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
545 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
546 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
547 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
548 }
549
550 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
551 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
552 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
553 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
554 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
555 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
556 }
557
558
559 TEST_F(TestCSet, CopyAssignEmpty)
560 {
561 {
562 stk::CSet cs;
563 {
564 stk::CSet secondCs;
565 secondCs = cs;
566 }
567 }
568
569 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 0);
570 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
571 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
572 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
573 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
574 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
575 }
576
577 TEST_F(TestCSet, CopyAssignNoDelete)
578 {
579 {
580 stk::CSet cs;
581 ObjectLifetimeSpy obj(1);
582 {
583 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
584 EXPECT_EQ(insertedObj->value(), 1);
585
586 stk::CSet secondCs;
587 secondCs = cs;
588
589 const ObjectLifetimeSpy* assignedGetObj = secondCs.get<ObjectLifetimeSpy>();
590 EXPECT_EQ(assignedGetObj->value(), 1);
591 EXPECT_EQ(insertedObj, assignedGetObj);
592 }
593
594 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
595 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
596 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
597 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
598 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
599 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
600 }
601
602 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
603 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
604 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
605 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
606 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
607 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
608 }
609
610 TEST_F(TestCSet, CopyAssignWithDelete)
611 {
612 {
613 stk::CSet cs;
614 ObjectLifetimeSpy * obj = new ObjectLifetimeSpy(1);
615 {
616 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
617 EXPECT_EQ(insertedObj->value(), 1);
618
619 stk::CSet secondCs;
620 secondCs = cs;
621
622 const ObjectLifetimeSpy* assignedGetObj = secondCs.get<ObjectLifetimeSpy>();
623 EXPECT_EQ(assignedGetObj->value(), 1);
624 EXPECT_EQ(insertedObj, assignedGetObj);
625 }
626
627 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
628 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
629 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
630 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
631 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
632 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
633 }
634
635 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
636 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
637 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
638 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
639 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
640 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
641 }
642
643
644 TEST_F(TestCSet, MoveConstructEmpty)
645 {
646 {
647 stk::CSet cs;
648 stk::CSet csCopy = std::move(cs);
649 }
650
651 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 0);
652 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
653 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
654 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
655 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
656 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
657 }
658
659 TEST_F(TestCSet, MoveConstructNoDelete)
660 {
661 {
662 stk::CSet cs;
663 ObjectLifetimeSpy obj(1);
664 {
665 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
666 EXPECT_EQ(insertedObj->value(), 1);
667
668 stk::CSet csCopy = std::move(cs);
669
670 const ObjectLifetimeSpy* copiedGetObj = csCopy.get<ObjectLifetimeSpy>();
671 EXPECT_EQ(copiedGetObj->value(), 1);
672 EXPECT_EQ(insertedObj, copiedGetObj);
673 }
674
675 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
676 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
677 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
678 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
679 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
680 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
681 }
682
683 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
684 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
685 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
686 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
687 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
688 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
689 }
690
691 TEST_F(TestCSet, MoveConstructWithDelete)
692 {
693 {
694 stk::CSet cs;
695 ObjectLifetimeSpy * obj = new ObjectLifetimeSpy(1);
696 {
697 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
698 EXPECT_EQ(insertedObj->value(), 1);
699
700 stk::CSet csCopy = std::move(cs);
701
702 const ObjectLifetimeSpy* copiedGetObj = csCopy.get<ObjectLifetimeSpy>();
703 EXPECT_EQ(copiedGetObj->value(), 1);
704 EXPECT_EQ(insertedObj, copiedGetObj);
705 }
706
707 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
708 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
709 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
710 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
711 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
712 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
713 }
714
715 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
716 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
717 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
718 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
719 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
720 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
721 }
722
723
724 TEST_F(TestCSet, MoveAssignEmpty)
725 {
726 {
727 stk::CSet cs;
728 {
729 stk::CSet secondCs;
730 secondCs = std::move(cs);
731 }
732 }
733
734 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 0);
735 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
736 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
737 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
738 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
739 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
740 }
741
742 TEST_F(TestCSet, MoveAssignNoDelete)
743 {
744 {
745 stk::CSet cs;
746 ObjectLifetimeSpy obj(1);
747 {
748 const ObjectLifetimeSpy* insertedObj = cs.insert_no_delete<ObjectLifetimeSpy>(&obj);
749 EXPECT_EQ(insertedObj->value(), 1);
750
751 stk::CSet secondCs;
752 secondCs = std::move(cs);
753
754 const ObjectLifetimeSpy* assignedGetObj = secondCs.get<ObjectLifetimeSpy>();
755 EXPECT_EQ(assignedGetObj->value(), 1);
756 EXPECT_EQ(insertedObj, assignedGetObj);
757 }
758
759 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
760 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
761 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
762 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
763 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
764 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 0);
765 }
766
767 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
768 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
769 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
770 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
771 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
772 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
773 }
774
775 TEST_F(TestCSet, MoveAssignWithDelete)
776 {
777 {
778 stk::CSet cs;
779 ObjectLifetimeSpy * obj = new ObjectLifetimeSpy(1);
780 {
781 const ObjectLifetimeSpy* insertedObj = cs.insert_with_delete<ObjectLifetimeSpy>(obj);
782 EXPECT_EQ(insertedObj->value(), 1);
783
784 stk::CSet secondCs;
785 secondCs = std::move(cs);
786
787 const ObjectLifetimeSpy* assignedGetObj = secondCs.get<ObjectLifetimeSpy>();
788 EXPECT_EQ(assignedGetObj->value(), 1);
789 EXPECT_EQ(insertedObj, assignedGetObj);
790 }
791
792 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
793 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
794 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
795 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
796 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
797 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
798 }
799
800 EXPECT_EQ(objectLifetimeSpy_getNumConstructions(), 1);
801 EXPECT_EQ(objectLifetimeSpy_getNumCopyConstructions(), 0);
802 EXPECT_EQ(objectLifetimeSpy_getNumMoveConstructions(), 0);
803 EXPECT_EQ(objectLifetimeSpy_getNumCopyAssignments(), 0);
804 EXPECT_EQ(objectLifetimeSpy_getNumMoveAssignments(), 0);
805 EXPECT_EQ(objectLifetimeSpy_getNumDestructions(), 1);
806 }
807
808 }