Blender V5.3
BLI_vector_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
6#include "BLI_vector.hh"
7#include "testing/testing.h"
8#include <forward_list>
9
10#include "BLI_strict_flags.hh" /* IWYU pragma: keep. Keep last. */
11
12namespace blender::tests {
13namespace {
14
15TEST(vector, DefaultConstructor)
16{
17 Vector<int> vec;
18 EXPECT_EQ(vec.size(), 0);
19}
20
21TEST(vector, SizeConstructor)
22{
23 Vector<int> vec(3);
24 EXPECT_EQ(vec.size(), 3);
25}
26
31TEST(vector, TrivialTypeSizeConstructor)
32{
33 Vector<char, 1> *vec = new Vector<char, 1>(1);
34 char *ptr = vec->data();
35 vec->~Vector();
36
37 const char magic = 42;
38 *ptr = magic;
39 EXPECT_EQ(*ptr, magic);
40
41 new (vec) Vector<char, 1>(1);
42 EXPECT_EQ((*vec)[0], magic);
43 EXPECT_EQ(*ptr, magic);
44 delete vec;
45}
46
47TEST(vector, SizeValueConstructor)
48{
49 Vector<int> vec(4, 10);
50 EXPECT_EQ(vec.size(), 4);
51 EXPECT_EQ(vec[0], 10);
52 EXPECT_EQ(vec[1], 10);
53 EXPECT_EQ(vec[2], 10);
54 EXPECT_EQ(vec[3], 10);
55}
56
57TEST(vector, InitializerListConstructor)
58{
59 Vector<int> vec = {1, 3, 4, 6};
60 EXPECT_EQ(vec.size(), 4);
61 EXPECT_EQ(vec[0], 1);
62 EXPECT_EQ(vec[1], 3);
63 EXPECT_EQ(vec[2], 4);
64 EXPECT_EQ(vec[3], 6);
65}
66
67TEST(vector, ConvertingConstructor)
68{
69 std::array<float, 5> values = {5.4f, 7.3f, -8.1f, 5.0f, 0.0f};
70 Vector<int> vec = values;
71 EXPECT_EQ(vec.size(), 5);
72 EXPECT_EQ(vec[0], 5);
73 EXPECT_EQ(vec[1], 7);
74 EXPECT_EQ(vec[2], -8);
75 EXPECT_EQ(vec[3], 5);
76 EXPECT_EQ(vec[4], 0);
77}
78
79struct TestListValue {
80 TestListValue *next, *prev;
81 int value;
82};
83
84// TEST(vector, ListBaseConstructor)
85// {
86// TestListValue *value1 = new TestListValue{nullptr, nullptr, 4};
87// TestListValue *value2 = new TestListValue{nullptr, nullptr, 5};
88// TestListValue *value3 = new TestListValue{nullptr, nullptr, 6};
89
90// ListBaseT<TestListValue> list = {nullptr, nullptr};
91// BLI_addtail(&list, value1);
92// BLI_addtail(&list, value2);
93// BLI_addtail(&list, value3);
94// Vector<TestListValue *> vec(list);
95
96// EXPECT_EQ(vec.size(), 3);
97// EXPECT_EQ(vec[0]->value, 4);
98// EXPECT_EQ(vec[1]->value, 5);
99// EXPECT_EQ(vec[2]->value, 6);
100
101// delete value1;
102// delete value2;
103// delete value3;
104// }
105
106TEST(vector, IteratorConstructor)
107{
108 std::forward_list<int> list;
109 list.push_front(3);
110 list.push_front(1);
111 list.push_front(5);
112
113 Vector<int> vec = Vector<int>(list.begin(), list.end());
114 EXPECT_EQ(vec.size(), 3);
115 EXPECT_EQ(vec[0], 5);
116 EXPECT_EQ(vec[1], 1);
117 EXPECT_EQ(vec[2], 3);
118}
119
120TEST(vector, CopyConstructor)
121{
122 Vector<int> vec1 = {1, 2, 3};
123 Vector<int> vec2(vec1);
124 EXPECT_EQ(vec2.size(), 3);
125 EXPECT_EQ(vec2[0], 1);
126 EXPECT_EQ(vec2[1], 2);
127 EXPECT_EQ(vec2[2], 3);
128
129 vec1[1] = 5;
130 EXPECT_EQ(vec1[1], 5);
131 EXPECT_EQ(vec2[1], 2);
132}
133
134TEST(vector, CopyConstructor2)
135{
136 Vector<int, 2> vec1 = {1, 2, 3, 4};
137 Vector<int, 3> vec2(vec1);
138
139 EXPECT_EQ(vec1.size(), 4);
140 EXPECT_EQ(vec2.size(), 4);
141 EXPECT_NE(vec1.data(), vec2.data());
142 EXPECT_EQ(vec2[0], 1);
143 EXPECT_EQ(vec2[1], 2);
144 EXPECT_EQ(vec2[2], 3);
145 EXPECT_EQ(vec2[3], 4);
146}
147
148TEST(vector, CopyConstructor3)
149{
150 Vector<int, 20> vec1 = {1, 2, 3, 4};
151 Vector<int, 1> vec2(vec1);
152
153 EXPECT_EQ(vec1.size(), 4);
154 EXPECT_EQ(vec2.size(), 4);
155 EXPECT_NE(vec1.data(), vec2.data());
156 EXPECT_EQ(vec2[2], 3);
157}
158
159TEST(vector, CopyConstructor4)
160{
161 Vector<int, 5> vec1 = {1, 2, 3, 4};
162 Vector<int, 6> vec2(vec1);
163
164 EXPECT_EQ(vec1.size(), 4);
165 EXPECT_EQ(vec2.size(), 4);
166 EXPECT_NE(vec1.data(), vec2.data());
167 EXPECT_EQ(vec2[3], 4);
168}
169
170TEST(vector, MoveConstructor)
171{
172 Vector<int> vec1 = {1, 2, 3, 4};
173 Vector<int> vec2(std::move(vec1));
174
175 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
176 EXPECT_EQ(vec2.size(), 4);
177 EXPECT_EQ(vec2[0], 1);
178 EXPECT_EQ(vec2[1], 2);
179 EXPECT_EQ(vec2[2], 3);
180 EXPECT_EQ(vec2[3], 4);
181}
182
183TEST(vector, MoveConstructor2)
184{
185 Vector<int, 2> vec1 = {1, 2, 3, 4};
186 Vector<int, 3> vec2(std::move(vec1));
187
188 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
189 EXPECT_EQ(vec2.size(), 4);
190 EXPECT_EQ(vec2[0], 1);
191 EXPECT_EQ(vec2[1], 2);
192 EXPECT_EQ(vec2[2], 3);
193 EXPECT_EQ(vec2[3], 4);
194}
195
196TEST(vector, MoveConstructor3)
197{
198 Vector<int, 20> vec1 = {1, 2, 3, 4};
199 Vector<int, 1> vec2(std::move(vec1));
200
201 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
202 EXPECT_EQ(vec2.size(), 4);
203 EXPECT_EQ(vec2[2], 3);
204}
205
206TEST(vector, MoveConstructor4)
207{
208 Vector<int, 5> vec1 = {1, 2, 3, 4};
209 Vector<int, 6> vec2(std::move(vec1));
210
211 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
212 EXPECT_EQ(vec2.size(), 4);
213 EXPECT_EQ(vec2[3], 4);
214}
215
216TEST(vector, MoveAssignment)
217{
218 Vector<int> vec = {1, 2};
219 EXPECT_EQ(vec.size(), 2);
220 EXPECT_EQ(vec[0], 1);
221 EXPECT_EQ(vec[1], 2);
222
223 vec = Vector<int>({5});
224 EXPECT_EQ(vec.size(), 1);
225 EXPECT_EQ(vec[0], 5);
226}
227
228TEST(vector, CopyAssignment)
229{
230 Vector<int> vec1 = {1, 2, 3};
231 Vector<int> vec2 = {4, 5};
232 EXPECT_EQ(vec1.size(), 3);
233 EXPECT_EQ(vec2.size(), 2);
234
235 vec2 = vec1;
236 EXPECT_EQ(vec2.size(), 3);
237
238 vec1[0] = 7;
239 EXPECT_EQ(vec1[0], 7);
240 EXPECT_EQ(vec2[0], 1);
241}
242
243TEST(vector, Append)
244{
245 Vector<int> vec;
246 vec.append(3);
247 vec.append(6);
248 vec.append(7);
249 EXPECT_EQ(vec.size(), 3);
250 EXPECT_EQ(vec[0], 3);
251 EXPECT_EQ(vec[1], 6);
252 EXPECT_EQ(vec[2], 7);
253}
254
255TEST(vector, AppendAs)
256{
257 Vector<StringRef> vec;
258 vec.append_as("hello", 2);
259 vec.append_as("world", 3);
260 EXPECT_EQ(vec[0], "he");
261 EXPECT_EQ(vec[1], "wor");
262}
263
264TEST(vector, AppendAndGetIndex)
265{
266 Vector<int> vec;
267 EXPECT_EQ(vec.append_and_get_index(10), 0);
268 EXPECT_EQ(vec.append_and_get_index(10), 1);
269 EXPECT_EQ(vec.append_and_get_index(10), 2);
270 vec.append(10);
271 int value = 10;
272 EXPECT_EQ(vec.append_and_get_index(value), 4);
273}
274
275TEST(vector, AppendNonDuplicates)
276{
277 Vector<int> vec;
278 vec.append_non_duplicates(4);
279 EXPECT_EQ(vec.size(), 1);
280 vec.append_non_duplicates(5);
281 EXPECT_EQ(vec.size(), 2);
282 vec.append_non_duplicates(4);
283 EXPECT_EQ(vec.size(), 2);
284}
285
286TEST(vector, ExtendNonDuplicates)
287{
288 Vector<int> vec;
289 vec.extend_non_duplicates({1, 2});
290 EXPECT_EQ(vec.size(), 2);
291 vec.extend_non_duplicates({3, 4});
292 EXPECT_EQ(vec.size(), 4);
293 vec.extend_non_duplicates({0, 1, 2, 3});
294 EXPECT_EQ(vec.size(), 5);
295}
296
297TEST(vector, ExtendIterator)
298{
299 Vector<int> vec = {3, 4, 5};
300 std::forward_list<int> list = {8, 9};
301 vec.extend(list.begin(), list.end());
302 EXPECT_EQ(vec.size(), 5);
303 EXPECT_EQ_SPAN<int>(vec, Span({3, 4, 5, 8, 9}));
304}
305
306TEST(vector, Iterator)
307{
308 Vector<int> vec({1, 4, 9, 16});
309 int i = 1;
310 for (int value : vec) {
311 EXPECT_EQ(value, i * i);
312 i++;
313 }
314}
315
316TEST(vector, BecomeLarge)
317{
318 Vector<int, 4> vec;
319 for (int i = 0; i < 100; i++) {
320 vec.append(i * 5);
321 }
322 EXPECT_EQ(vec.size(), 100);
323 for (int i = 0; i < 100; i++) {
324 EXPECT_EQ(vec[i], int(i * 5));
325 }
326}
327
328static Vector<int> return_by_value_helper()
329{
330 return Vector<int>({3, 5, 1});
331}
332
333TEST(vector, ReturnByValue)
334{
335 Vector<int> vec = return_by_value_helper();
336 EXPECT_EQ(vec.size(), 3);
337 EXPECT_EQ(vec[0], 3);
338 EXPECT_EQ(vec[1], 5);
339 EXPECT_EQ(vec[2], 1);
340}
341
342TEST(vector, VectorOfVectors_Append)
343{
344 Vector<Vector<int>> vec;
345 EXPECT_EQ(vec.size(), 0);
346
347 Vector<int> v({1, 2});
348 vec.append(v);
349 vec.append({7, 8});
350 EXPECT_EQ(vec.size(), 2);
351 EXPECT_EQ(vec[0][0], 1);
352 EXPECT_EQ(vec[0][1], 2);
353 EXPECT_EQ(vec[1][0], 7);
354 EXPECT_EQ(vec[1][1], 8);
355}
356
357TEST(vector, RemoveLast)
358{
359 Vector<int> vec = {5, 6};
360 EXPECT_EQ(vec.size(), 2);
361 vec.remove_last();
362 EXPECT_EQ(vec.size(), 1);
363 vec.remove_last();
364 EXPECT_EQ(vec.size(), 0);
365}
366
367TEST(vector, IsEmpty)
368{
369 Vector<int> vec;
370 EXPECT_TRUE(vec.is_empty());
371 vec.append(1);
372 EXPECT_FALSE(vec.is_empty());
373 vec.remove_last();
374 EXPECT_TRUE(vec.is_empty());
375}
376
377TEST(vector, RemoveReorder)
378{
379 Vector<int> vec = {4, 5, 6, 7};
380 vec.remove_and_reorder(1);
381 EXPECT_EQ(vec[0], 4);
382 EXPECT_EQ(vec[1], 7);
383 EXPECT_EQ(vec[2], 6);
384 vec.remove_and_reorder(2);
385 EXPECT_EQ(vec[0], 4);
386 EXPECT_EQ(vec[1], 7);
387 vec.remove_and_reorder(0);
388 EXPECT_EQ(vec[0], 7);
389 vec.remove_and_reorder(0);
390 EXPECT_TRUE(vec.is_empty());
391}
392
393TEST(vector, RemoveFirstOccurrenceAndReorder)
394{
395 Vector<int> vec = {4, 5, 6, 7};
396 vec.remove_first_occurrence_and_reorder(5);
397 EXPECT_EQ(vec[0], 4);
398 EXPECT_EQ(vec[1], 7);
399 EXPECT_EQ(vec[2], 6);
400 vec.remove_first_occurrence_and_reorder(6);
401 EXPECT_EQ(vec[0], 4);
402 EXPECT_EQ(vec[1], 7);
403 vec.remove_first_occurrence_and_reorder(4);
404 EXPECT_EQ(vec[0], 7);
405 vec.remove_first_occurrence_and_reorder(7);
406 EXPECT_EQ(vec.size(), 0);
407}
408
409TEST(vector, Remove)
410{
411 Vector<int> vec = {1, 2, 3, 4, 5, 6};
412 vec.remove(3);
413 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({1, 2, 3, 5, 6}).begin()));
414 vec.remove(0);
415 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5, 6}).begin()));
416 vec.remove(3);
417 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5}).begin()));
418 vec.remove(1);
419 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 5}).begin()));
420 vec.remove(1);
421 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2}).begin()));
422 vec.remove(0);
423 EXPECT_EQ(vec.begin(), vec.end());
424}
425
426TEST(vector, RemoveIf)
427{
428 Vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8};
429 const int64_t removed = vec.remove_if([](const int x) { return x % 2 == 0; });
430 EXPECT_EQ(vec.size() + removed, 8);
431 const Vector<int> expected_vec = {1, 3, 5, 7};
432 EXPECT_EQ(vec.size(), expected_vec.size());
433 EXPECT_EQ_SPAN<int>(vec, expected_vec);
434}
435
436TEST(vector, RemoveIfNonTrivialDestructible)
437{
438 Vector<Vector<int, 0, GuardedAllocator>> vec;
439 for ([[maybe_unused]] const int64_t i : IndexRange(10)) {
440 /* This test relies on leak detection to run after tests. */
441 vec.append(Vector<int, 0, GuardedAllocator>(100));
442 }
443 vec.remove_if([&](const auto & /*value*/) { return true; });
444 EXPECT_TRUE(vec.is_empty());
445}
446
447TEST(vector, ExtendSmallVector)
448{
449 Vector<int> a = {2, 3, 4};
450 Vector<int> b = {11, 12};
451 b.extend(a);
452 EXPECT_EQ(b.size(), 5);
453 EXPECT_EQ(b[0], 11);
454 EXPECT_EQ(b[1], 12);
455 EXPECT_EQ(b[2], 2);
456 EXPECT_EQ(b[3], 3);
457 EXPECT_EQ(b[4], 4);
458}
459
460TEST(vector, ExtendArray)
461{
462 int array[] = {3, 4, 5, 6};
463
464 Vector<int> a;
465 a.extend(array, 2);
466
467 EXPECT_EQ(a.size(), 2);
468 EXPECT_EQ(a[0], 3);
469 EXPECT_EQ(a[1], 4);
470}
471
472TEST(vector, ExtendMoveFromSmallVector)
473{
474 Vector<Vector<uint64_t, 0>> a = {
475 {1, 2, 3, 4, 5},
476 {6, 7, 8},
477 };
478 Vector<Vector<uint64_t, 0>> b = {
479 {9, 10, 11, 12},
480 {13, 14, 15, 16},
481 };
482 const Vector<Vector<uint64_t, 0>> c = {
483 {1, 2, 3, 4, 5},
484 {6, 7, 8},
485 {9, 10, 11, 12},
486 {13, 14, 15, 16},
487 };
488
489 a.extend(std::move(b));
490
491 EXPECT_EQ(a, c);
492 EXPECT_TRUE(b.is_empty());
493}
494
495TEST(vector, ExtendMoveFromUniquePtrVector)
496{
497 Vector<int *> ptr_vec;
498
499 Vector<std::unique_ptr<int>> a;
500 a.append(std::make_unique<int>(0));
501 a.append(std::make_unique<int>(1));
502 a.append(std::make_unique<int>(2));
503
504 for (std::unique_ptr<int> &i : a) {
505 ptr_vec.append(i.get());
506 }
507
508 Vector<std::unique_ptr<int>> b;
509 b.append(std::make_unique<int>(7));
510 b.append(std::make_unique<int>(8));
511 b.append(std::make_unique<int>(9));
512 b.append(std::make_unique<int>(20));
513
514 for (std::unique_ptr<int> &i : b) {
515 ptr_vec.append(i.get());
516 }
517
518 ASSERT_EQ(a.size(), 3);
519 ASSERT_EQ(b.size(), 4);
520
521 a.extend(std::move(b));
522
523 std::array<int, 7> values = {0, 1, 2, 7, 8, 9, 20};
524
525 ASSERT_EQ(size_t(a.size()), values.size());
526 ASSERT_TRUE(b.is_empty());
527 ASSERT_EQ(a.size(), ptr_vec.size());
528
529 for (int64_t i = 0; i < a.size(); i++) {
530 ASSERT_EQ(*a[i], values[size_t(i)]);
531 ASSERT_EQ(a[i].get(), ptr_vec[i]);
532 }
533}
534
535TEST(vector, Last)
536{
537 Vector<int> a{3, 5, 7};
538 EXPECT_EQ(a.last(), 7);
539 EXPECT_EQ(a.last(0), 7);
540 EXPECT_EQ(a.last(1), 5);
541 EXPECT_EQ(a.last(2), 3);
542}
543
544TEST(vector, AppendNTimes)
545{
546 Vector<int> a;
547 a.append_n_times(5, 3);
548 a.append_n_times(2, 2);
549 EXPECT_EQ(a.size(), 5);
550 EXPECT_EQ(a[0], 5);
551 EXPECT_EQ(a[1], 5);
552 EXPECT_EQ(a[2], 5);
553 EXPECT_EQ(a[3], 2);
554 EXPECT_EQ(a[4], 2);
555}
556
557TEST(vector, UniquePtrValue)
558{
559 Vector<std::unique_ptr<int>> vec;
560 vec.append(std::make_unique<int>());
561 vec.append(std::make_unique<int>());
562 vec.append(std::make_unique<int>());
563 vec.append(std::make_unique<int>());
564 EXPECT_EQ(vec.size(), 4);
565
566 std::unique_ptr<int> &a = vec.last();
567 std::unique_ptr<int> b = vec.pop_last();
568 vec.remove_and_reorder(0);
569 vec.remove(0);
570 EXPECT_EQ(vec.size(), 1);
571 EXPECT_EQ(vec.append_and_get_index(std::make_unique<int>(4)), 1);
572
573 UNUSED_VARS(a, b);
574}
575
576class TypeConstructMock {
577 public:
578 bool default_constructed = false;
579 bool copy_constructed = false;
580 bool move_constructed = false;
581 bool copy_assigned = false;
582 bool move_assigned = false;
583
584 TypeConstructMock() : default_constructed(true) {}
585
586 TypeConstructMock(const TypeConstructMock & /*other*/) : copy_constructed(true) {}
587
588 TypeConstructMock(TypeConstructMock && /*other*/) noexcept : move_constructed(true) {}
589
590 TypeConstructMock &operator=(const TypeConstructMock &other)
591 {
592 if (this == &other) {
593 return *this;
594 }
595
596 copy_assigned = true;
597 return *this;
598 }
599
600 TypeConstructMock &operator=(TypeConstructMock &&other) noexcept
601 {
602 if (this == &other) {
603 return *this;
604 }
605
606 move_assigned = true;
607 return *this;
608 }
609};
610
611TEST(vector, SizeConstructorCallsDefaultConstructor)
612{
613 Vector<TypeConstructMock> vec(3);
614 EXPECT_TRUE(vec[0].default_constructed);
615 EXPECT_TRUE(vec[1].default_constructed);
616 EXPECT_TRUE(vec[2].default_constructed);
617}
618
619TEST(vector, SizeValueConstructorCallsCopyConstructor)
620{
621 Vector<TypeConstructMock> vec(3, TypeConstructMock());
622 EXPECT_TRUE(vec[0].copy_constructed);
623 EXPECT_TRUE(vec[1].copy_constructed);
624 EXPECT_TRUE(vec[2].copy_constructed);
625}
626
627TEST(vector, AppendCallsCopyConstructor)
628{
629 Vector<TypeConstructMock> vec;
630 TypeConstructMock value;
631 vec.append(value);
632 EXPECT_TRUE(vec[0].copy_constructed);
633}
634
635TEST(vector, AppendCallsMoveConstructor)
636{
637 Vector<TypeConstructMock> vec;
638 vec.append(TypeConstructMock());
639 EXPECT_TRUE(vec[0].move_constructed);
640}
641
642TEST(vector, SmallVectorCopyCallsCopyConstructor)
643{
644 Vector<TypeConstructMock, 2> src(2);
645 Vector<TypeConstructMock, 2> dst(src);
646 EXPECT_TRUE(dst[0].copy_constructed);
647 EXPECT_TRUE(dst[1].copy_constructed);
648}
649
650TEST(vector, LargeVectorCopyCallsCopyConstructor)
651{
652 Vector<TypeConstructMock, 2> src(5);
653 Vector<TypeConstructMock, 2> dst(src);
654 EXPECT_TRUE(dst[0].copy_constructed);
655 EXPECT_TRUE(dst[1].copy_constructed);
656}
657
658TEST(vector, SmallVectorMoveCallsMoveConstructor)
659{
660 Vector<TypeConstructMock, 2> src(2);
661 Vector<TypeConstructMock, 2> dst(std::move(src));
662 EXPECT_TRUE(dst[0].move_constructed);
663 EXPECT_TRUE(dst[1].move_constructed);
664}
665
666TEST(vector, LargeVectorMoveCallsNoConstructor)
667{
668 Vector<TypeConstructMock, 2> src(5);
669 Vector<TypeConstructMock, 2> dst(std::move(src));
670
671 EXPECT_TRUE(dst[0].default_constructed);
672 EXPECT_FALSE(dst[0].move_constructed);
673 EXPECT_FALSE(dst[0].copy_constructed);
674}
675
676TEST(vector, Resize)
677{
678 std::string long_string = "012345678901234567890123456789";
679 Vector<std::string> vec;
680 EXPECT_EQ(vec.size(), 0);
681 vec.resize(2);
682 EXPECT_EQ(vec.size(), 2);
683 EXPECT_EQ(vec[0], "");
684 EXPECT_EQ(vec[1], "");
685 vec.resize(5, long_string);
686 EXPECT_EQ(vec.size(), 5);
687 EXPECT_EQ(vec[0], "");
688 EXPECT_EQ(vec[1], "");
689 EXPECT_EQ(vec[2], long_string);
690 EXPECT_EQ(vec[3], long_string);
691 EXPECT_EQ(vec[4], long_string);
692 vec.resize(1);
693 EXPECT_EQ(vec.size(), 1);
694 EXPECT_EQ(vec[0], "");
695}
696
697TEST(vector, FirstIndexOf)
698{
699 Vector<int> vec = {2, 3, 5, 7, 5, 9};
700 EXPECT_EQ(vec.first_index_of(2), 0);
701 EXPECT_EQ(vec.first_index_of(5), 2);
702 EXPECT_EQ(vec.first_index_of(9), 5);
703}
704
705TEST(vector, FirstIndexTryOf)
706{
707 Vector<int> vec = {2, 3, 5, 7, 5, 9};
708 EXPECT_EQ(vec.first_index_of_try(2), 0);
709 EXPECT_EQ(vec.first_index_of_try(4), -1);
710 EXPECT_EQ(vec.first_index_of_try(5), 2);
711 EXPECT_EQ(vec.first_index_of_try(9), 5);
712 EXPECT_EQ(vec.first_index_of_try(1), -1);
713}
714
715TEST(vector, OveralignedValues)
716{
717 Vector<AlignedBuffer<1, 512>, 2> vec;
718 for (int i = 0; i < 100; i++) {
719 vec.append({});
720 EXPECT_EQ(uintptr_t(&vec.last()) % 512, 0);
721 }
722}
723
724TEST(vector, ConstructVoidPointerVector)
725{
726 int a;
727 float b;
728 double c;
729 Vector<void *> vec = {&a, &b, &c};
730 EXPECT_EQ(vec.size(), 3);
731}
732
733TEST(vector, Fill)
734{
735 Vector<int> vec(5);
736 vec.fill(3);
737 EXPECT_EQ(vec.size(), 5u);
738 EXPECT_EQ(vec[0], 3);
739 EXPECT_EQ(vec[1], 3);
740 EXPECT_EQ(vec[2], 3);
741 EXPECT_EQ(vec[3], 3);
742 EXPECT_EQ(vec[4], 3);
743}
744
745TEST(vector, InsertAtBeginning)
746{
747 Vector<int> vec = {1, 2, 3};
748 vec.insert(0, {6, 7});
749 EXPECT_EQ(vec.size(), 5);
750 EXPECT_EQ_SPAN<int>(vec, Span({6, 7, 1, 2, 3}));
751}
752
753TEST(vector, InsertAtEnd)
754{
755 Vector<int> vec = {1, 2, 3};
756 vec.insert(3, {6, 7});
757 EXPECT_EQ(vec.size(), 5);
758 EXPECT_EQ_SPAN<int>(vec, Span({1, 2, 3, 6, 7}));
759}
760
761TEST(vector, InsertInMiddle)
762{
763 Vector<int> vec = {1, 2, 3};
764 vec.insert(1, {6, 7});
765 EXPECT_EQ(vec.size(), 5);
766 EXPECT_EQ_SPAN<int>(vec, Span({1, 6, 7, 2, 3}));
767}
768
769TEST(vector, InsertAtIterator)
770{
771 Vector<std::string> vec = {"1", "2", "3"};
772 Vector<std::string> other_vec = {"hello", "world"};
773 vec.insert(vec.begin() + 1, other_vec.begin(), other_vec.end());
774 EXPECT_EQ(vec.size(), 5);
775 EXPECT_EQ_SPAN<std::string>(vec, Span<std::string>({"1", "hello", "world", "2", "3"}));
776}
777
778TEST(vector, InsertMoveOnlyType)
779{
780 Vector<std::unique_ptr<int>> vec;
781 vec.append(std::make_unique<int>(1));
782 vec.append(std::make_unique<int>(2));
783 vec.insert(1, std::make_unique<int>(30));
784 EXPECT_EQ(vec.size(), 3);
785 EXPECT_EQ(*vec[0], 1);
786 EXPECT_EQ(*vec[1], 30);
787 EXPECT_EQ(*vec[2], 2);
788}
789
790TEST(vector, Prepend)
791{
792 Vector<int> vec = {1, 2, 3};
793 vec.prepend({7, 8});
794 EXPECT_EQ(vec.size(), 5);
795 EXPECT_EQ_SPAN<int>(vec, Span({7, 8, 1, 2, 3}));
796}
797
798TEST(vector, PrependString)
799{
800 std::string s = "test";
801 Vector<std::string> vec;
802 vec.prepend(s);
803 vec.prepend(std::move(s));
804 EXPECT_EQ(vec.size(), 2);
805 EXPECT_EQ(vec[0], "test");
806 EXPECT_EQ(vec[1], "test");
807}
808
809TEST(vector, ReverseIterator)
810{
811 Vector<int> vec = {4, 5, 6, 7};
812 Vector<int> reversed_vec;
813 for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
814 reversed_vec.append(*it);
815 }
816 EXPECT_EQ(reversed_vec.size(), 4);
817 EXPECT_EQ_SPAN<int>(reversed_vec, Span({7, 6, 5, 4}));
818}
819
820TEST(vector, SizeValueConstructorExceptions)
821{
822 ExceptionThrower value;
823 value.throw_during_copy = true;
824 EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(5, value); });
825}
826
827TEST(vector, SpanConstructorExceptions)
828{
829 std::array<ExceptionThrower, 5> values;
830 values[3].throw_during_copy = true;
831 EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(values); });
832}
833
834TEST(vector, MoveConstructorExceptions)
835{
836 Vector<ExceptionThrower, 4> vec(3);
837 vec[2].throw_during_move = true;
838 EXPECT_ANY_THROW({ Vector<ExceptionThrower> moved_vector{std::move(vec)}; });
839}
840
841TEST(vector, AppendExceptions)
842{
843 Vector<ExceptionThrower, 4> vec(2);
844 ExceptionThrower *ptr1 = &vec.last();
845 ExceptionThrower value;
846 value.throw_during_copy = true;
847 EXPECT_ANY_THROW({ vec.append(value); });
848 EXPECT_EQ(vec.size(), 2);
849 ExceptionThrower *ptr2 = &vec.last();
850 EXPECT_EQ(ptr1, ptr2);
851}
852
853TEST(vector, ExtendExceptions)
854{
855 Vector<ExceptionThrower> vec(5);
856 std::array<ExceptionThrower, 10> values;
857 values[6].throw_during_copy = true;
858 EXPECT_ANY_THROW({ vec.extend(values); });
859 EXPECT_EQ(vec.size(), 5);
860}
861
862TEST(vector, Insert1Exceptions)
863{
864 Vector<ExceptionThrower> vec(10);
865 std::array<ExceptionThrower, 5> values;
866 values[3].throw_during_copy = true;
867 EXPECT_ANY_THROW({ vec.insert(7, values); });
868}
869
870TEST(vector, Insert2Exceptions)
871{
872 Vector<ExceptionThrower> vec(10);
873 vec.reserve(100);
874 vec[8].throw_during_move = true;
875 std::array<ExceptionThrower, 5> values;
876 EXPECT_ANY_THROW({ vec.insert(3, values); });
877}
878
879TEST(vector, PopLastExceptions)
880{
881 Vector<ExceptionThrower> vec(10);
882 vec.last().throw_during_move = true;
883 EXPECT_ANY_THROW({ vec.pop_last(); }); /* NOLINT: bugprone-throw-keyword-missing */
884 EXPECT_EQ(vec.size(), 10);
885}
886
887TEST(vector, RemoveAndReorderExceptions)
888{
889 Vector<ExceptionThrower> vec(10);
890 vec.last().throw_during_move = true;
891 EXPECT_ANY_THROW({ vec.remove_and_reorder(3); });
892 EXPECT_EQ(vec.size(), 10);
893}
894
895TEST(vector, RemoveExceptions)
896{
897 Vector<ExceptionThrower> vec(10);
898 vec[8].throw_during_move = true;
899 EXPECT_ANY_THROW({ vec.remove(2); });
900 EXPECT_EQ(vec.size(), 10);
901}
902
903TEST(vector, RemoveChunk)
904{
905 Vector<int> vec = {2, 3, 4, 5, 6, 7, 8};
906 EXPECT_EQ(vec.size(), 7);
907 vec.remove(2, 4);
908 EXPECT_EQ(vec.size(), 3);
909 EXPECT_EQ(vec[0], 2);
910 EXPECT_EQ(vec[1], 3);
911 EXPECT_EQ(vec[2], 8);
912 vec.remove(0, 1);
913 EXPECT_EQ(vec.size(), 2);
914 EXPECT_EQ(vec[0], 3);
915 EXPECT_EQ(vec[1], 8);
916 vec.remove(1, 1);
917 EXPECT_EQ(vec.size(), 1);
918 EXPECT_EQ(vec[0], 3);
919 vec.remove(0, 1);
920 EXPECT_EQ(vec.size(), 0);
921 vec.remove(0, 0);
922 EXPECT_EQ(vec.size(), 0);
923}
924
925TEST(vector, RemoveChunkExceptions)
926{
927 Vector<ExceptionThrower> vec(10);
928 vec.remove(1, 3);
929 EXPECT_EQ(vec.size(), 7);
930 vec[5].throw_during_move = true;
931 EXPECT_ANY_THROW({ vec.remove(2, 3); });
932 EXPECT_EQ(vec.size(), 7);
933}
934
935struct RecursiveType {
936 Vector<RecursiveType, 0> my_vector;
937};
938
939TEST(vector, RecursiveStructure)
940{
941 RecursiveType my_recursive_type;
942 my_recursive_type.my_vector.append({});
943}
944
945TEST(vector, FromRaw)
946{
947 VectorData<int, GuardedAllocator> data;
948 data.data = MEM_new_array_zeroed<int>(30, __func__);
949 data.size = 10;
950 data.capacity = 30;
951
952 data.data[0] = 5;
953
954 Vector<int> vec{data};
955 EXPECT_EQ(vec.size(), 10);
956 EXPECT_EQ(vec.capacity(), 30);
957 EXPECT_EQ(vec[0], 5);
958}
959
960TEST(vector, FromRawEmpty)
961{
962 VectorData<int, GuardedAllocator> data;
963 Vector<int> vec{data};
964 EXPECT_TRUE(vec.is_empty());
965}
966
967TEST(vector, ReleaseEmptyInline)
968{
969 Vector<int> vec;
970 VectorData<int, GuardedAllocator> data = vec.release();
971 EXPECT_EQ(data.data, nullptr);
972}
973
974TEST(vector, ReleaseEmptyAllocated)
975{
976 Vector<int> vec;
977 vec.reserve(100);
978 const int *data_ptr = vec.data();
979 EXPECT_FALSE(vec.is_inline());
980
981 VectorData<int, GuardedAllocator> data = vec.release();
982 EXPECT_TRUE(vec.is_inline());
983
984 EXPECT_EQ(data.data, data_ptr);
985 EXPECT_NE(data.data, nullptr);
986 EXPECT_EQ(data.size, 0);
987 EXPECT_EQ(data.capacity, 100);
988 MEM_delete(data.data);
989}
990
991TEST(vector, ReleaseNonEmptyInline)
992{
993 Vector<int> vec = {1, 2};
994 const int *inline_data_ptr = vec.data();
995 EXPECT_EQ(inline_data_ptr[0], 1);
996 EXPECT_TRUE(vec.is_inline());
997
998 VectorData<int, GuardedAllocator> data = vec.release();
999 EXPECT_TRUE(vec.is_inline());
1000 EXPECT_TRUE(vec.is_empty());
1001
1002 EXPECT_NE(data.data, inline_data_ptr);
1003 EXPECT_EQ(data.size, 2);
1004 MEM_delete(data.data);
1005}
1006
1007TEST(vector, ReleaseAllocated)
1008{
1009 Vector<int> vec(50, 3);
1010 const int *data_ptr = vec.data();
1011 EXPECT_FALSE(vec.is_inline());
1012 EXPECT_EQ(vec[0], 3);
1013
1014 VectorData<int, GuardedAllocator> data = vec.release();
1015 EXPECT_TRUE(vec.is_inline());
1016 EXPECT_TRUE(vec.is_empty());
1017
1018 EXPECT_EQ(data.data, data_ptr);
1019 EXPECT_EQ(data.size, 50);
1020 EXPECT_EQ(data.data[0], 3);
1021 MEM_delete(data.data);
1022}
1023
1024} // namespace
1025} // namespace blender::tests
#define UNUSED_VARS(...)
btGeneric6DofConstraint & operator=(btGeneric6DofConstraint &other)
constexpr IndexRange()=default
constexpr Span()=default
friend class Vector
#define EXPECT_FALSE(result)
#define EXPECT_NE(result, expect)
#define EXPECT_TRUE(result)
#define EXPECT_EQ(result, expect)
std::shared_ptr< const T > get(const GenericKey &key, FunctionRef< std::unique_ptr< T >()> compute_fn)
TEST(any_virtual, DefaultConstructor)
__int64 int64_t
Definition BKE_text.h:90
ATTR_WARN_UNUSED_RESULT const BMVert * v
BMesh const char void * data
_W64 unsigned int uintptr_t
Definition BKE_text.h:120
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1