OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/base/list_container.h" | 5 #include "cc/base/list_container.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <vector> | 10 #include <vector> |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
44 | 44 |
45 class DerivedElement3 : public DerivedElement { | 45 class DerivedElement3 : public DerivedElement { |
46 protected: | 46 protected: |
47 bool bool_values3[3]; | 47 bool bool_values3[3]; |
48 char char_values3[3]; | 48 char char_values3[3]; |
49 int int_values3[3]; | 49 int int_values3[3]; |
50 long long_values3[3]; | 50 long long_values3[3]; |
51 }; | 51 }; |
52 | 52 |
53 const size_t kLargestDerivedElementSize = sizeof(DerivedElement3); | 53 const size_t kLargestDerivedElementSize = sizeof(DerivedElement3); |
54 const size_t kLargestDerivedElementAlign = ALIGNOF(DerivedElement3); | 54 const size_t kLargestDerivedElementAlign = alignof(DerivedElement3); |
55 | 55 |
56 static_assert(sizeof(DerivedElement1) <= kLargestDerivedElementSize, | 56 static_assert(sizeof(DerivedElement1) <= kLargestDerivedElementSize, |
57 "Largest Derived Element size needs update. DerivedElement1 is " | 57 "Largest Derived Element size needs update. DerivedElement1 is " |
58 "currently largest."); | 58 "currently largest."); |
59 static_assert(sizeof(DerivedElement2) <= kLargestDerivedElementSize, | 59 static_assert(sizeof(DerivedElement2) <= kLargestDerivedElementSize, |
60 "Largest Derived Element size needs update. DerivedElement2 is " | 60 "Largest Derived Element size needs update. DerivedElement2 is " |
61 "currently largest."); | 61 "currently largest."); |
62 static_assert(ALIGNOF(DerivedElement1) <= kLargestDerivedElementSize, | 62 static_assert(alignof(DerivedElement1) <= kLargestDerivedElementSize, |
63 "Largest Derived Element align needs update. DerivedElement1 is " | 63 "Largest Derived Element align needs update. DerivedElement1 is " |
64 "currently largest."); | 64 "currently largest."); |
65 static_assert(ALIGNOF(DerivedElement2) <= kLargestDerivedElementSize, | 65 static_assert(alignof(DerivedElement2) <= kLargestDerivedElementSize, |
66 "Largest Derived Element align needs update. DerivedElement2 is " | 66 "Largest Derived Element align needs update. DerivedElement2 is " |
67 "currently largest."); | 67 "currently largest."); |
68 | 68 |
69 // Element class having no derived classes. | 69 // Element class having no derived classes. |
70 class NonDerivedElement { | 70 class NonDerivedElement { |
71 public: | 71 public: |
72 NonDerivedElement() {} | 72 NonDerivedElement() {} |
73 ~NonDerivedElement() {} | 73 ~NonDerivedElement() {} |
74 | 74 |
75 int int_values[1]; | 75 int int_values[1]; |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
130 class MockDerivedElementSubclass : public MockDerivedElement { | 130 class MockDerivedElementSubclass : public MockDerivedElement { |
131 public: | 131 public: |
132 MockDerivedElementSubclass() { | 132 MockDerivedElementSubclass() { |
133 set_value(kMagicNumberToUseForSimpleDerivedElementTwo); | 133 set_value(kMagicNumberToUseForSimpleDerivedElementTwo); |
134 } | 134 } |
135 }; | 135 }; |
136 | 136 |
137 const size_t kCurrentLargestDerivedElementSize = | 137 const size_t kCurrentLargestDerivedElementSize = |
138 std::max(kLargestDerivedElementSize, sizeof(MockDerivedElementSubclass)); | 138 std::max(kLargestDerivedElementSize, sizeof(MockDerivedElementSubclass)); |
139 const size_t kCurrentLargestDerivedElementAlign = | 139 const size_t kCurrentLargestDerivedElementAlign = |
140 std::max(kLargestDerivedElementAlign, ALIGNOF(MockDerivedElementSubclass)); | 140 std::max(kLargestDerivedElementAlign, alignof(MockDerivedElementSubclass)); |
141 | 141 |
142 TEST(ListContainerTest, ConstructorCalledInAllocateAndConstruct) { | 142 TEST(ListContainerTest, ConstructorCalledInAllocateAndConstruct) { |
143 ListContainer<DerivedElement> list(kCurrentLargestDerivedElementAlign, | 143 ListContainer<DerivedElement> list(kCurrentLargestDerivedElementAlign, |
144 kCurrentLargestDerivedElementSize, 0); | 144 kCurrentLargestDerivedElementSize, 0); |
145 | 145 |
146 size_t size = 2; | 146 size_t size = 2; |
147 SimpleDerivedElementConstructMagicNumberOne* de_1 = | 147 SimpleDerivedElementConstructMagicNumberOne* de_1 = |
148 list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberOne>(); | 148 list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberOne>(); |
149 SimpleDerivedElementConstructMagicNumberTwo* de_2 = | 149 SimpleDerivedElementConstructMagicNumberTwo* de_2 = |
150 list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberTwo>(); | 150 list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberTwo>(); |
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
270 EXPECT_CALL(*de_1, Destruct()); | 270 EXPECT_CALL(*de_1, Destruct()); |
271 EXPECT_CALL(separator, Call()); | 271 EXPECT_CALL(separator, Call()); |
272 EXPECT_CALL(*de_1, Destruct()).Times(0); | 272 EXPECT_CALL(*de_1, Destruct()).Times(0); |
273 } | 273 } |
274 | 274 |
275 list.EraseAndInvalidateAllPointers(list.begin()); | 275 list.EraseAndInvalidateAllPointers(list.begin()); |
276 separator.Call(); | 276 separator.Call(); |
277 } | 277 } |
278 | 278 |
279 TEST(ListContainerTest, SimpleIndexAccessNonDerivedElement) { | 279 TEST(ListContainerTest, SimpleIndexAccessNonDerivedElement) { |
280 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 280 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
281 sizeof(NonDerivedElement), 0); | 281 sizeof(NonDerivedElement), 0); |
282 | 282 |
283 size_t size = 3; | 283 size_t size = 3; |
284 NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>(); | 284 NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>(); |
285 NonDerivedElement* nde_2 = list.AllocateAndConstruct<NonDerivedElement>(); | 285 NonDerivedElement* nde_2 = list.AllocateAndConstruct<NonDerivedElement>(); |
286 NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>(); | 286 NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>(); |
287 | 287 |
288 EXPECT_EQ(size, list.size()); | 288 EXPECT_EQ(size, list.size()); |
289 EXPECT_EQ(nde_1, list.front()); | 289 EXPECT_EQ(nde_1, list.front()); |
290 EXPECT_EQ(nde_3, list.back()); | 290 EXPECT_EQ(nde_3, list.back()); |
291 EXPECT_EQ(list.front(), list.ElementAt(0)); | 291 EXPECT_EQ(list.front(), list.ElementAt(0)); |
292 EXPECT_EQ(nde_2, list.ElementAt(1)); | 292 EXPECT_EQ(nde_2, list.ElementAt(1)); |
293 EXPECT_EQ(list.back(), list.ElementAt(2)); | 293 EXPECT_EQ(list.back(), list.ElementAt(2)); |
294 } | 294 } |
295 | 295 |
296 TEST(ListContainerTest, SimpleInsertionNonDerivedElement) { | 296 TEST(ListContainerTest, SimpleInsertionNonDerivedElement) { |
297 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 297 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
298 sizeof(NonDerivedElement), 0); | 298 sizeof(NonDerivedElement), 0); |
299 | 299 |
300 size_t size = 3; | 300 size_t size = 3; |
301 NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>(); | 301 NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>(); |
302 list.AllocateAndConstruct<NonDerivedElement>(); | 302 list.AllocateAndConstruct<NonDerivedElement>(); |
303 NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>(); | 303 NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>(); |
304 | 304 |
305 EXPECT_EQ(size, list.size()); | 305 EXPECT_EQ(size, list.size()); |
306 EXPECT_EQ(nde_1, list.front()); | 306 EXPECT_EQ(nde_1, list.front()); |
307 EXPECT_EQ(nde_3, list.back()); | 307 EXPECT_EQ(nde_3, list.back()); |
308 } | 308 } |
309 | 309 |
310 TEST(ListContainerTest, SimpleInsertionAndClearNonDerivedElement) { | 310 TEST(ListContainerTest, SimpleInsertionAndClearNonDerivedElement) { |
311 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 311 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
312 sizeof(NonDerivedElement), 0); | 312 sizeof(NonDerivedElement), 0); |
313 EXPECT_TRUE(list.empty()); | 313 EXPECT_TRUE(list.empty()); |
314 EXPECT_EQ(0u, list.size()); | 314 EXPECT_EQ(0u, list.size()); |
315 | 315 |
316 size_t size = 3; | 316 size_t size = 3; |
317 NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>(); | 317 NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>(); |
318 list.AllocateAndConstruct<NonDerivedElement>(); | 318 list.AllocateAndConstruct<NonDerivedElement>(); |
319 NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>(); | 319 NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>(); |
320 | 320 |
321 EXPECT_EQ(size, list.size()); | 321 EXPECT_EQ(size, list.size()); |
322 EXPECT_EQ(nde_1, list.front()); | 322 EXPECT_EQ(nde_1, list.front()); |
323 EXPECT_EQ(nde_3, list.back()); | 323 EXPECT_EQ(nde_3, list.back()); |
324 EXPECT_FALSE(list.empty()); | 324 EXPECT_FALSE(list.empty()); |
325 | 325 |
326 list.clear(); | 326 list.clear(); |
327 EXPECT_TRUE(list.empty()); | 327 EXPECT_TRUE(list.empty()); |
328 EXPECT_EQ(0u, list.size()); | 328 EXPECT_EQ(0u, list.size()); |
329 } | 329 } |
330 | 330 |
331 TEST(ListContainerTest, SimpleInsertionClearAndInsertAgainNonDerivedElement) { | 331 TEST(ListContainerTest, SimpleInsertionClearAndInsertAgainNonDerivedElement) { |
332 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 332 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
333 sizeof(NonDerivedElement), 0); | 333 sizeof(NonDerivedElement), 0); |
334 EXPECT_TRUE(list.empty()); | 334 EXPECT_TRUE(list.empty()); |
335 EXPECT_EQ(0u, list.size()); | 335 EXPECT_EQ(0u, list.size()); |
336 | 336 |
337 size_t size = 2; | 337 size_t size = 2; |
338 NonDerivedElement* nde_front = list.AllocateAndConstruct<NonDerivedElement>(); | 338 NonDerivedElement* nde_front = list.AllocateAndConstruct<NonDerivedElement>(); |
339 NonDerivedElement* nde_back = list.AllocateAndConstruct<NonDerivedElement>(); | 339 NonDerivedElement* nde_back = list.AllocateAndConstruct<NonDerivedElement>(); |
340 | 340 |
341 EXPECT_EQ(size, list.size()); | 341 EXPECT_EQ(size, list.size()); |
342 EXPECT_EQ(nde_front, list.front()); | 342 EXPECT_EQ(nde_front, list.front()); |
(...skipping 12 matching lines...) Expand all Loading... |
355 EXPECT_EQ(size, list.size()); | 355 EXPECT_EQ(size, list.size()); |
356 EXPECT_EQ(nde_front, list.front()); | 356 EXPECT_EQ(nde_front, list.front()); |
357 EXPECT_EQ(nde_back, list.back()); | 357 EXPECT_EQ(nde_back, list.back()); |
358 EXPECT_FALSE(list.empty()); | 358 EXPECT_FALSE(list.empty()); |
359 } | 359 } |
360 | 360 |
361 // This test is used to test when there is more than one allocation needed | 361 // This test is used to test when there is more than one allocation needed |
362 // for, ListContainer can still perform like normal vector. | 362 // for, ListContainer can still perform like normal vector. |
363 TEST(ListContainerTest, | 363 TEST(ListContainerTest, |
364 SimpleInsertionTriggerMoreThanOneAllocationNonDerivedElement) { | 364 SimpleInsertionTriggerMoreThanOneAllocationNonDerivedElement) { |
365 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 365 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
366 sizeof(NonDerivedElement), 2); | 366 sizeof(NonDerivedElement), 2); |
367 std::vector<NonDerivedElement*> nde_list; | 367 std::vector<NonDerivedElement*> nde_list; |
368 size_t size = 10; | 368 size_t size = 10; |
369 for (size_t i = 0; i < size; ++i) { | 369 for (size_t i = 0; i < size; ++i) { |
370 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); | 370 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); |
371 } | 371 } |
372 EXPECT_EQ(size, list.size()); | 372 EXPECT_EQ(size, list.size()); |
373 | 373 |
374 ListContainer<NonDerivedElement>::Iterator iter = list.begin(); | 374 ListContainer<NonDerivedElement>::Iterator iter = list.begin(); |
375 for (std::vector<NonDerivedElement*>::const_iterator nde_iter = | 375 for (std::vector<NonDerivedElement*>::const_iterator nde_iter = |
376 nde_list.begin(); | 376 nde_list.begin(); |
377 nde_iter != nde_list.end(); ++nde_iter) { | 377 nde_iter != nde_list.end(); ++nde_iter) { |
378 EXPECT_EQ(*nde_iter, *iter); | 378 EXPECT_EQ(*nde_iter, *iter); |
379 ++iter; | 379 ++iter; |
380 } | 380 } |
381 } | 381 } |
382 | 382 |
383 TEST(ListContainerTest, | 383 TEST(ListContainerTest, |
384 CorrectAllocationSizeForMoreThanOneAllocationNonDerivedElement) { | 384 CorrectAllocationSizeForMoreThanOneAllocationNonDerivedElement) { |
385 // Constructor sets the allocation size to 2. Every time ListContainer needs | 385 // Constructor sets the allocation size to 2. Every time ListContainer needs |
386 // to allocate again, it doubles allocation size. In this test, 10 elements is | 386 // to allocate again, it doubles allocation size. In this test, 10 elements is |
387 // needed, thus ListContainerShould allocate spaces 2, 4 and 8 elements. | 387 // needed, thus ListContainerShould allocate spaces 2, 4 and 8 elements. |
388 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 388 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
389 sizeof(NonDerivedElement), 2); | 389 sizeof(NonDerivedElement), 2); |
390 std::vector<NonDerivedElement*> nde_list; | 390 std::vector<NonDerivedElement*> nde_list; |
391 size_t size = 10; | 391 size_t size = 10; |
392 for (size_t i = 0; i < size; ++i) { | 392 for (size_t i = 0; i < size; ++i) { |
393 // Before asking for a new element, space available without another | 393 // Before asking for a new element, space available without another |
394 // allocation follows. | 394 // allocation follows. |
395 switch (i) { | 395 switch (i) { |
396 case 2: | 396 case 2: |
397 case 6: | 397 case 6: |
398 EXPECT_EQ(0u, list.AvailableSizeWithoutAnotherAllocationForTesting()); | 398 EXPECT_EQ(0u, list.AvailableSizeWithoutAnotherAllocationForTesting()); |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
459 ListContainer<NonDerivedElement>::Iterator iter = list.begin(); | 459 ListContainer<NonDerivedElement>::Iterator iter = list.begin(); |
460 for (std::vector<NonDerivedElement*>::const_iterator nde_iter = | 460 for (std::vector<NonDerivedElement*>::const_iterator nde_iter = |
461 nde_list.begin(); | 461 nde_list.begin(); |
462 nde_iter != nde_list.end(); ++nde_iter) { | 462 nde_iter != nde_list.end(); ++nde_iter) { |
463 EXPECT_EQ(*nde_iter, *iter); | 463 EXPECT_EQ(*nde_iter, *iter); |
464 ++iter; | 464 ++iter; |
465 } | 465 } |
466 } | 466 } |
467 | 467 |
468 TEST(ListContainerTest, SimpleIterationNonDerivedElement) { | 468 TEST(ListContainerTest, SimpleIterationNonDerivedElement) { |
469 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 469 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
470 sizeof(NonDerivedElement), 0); | 470 sizeof(NonDerivedElement), 0); |
471 std::vector<NonDerivedElement*> nde_list; | 471 std::vector<NonDerivedElement*> nde_list; |
472 size_t size = 10; | 472 size_t size = 10; |
473 for (size_t i = 0; i < size; ++i) { | 473 for (size_t i = 0; i < size; ++i) { |
474 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); | 474 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); |
475 } | 475 } |
476 EXPECT_EQ(size, list.size()); | 476 EXPECT_EQ(size, list.size()); |
477 | 477 |
478 size_t num_iters_in_list = 0; | 478 size_t num_iters_in_list = 0; |
479 { | 479 { |
(...skipping 15 matching lines...) Expand all Loading... |
495 EXPECT_EQ(*nde_iter, *iter); | 495 EXPECT_EQ(*nde_iter, *iter); |
496 ++num_iters_in_vector; | 496 ++num_iters_in_vector; |
497 ++iter; | 497 ++iter; |
498 } | 498 } |
499 } | 499 } |
500 | 500 |
501 EXPECT_EQ(num_iters_in_vector, num_iters_in_list); | 501 EXPECT_EQ(num_iters_in_vector, num_iters_in_list); |
502 } | 502 } |
503 | 503 |
504 TEST(ListContainerTest, SimpleConstIteratorIterationNonDerivedElement) { | 504 TEST(ListContainerTest, SimpleConstIteratorIterationNonDerivedElement) { |
505 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 505 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
506 sizeof(NonDerivedElement), 0); | 506 sizeof(NonDerivedElement), 0); |
507 std::vector<const NonDerivedElement*> nde_list; | 507 std::vector<const NonDerivedElement*> nde_list; |
508 size_t size = 10; | 508 size_t size = 10; |
509 for (size_t i = 0; i < size; ++i) { | 509 for (size_t i = 0; i < size; ++i) { |
510 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); | 510 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); |
511 } | 511 } |
512 EXPECT_EQ(size, list.size()); | 512 EXPECT_EQ(size, list.size()); |
513 | 513 |
514 { | 514 { |
515 std::vector<const NonDerivedElement*>::const_iterator nde_iter = | 515 std::vector<const NonDerivedElement*>::const_iterator nde_iter = |
(...skipping 22 matching lines...) Expand all Loading... |
538 for (std::vector<const NonDerivedElement*>::const_iterator nde_iter = | 538 for (std::vector<const NonDerivedElement*>::const_iterator nde_iter = |
539 nde_list.begin(); | 539 nde_list.begin(); |
540 nde_iter != nde_list.end(); ++nde_iter) { | 540 nde_iter != nde_list.end(); ++nde_iter) { |
541 EXPECT_EQ(*nde_iter, *iter); | 541 EXPECT_EQ(*nde_iter, *iter); |
542 ++iter; | 542 ++iter; |
543 } | 543 } |
544 } | 544 } |
545 } | 545 } |
546 | 546 |
547 TEST(ListContainerTest, SimpleReverseInsertionNonDerivedElement) { | 547 TEST(ListContainerTest, SimpleReverseInsertionNonDerivedElement) { |
548 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 548 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
549 sizeof(NonDerivedElement), 0); | 549 sizeof(NonDerivedElement), 0); |
550 std::vector<NonDerivedElement*> nde_list; | 550 std::vector<NonDerivedElement*> nde_list; |
551 size_t size = 10; | 551 size_t size = 10; |
552 for (size_t i = 0; i < size; ++i) { | 552 for (size_t i = 0; i < size; ++i) { |
553 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); | 553 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); |
554 } | 554 } |
555 EXPECT_EQ(size, list.size()); | 555 EXPECT_EQ(size, list.size()); |
556 | 556 |
557 { | 557 { |
558 std::vector<NonDerivedElement*>::const_reverse_iterator nde_iter = | 558 std::vector<NonDerivedElement*>::const_reverse_iterator nde_iter = |
(...skipping 318 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
877 int i = 0; | 877 int i = 0; |
878 for (std::vector<SimpleDerivedElement*>::const_iterator | 878 for (std::vector<SimpleDerivedElement*>::const_iterator |
879 de_iter = de_list.begin(); | 879 de_iter = de_list.begin(); |
880 de_iter != de_list.end(); ++de_iter, ++i) { | 880 de_iter != de_list.end(); ++de_iter, ++i) { |
881 EXPECT_EQ(i, (*de_iter)->get_value()); | 881 EXPECT_EQ(i, (*de_iter)->get_value()); |
882 } | 882 } |
883 } | 883 } |
884 | 884 |
885 TEST(ListContainerTest, | 885 TEST(ListContainerTest, |
886 SimpleIterationAndReverseIterationWithIndexNonDerivedElement) { | 886 SimpleIterationAndReverseIterationWithIndexNonDerivedElement) { |
887 ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement), | 887 ListContainer<NonDerivedElement> list(alignof(NonDerivedElement), |
888 sizeof(NonDerivedElement), 0); | 888 sizeof(NonDerivedElement), 0); |
889 std::vector<NonDerivedElement*> nde_list; | 889 std::vector<NonDerivedElement*> nde_list; |
890 size_t size = 10; | 890 size_t size = 10; |
891 for (size_t i = 0; i < size; ++i) { | 891 for (size_t i = 0; i < size; ++i) { |
892 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); | 892 nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>()); |
893 } | 893 } |
894 EXPECT_EQ(size, list.size()); | 894 EXPECT_EQ(size, list.size()); |
895 | 895 |
896 size_t i = 0; | 896 size_t i = 0; |
897 for (ListContainer<NonDerivedElement>::Iterator iter = list.begin(); | 897 for (ListContainer<NonDerivedElement>::Iterator iter = list.begin(); |
(...skipping 26 matching lines...) Expand all Loading... |
924 } | 924 } |
925 | 925 |
926 private: | 926 private: |
927 int* counter_; | 927 int* counter_; |
928 }; | 928 }; |
929 | 929 |
930 TEST(ListContainerTest, RemoveLastDestruction) { | 930 TEST(ListContainerTest, RemoveLastDestruction) { |
931 // We keep an explicit instance count to make sure that the destructors are | 931 // We keep an explicit instance count to make sure that the destructors are |
932 // indeed getting called. | 932 // indeed getting called. |
933 int counter = 0; | 933 int counter = 0; |
934 ListContainer<InstanceCounter> list(ALIGNOF(InstanceCounter), | 934 ListContainer<InstanceCounter> list(alignof(InstanceCounter), |
935 sizeof(InstanceCounter), 1); | 935 sizeof(InstanceCounter), 1); |
936 EXPECT_EQ(0, counter); | 936 EXPECT_EQ(0, counter); |
937 EXPECT_EQ(0u, list.size()); | 937 EXPECT_EQ(0u, list.size()); |
938 | 938 |
939 // We should be okay to add one and then go back to zero. | 939 // We should be okay to add one and then go back to zero. |
940 list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter); | 940 list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter); |
941 EXPECT_EQ(1, counter); | 941 EXPECT_EQ(1, counter); |
942 EXPECT_EQ(1u, list.size()); | 942 EXPECT_EQ(1u, list.size()); |
943 list.RemoveLast(); | 943 list.RemoveLast(); |
944 EXPECT_EQ(0, counter); | 944 EXPECT_EQ(0, counter); |
(...skipping 24 matching lines...) Expand all Loading... |
969 if (!(*it1 == *it2)) | 969 if (!(*it1 == *it2)) |
970 return false; | 970 return false; |
971 } | 971 } |
972 return true; | 972 return true; |
973 } | 973 } |
974 | 974 |
975 TEST(ListContainerTest, RemoveLastIteration) { | 975 TEST(ListContainerTest, RemoveLastIteration) { |
976 struct SmallStruct { | 976 struct SmallStruct { |
977 char dummy[16]; | 977 char dummy[16]; |
978 }; | 978 }; |
979 ListContainer<SmallStruct> list(ALIGNOF(SmallStruct), sizeof(SmallStruct), 1); | 979 ListContainer<SmallStruct> list(alignof(SmallStruct), sizeof(SmallStruct), 1); |
980 std::vector<SmallStruct*> pointers; | 980 std::vector<SmallStruct*> pointers; |
981 | 981 |
982 // Utilities which keep these two lists in sync and check that their iteration | 982 // Utilities which keep these two lists in sync and check that their iteration |
983 // order matches. | 983 // order matches. |
984 auto push = [&list, &pointers]() { | 984 auto push = [&list, &pointers]() { |
985 pointers.push_back(list.AllocateAndConstruct<SmallStruct>()); | 985 pointers.push_back(list.AllocateAndConstruct<SmallStruct>()); |
986 }; | 986 }; |
987 auto pop = [&list, &pointers]() { | 987 auto pop = [&list, &pointers]() { |
988 pointers.pop_back(); | 988 pointers.pop_back(); |
989 list.RemoveLast(); | 989 list.RemoveLast(); |
(...skipping 249 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1239 size_t capacity = list.GetCapacityInBytes(); | 1239 size_t capacity = list.GetCapacityInBytes(); |
1240 ASSERT_GE(capacity, list.size() * kLargestDerivedElementSize); | 1240 ASSERT_GE(capacity, list.size() * kLargestDerivedElementSize); |
1241 ASSERT_LE(capacity, std::max(list.size(), upper_bound_on_min_capacity) * | 1241 ASSERT_LE(capacity, std::max(list.size(), upper_bound_on_min_capacity) * |
1242 max_waste_factor * kLargestDerivedElementSize); | 1242 max_waste_factor * kLargestDerivedElementSize); |
1243 list.RemoveLast(); | 1243 list.RemoveLast(); |
1244 } | 1244 } |
1245 } | 1245 } |
1246 | 1246 |
1247 } // namespace | 1247 } // namespace |
1248 } // namespace cc | 1248 } // namespace cc |
OLD | NEW |