1 /* Apache License, Version 2.0 */
2
3 #include "BLI_exception_safety_test_utils.hh"
4 #include "BLI_strict_flags.h"
5 #include "BLI_vector.hh"
6 #include "testing/testing.h"
7 #include <forward_list>
8
9 namespace blender::tests {
10
TEST(vector,DefaultConstructor)11 TEST(vector, DefaultConstructor)
12 {
13 Vector<int> vec;
14 EXPECT_EQ(vec.size(), 0);
15 }
16
TEST(vector,SizeConstructor)17 TEST(vector, SizeConstructor)
18 {
19 Vector<int> vec(3);
20 EXPECT_EQ(vec.size(), 3);
21 }
22
23 /**
24 * Tests that the trivially constructible types are not zero-initialized. We do not want that for
25 * performance reasons.
26 */
TEST(vector,TrivialTypeSizeConstructor)27 TEST(vector, TrivialTypeSizeConstructor)
28 {
29 Vector<char, 1> *vec = new Vector<char, 1>(1);
30 char *ptr = &(*vec)[0];
31 vec->~Vector();
32
33 const char magic = 42;
34 *ptr = magic;
35 EXPECT_EQ(*ptr, magic);
36
37 new (vec) Vector<char, 1>(1);
38 EXPECT_EQ((*vec)[0], magic);
39 EXPECT_EQ(*ptr, magic);
40 delete vec;
41 }
42
TEST(vector,SizeValueConstructor)43 TEST(vector, SizeValueConstructor)
44 {
45 Vector<int> vec(4, 10);
46 EXPECT_EQ(vec.size(), 4);
47 EXPECT_EQ(vec[0], 10);
48 EXPECT_EQ(vec[1], 10);
49 EXPECT_EQ(vec[2], 10);
50 EXPECT_EQ(vec[3], 10);
51 }
52
TEST(vector,InitializerListConstructor)53 TEST(vector, InitializerListConstructor)
54 {
55 Vector<int> vec = {1, 3, 4, 6};
56 EXPECT_EQ(vec.size(), 4);
57 EXPECT_EQ(vec[0], 1);
58 EXPECT_EQ(vec[1], 3);
59 EXPECT_EQ(vec[2], 4);
60 EXPECT_EQ(vec[3], 6);
61 }
62
TEST(vector,ConvertingConstructor)63 TEST(vector, ConvertingConstructor)
64 {
65 std::array<float, 5> values = {5.4f, 7.3f, -8.1f, 5.0f, 0.0f};
66 Vector<int> vec = values;
67 EXPECT_EQ(vec.size(), 5);
68 EXPECT_EQ(vec[0], 5);
69 EXPECT_EQ(vec[1], 7);
70 EXPECT_EQ(vec[2], -8);
71 EXPECT_EQ(vec[3], 5);
72 EXPECT_EQ(vec[4], 0);
73 }
74
75 struct TestListValue {
76 TestListValue *next, *prev;
77 int value;
78 };
79
TEST(vector,ListBaseConstructor)80 TEST(vector, ListBaseConstructor)
81 {
82 TestListValue *value1 = new TestListValue{0, 0, 4};
83 TestListValue *value2 = new TestListValue{0, 0, 5};
84 TestListValue *value3 = new TestListValue{0, 0, 6};
85
86 ListBase list = {NULL, NULL};
87 BLI_addtail(&list, value1);
88 BLI_addtail(&list, value2);
89 BLI_addtail(&list, value3);
90 Vector<TestListValue *> vec(list);
91
92 EXPECT_EQ(vec.size(), 3);
93 EXPECT_EQ(vec[0]->value, 4);
94 EXPECT_EQ(vec[1]->value, 5);
95 EXPECT_EQ(vec[2]->value, 6);
96
97 delete value1;
98 delete value2;
99 delete value3;
100 }
101
TEST(vector,IteratorConstructor)102 TEST(vector, IteratorConstructor)
103 {
104 std::forward_list<int> list;
105 list.push_front(3);
106 list.push_front(1);
107 list.push_front(5);
108
109 Vector<int> vec = Vector<int>(list.begin(), list.end());
110 EXPECT_EQ(vec.size(), 3);
111 EXPECT_EQ(vec[0], 5);
112 EXPECT_EQ(vec[1], 1);
113 EXPECT_EQ(vec[2], 3);
114 }
115
TEST(vector,CopyConstructor)116 TEST(vector, CopyConstructor)
117 {
118 Vector<int> vec1 = {1, 2, 3};
119 Vector<int> vec2(vec1);
120 EXPECT_EQ(vec2.size(), 3);
121 EXPECT_EQ(vec2[0], 1);
122 EXPECT_EQ(vec2[1], 2);
123 EXPECT_EQ(vec2[2], 3);
124
125 vec1[1] = 5;
126 EXPECT_EQ(vec1[1], 5);
127 EXPECT_EQ(vec2[1], 2);
128 }
129
TEST(vector,CopyConstructor2)130 TEST(vector, CopyConstructor2)
131 {
132 Vector<int, 2> vec1 = {1, 2, 3, 4};
133 Vector<int, 3> vec2(vec1);
134
135 EXPECT_EQ(vec1.size(), 4);
136 EXPECT_EQ(vec2.size(), 4);
137 EXPECT_NE(vec1.data(), vec2.data());
138 EXPECT_EQ(vec2[0], 1);
139 EXPECT_EQ(vec2[1], 2);
140 EXPECT_EQ(vec2[2], 3);
141 EXPECT_EQ(vec2[3], 4);
142 }
143
TEST(vector,CopyConstructor3)144 TEST(vector, CopyConstructor3)
145 {
146 Vector<int, 20> vec1 = {1, 2, 3, 4};
147 Vector<int, 1> vec2(vec1);
148
149 EXPECT_EQ(vec1.size(), 4);
150 EXPECT_EQ(vec2.size(), 4);
151 EXPECT_NE(vec1.data(), vec2.data());
152 EXPECT_EQ(vec2[2], 3);
153 }
154
TEST(vector,CopyConstructor4)155 TEST(vector, CopyConstructor4)
156 {
157 Vector<int, 5> vec1 = {1, 2, 3, 4};
158 Vector<int, 6> vec2(vec1);
159
160 EXPECT_EQ(vec1.size(), 4);
161 EXPECT_EQ(vec2.size(), 4);
162 EXPECT_NE(vec1.data(), vec2.data());
163 EXPECT_EQ(vec2[3], 4);
164 }
165
TEST(vector,MoveConstructor)166 TEST(vector, MoveConstructor)
167 {
168 Vector<int> vec1 = {1, 2, 3, 4};
169 Vector<int> vec2(std::move(vec1));
170
171 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
172 EXPECT_EQ(vec2.size(), 4);
173 EXPECT_EQ(vec2[0], 1);
174 EXPECT_EQ(vec2[1], 2);
175 EXPECT_EQ(vec2[2], 3);
176 EXPECT_EQ(vec2[3], 4);
177 }
178
TEST(vector,MoveConstructor2)179 TEST(vector, MoveConstructor2)
180 {
181 Vector<int, 2> vec1 = {1, 2, 3, 4};
182 Vector<int, 3> vec2(std::move(vec1));
183
184 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
185 EXPECT_EQ(vec2.size(), 4);
186 EXPECT_EQ(vec2[0], 1);
187 EXPECT_EQ(vec2[1], 2);
188 EXPECT_EQ(vec2[2], 3);
189 EXPECT_EQ(vec2[3], 4);
190 }
191
TEST(vector,MoveConstructor3)192 TEST(vector, MoveConstructor3)
193 {
194 Vector<int, 20> vec1 = {1, 2, 3, 4};
195 Vector<int, 1> vec2(std::move(vec1));
196
197 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
198 EXPECT_EQ(vec2.size(), 4);
199 EXPECT_EQ(vec2[2], 3);
200 }
201
TEST(vector,MoveConstructor4)202 TEST(vector, MoveConstructor4)
203 {
204 Vector<int, 5> vec1 = {1, 2, 3, 4};
205 Vector<int, 6> vec2(std::move(vec1));
206
207 EXPECT_EQ(vec1.size(), 0); /* NOLINT: bugprone-use-after-move */
208 EXPECT_EQ(vec2.size(), 4);
209 EXPECT_EQ(vec2[3], 4);
210 }
211
TEST(vector,MoveAssignment)212 TEST(vector, MoveAssignment)
213 {
214 Vector<int> vec = {1, 2};
215 EXPECT_EQ(vec.size(), 2);
216 EXPECT_EQ(vec[0], 1);
217 EXPECT_EQ(vec[1], 2);
218
219 vec = Vector<int>({5});
220 EXPECT_EQ(vec.size(), 1);
221 EXPECT_EQ(vec[0], 5);
222 }
223
TEST(vector,CopyAssignment)224 TEST(vector, CopyAssignment)
225 {
226 Vector<int> vec1 = {1, 2, 3};
227 Vector<int> vec2 = {4, 5};
228 EXPECT_EQ(vec1.size(), 3);
229 EXPECT_EQ(vec2.size(), 2);
230
231 vec2 = vec1;
232 EXPECT_EQ(vec2.size(), 3);
233
234 vec1[0] = 7;
235 EXPECT_EQ(vec1[0], 7);
236 EXPECT_EQ(vec2[0], 1);
237 }
238
TEST(vector,Append)239 TEST(vector, Append)
240 {
241 Vector<int> vec;
242 vec.append(3);
243 vec.append(6);
244 vec.append(7);
245 EXPECT_EQ(vec.size(), 3);
246 EXPECT_EQ(vec[0], 3);
247 EXPECT_EQ(vec[1], 6);
248 EXPECT_EQ(vec[2], 7);
249 }
250
TEST(vector,AppendAndGetIndex)251 TEST(vector, AppendAndGetIndex)
252 {
253 Vector<int> vec;
254 EXPECT_EQ(vec.append_and_get_index(10), 0);
255 EXPECT_EQ(vec.append_and_get_index(10), 1);
256 EXPECT_EQ(vec.append_and_get_index(10), 2);
257 vec.append(10);
258 EXPECT_EQ(vec.append_and_get_index(10), 4);
259 }
260
TEST(vector,AppendNonDuplicates)261 TEST(vector, AppendNonDuplicates)
262 {
263 Vector<int> vec;
264 vec.append_non_duplicates(4);
265 EXPECT_EQ(vec.size(), 1);
266 vec.append_non_duplicates(5);
267 EXPECT_EQ(vec.size(), 2);
268 vec.append_non_duplicates(4);
269 EXPECT_EQ(vec.size(), 2);
270 }
271
TEST(vector,ExtendNonDuplicates)272 TEST(vector, ExtendNonDuplicates)
273 {
274 Vector<int> vec;
275 vec.extend_non_duplicates({1, 2});
276 EXPECT_EQ(vec.size(), 2);
277 vec.extend_non_duplicates({3, 4});
278 EXPECT_EQ(vec.size(), 4);
279 vec.extend_non_duplicates({0, 1, 2, 3});
280 EXPECT_EQ(vec.size(), 5);
281 }
282
TEST(vector,ExtendIterator)283 TEST(vector, ExtendIterator)
284 {
285 Vector<int> vec = {3, 4, 5};
286 std::forward_list<int> list = {8, 9};
287 vec.extend(list.begin(), list.end());
288 EXPECT_EQ(vec.size(), 5);
289 EXPECT_EQ_ARRAY(vec.data(), Span({3, 4, 5, 8, 9}).data(), 5);
290 }
291
TEST(vector,Iterator)292 TEST(vector, Iterator)
293 {
294 Vector<int> vec({1, 4, 9, 16});
295 int i = 1;
296 for (int value : vec) {
297 EXPECT_EQ(value, i * i);
298 i++;
299 }
300 }
301
TEST(vector,BecomeLarge)302 TEST(vector, BecomeLarge)
303 {
304 Vector<int, 4> vec;
305 for (int i = 0; i < 100; i++) {
306 vec.append(i * 5);
307 }
308 EXPECT_EQ(vec.size(), 100);
309 for (int i = 0; i < 100; i++) {
310 EXPECT_EQ(vec[i], static_cast<int>(i * 5));
311 }
312 }
313
return_by_value_helper()314 static Vector<int> return_by_value_helper()
315 {
316 return Vector<int>({3, 5, 1});
317 }
318
TEST(vector,ReturnByValue)319 TEST(vector, ReturnByValue)
320 {
321 Vector<int> vec = return_by_value_helper();
322 EXPECT_EQ(vec.size(), 3);
323 EXPECT_EQ(vec[0], 3);
324 EXPECT_EQ(vec[1], 5);
325 EXPECT_EQ(vec[2], 1);
326 }
327
TEST(vector,VectorOfVectors_Append)328 TEST(vector, VectorOfVectors_Append)
329 {
330 Vector<Vector<int>> vec;
331 EXPECT_EQ(vec.size(), 0);
332
333 Vector<int> v({1, 2});
334 vec.append(v);
335 vec.append({7, 8});
336 EXPECT_EQ(vec.size(), 2);
337 EXPECT_EQ(vec[0][0], 1);
338 EXPECT_EQ(vec[0][1], 2);
339 EXPECT_EQ(vec[1][0], 7);
340 EXPECT_EQ(vec[1][1], 8);
341 }
342
TEST(vector,RemoveLast)343 TEST(vector, RemoveLast)
344 {
345 Vector<int> vec = {5, 6};
346 EXPECT_EQ(vec.size(), 2);
347 vec.remove_last();
348 EXPECT_EQ(vec.size(), 1);
349 vec.remove_last();
350 EXPECT_EQ(vec.size(), 0);
351 }
352
TEST(vector,IsEmpty)353 TEST(vector, IsEmpty)
354 {
355 Vector<int> vec;
356 EXPECT_TRUE(vec.is_empty());
357 vec.append(1);
358 EXPECT_FALSE(vec.is_empty());
359 vec.remove_last();
360 EXPECT_TRUE(vec.is_empty());
361 }
362
TEST(vector,RemoveReorder)363 TEST(vector, RemoveReorder)
364 {
365 Vector<int> vec = {4, 5, 6, 7};
366 vec.remove_and_reorder(1);
367 EXPECT_EQ(vec[0], 4);
368 EXPECT_EQ(vec[1], 7);
369 EXPECT_EQ(vec[2], 6);
370 vec.remove_and_reorder(2);
371 EXPECT_EQ(vec[0], 4);
372 EXPECT_EQ(vec[1], 7);
373 vec.remove_and_reorder(0);
374 EXPECT_EQ(vec[0], 7);
375 vec.remove_and_reorder(0);
376 EXPECT_TRUE(vec.is_empty());
377 }
378
TEST(vector,RemoveFirstOccurrenceAndReorder)379 TEST(vector, RemoveFirstOccurrenceAndReorder)
380 {
381 Vector<int> vec = {4, 5, 6, 7};
382 vec.remove_first_occurrence_and_reorder(5);
383 EXPECT_EQ(vec[0], 4);
384 EXPECT_EQ(vec[1], 7);
385 EXPECT_EQ(vec[2], 6);
386 vec.remove_first_occurrence_and_reorder(6);
387 EXPECT_EQ(vec[0], 4);
388 EXPECT_EQ(vec[1], 7);
389 vec.remove_first_occurrence_and_reorder(4);
390 EXPECT_EQ(vec[0], 7);
391 vec.remove_first_occurrence_and_reorder(7);
392 EXPECT_EQ(vec.size(), 0);
393 }
394
TEST(vector,Remove)395 TEST(vector, Remove)
396 {
397 Vector<int> vec = {1, 2, 3, 4, 5, 6};
398 vec.remove(3);
399 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({1, 2, 3, 5, 6}).begin()));
400 vec.remove(0);
401 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5, 6}).begin()));
402 vec.remove(3);
403 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5}).begin()));
404 vec.remove(1);
405 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 5}).begin()));
406 vec.remove(1);
407 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2}).begin()));
408 vec.remove(0);
409 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({}).begin()));
410 }
411
TEST(vector,ExtendSmallVector)412 TEST(vector, ExtendSmallVector)
413 {
414 Vector<int> a = {2, 3, 4};
415 Vector<int> b = {11, 12};
416 b.extend(a);
417 EXPECT_EQ(b.size(), 5);
418 EXPECT_EQ(b[0], 11);
419 EXPECT_EQ(b[1], 12);
420 EXPECT_EQ(b[2], 2);
421 EXPECT_EQ(b[3], 3);
422 EXPECT_EQ(b[4], 4);
423 }
424
TEST(vector,ExtendArray)425 TEST(vector, ExtendArray)
426 {
427 int array[] = {3, 4, 5, 6};
428
429 Vector<int> a;
430 a.extend(array, 2);
431
432 EXPECT_EQ(a.size(), 2);
433 EXPECT_EQ(a[0], 3);
434 EXPECT_EQ(a[1], 4);
435 }
436
TEST(vector,Last)437 TEST(vector, Last)
438 {
439 Vector<int> a{3, 5, 7};
440 EXPECT_EQ(a.last(), 7);
441 }
442
TEST(vector,AppendNTimes)443 TEST(vector, AppendNTimes)
444 {
445 Vector<int> a;
446 a.append_n_times(5, 3);
447 a.append_n_times(2, 2);
448 EXPECT_EQ(a.size(), 5);
449 EXPECT_EQ(a[0], 5);
450 EXPECT_EQ(a[1], 5);
451 EXPECT_EQ(a[2], 5);
452 EXPECT_EQ(a[3], 2);
453 EXPECT_EQ(a[4], 2);
454 }
455
TEST(vector,UniquePtrValue)456 TEST(vector, UniquePtrValue)
457 {
458 Vector<std::unique_ptr<int>> vec;
459 vec.append(std::unique_ptr<int>(new int()));
460 vec.append(std::unique_ptr<int>(new int()));
461 vec.append(std::unique_ptr<int>(new int()));
462 vec.append(std::unique_ptr<int>(new int()));
463 EXPECT_EQ(vec.size(), 4);
464
465 std::unique_ptr<int> &a = vec.last();
466 std::unique_ptr<int> b = vec.pop_last();
467 vec.remove_and_reorder(0);
468 vec.remove(0);
469 EXPECT_EQ(vec.size(), 1);
470
471 UNUSED_VARS(a, b);
472 }
473
474 class TypeConstructMock {
475 public:
476 bool default_constructed = false;
477 bool copy_constructed = false;
478 bool move_constructed = false;
479 bool copy_assigned = false;
480 bool move_assigned = false;
481
TypeConstructMock()482 TypeConstructMock() : default_constructed(true)
483 {
484 }
485
TypeConstructMock(const TypeConstructMock & UNUSED (other))486 TypeConstructMock(const TypeConstructMock &UNUSED(other)) : copy_constructed(true)
487 {
488 }
489
TypeConstructMock(TypeConstructMock && UNUSED (other))490 TypeConstructMock(TypeConstructMock &&UNUSED(other)) noexcept : move_constructed(true)
491 {
492 }
493
operator =(const TypeConstructMock & other)494 TypeConstructMock &operator=(const TypeConstructMock &other)
495 {
496 if (this == &other) {
497 return *this;
498 }
499
500 copy_assigned = true;
501 return *this;
502 }
503
operator =(TypeConstructMock && other)504 TypeConstructMock &operator=(TypeConstructMock &&other) noexcept
505 {
506 if (this == &other) {
507 return *this;
508 }
509
510 move_assigned = true;
511 return *this;
512 }
513 };
514
TEST(vector,SizeConstructorCallsDefaultConstructor)515 TEST(vector, SizeConstructorCallsDefaultConstructor)
516 {
517 Vector<TypeConstructMock> vec(3);
518 EXPECT_TRUE(vec[0].default_constructed);
519 EXPECT_TRUE(vec[1].default_constructed);
520 EXPECT_TRUE(vec[2].default_constructed);
521 }
522
TEST(vector,SizeValueConstructorCallsCopyConstructor)523 TEST(vector, SizeValueConstructorCallsCopyConstructor)
524 {
525 Vector<TypeConstructMock> vec(3, TypeConstructMock());
526 EXPECT_TRUE(vec[0].copy_constructed);
527 EXPECT_TRUE(vec[1].copy_constructed);
528 EXPECT_TRUE(vec[2].copy_constructed);
529 }
530
TEST(vector,AppendCallsCopyConstructor)531 TEST(vector, AppendCallsCopyConstructor)
532 {
533 Vector<TypeConstructMock> vec;
534 TypeConstructMock value;
535 vec.append(value);
536 EXPECT_TRUE(vec[0].copy_constructed);
537 }
538
TEST(vector,AppendCallsMoveConstructor)539 TEST(vector, AppendCallsMoveConstructor)
540 {
541 Vector<TypeConstructMock> vec;
542 vec.append(TypeConstructMock());
543 EXPECT_TRUE(vec[0].move_constructed);
544 }
545
TEST(vector,SmallVectorCopyCallsCopyConstructor)546 TEST(vector, SmallVectorCopyCallsCopyConstructor)
547 {
548 Vector<TypeConstructMock, 2> src(2);
549 Vector<TypeConstructMock, 2> dst(src);
550 EXPECT_TRUE(dst[0].copy_constructed);
551 EXPECT_TRUE(dst[1].copy_constructed);
552 }
553
TEST(vector,LargeVectorCopyCallsCopyConstructor)554 TEST(vector, LargeVectorCopyCallsCopyConstructor)
555 {
556 Vector<TypeConstructMock, 2> src(5);
557 Vector<TypeConstructMock, 2> dst(src);
558 EXPECT_TRUE(dst[0].copy_constructed);
559 EXPECT_TRUE(dst[1].copy_constructed);
560 }
561
TEST(vector,SmallVectorMoveCallsMoveConstructor)562 TEST(vector, SmallVectorMoveCallsMoveConstructor)
563 {
564 Vector<TypeConstructMock, 2> src(2);
565 Vector<TypeConstructMock, 2> dst(std::move(src));
566 EXPECT_TRUE(dst[0].move_constructed);
567 EXPECT_TRUE(dst[1].move_constructed);
568 }
569
TEST(vector,LargeVectorMoveCallsNoConstructor)570 TEST(vector, LargeVectorMoveCallsNoConstructor)
571 {
572 Vector<TypeConstructMock, 2> src(5);
573 Vector<TypeConstructMock, 2> dst(std::move(src));
574
575 EXPECT_TRUE(dst[0].default_constructed);
576 EXPECT_FALSE(dst[0].move_constructed);
577 EXPECT_FALSE(dst[0].copy_constructed);
578 }
579
TEST(vector,Resize)580 TEST(vector, Resize)
581 {
582 std::string long_string = "012345678901234567890123456789";
583 Vector<std::string> vec;
584 EXPECT_EQ(vec.size(), 0);
585 vec.resize(2);
586 EXPECT_EQ(vec.size(), 2);
587 EXPECT_EQ(vec[0], "");
588 EXPECT_EQ(vec[1], "");
589 vec.resize(5, long_string);
590 EXPECT_EQ(vec.size(), 5);
591 EXPECT_EQ(vec[0], "");
592 EXPECT_EQ(vec[1], "");
593 EXPECT_EQ(vec[2], long_string);
594 EXPECT_EQ(vec[3], long_string);
595 EXPECT_EQ(vec[4], long_string);
596 vec.resize(1);
597 EXPECT_EQ(vec.size(), 1);
598 EXPECT_EQ(vec[0], "");
599 }
600
TEST(vector,FirstIndexOf)601 TEST(vector, FirstIndexOf)
602 {
603 Vector<int> vec = {2, 3, 5, 7, 5, 9};
604 EXPECT_EQ(vec.first_index_of(2), 0);
605 EXPECT_EQ(vec.first_index_of(5), 2);
606 EXPECT_EQ(vec.first_index_of(9), 5);
607 }
608
TEST(vector,FirstIndexTryOf)609 TEST(vector, FirstIndexTryOf)
610 {
611 Vector<int> vec = {2, 3, 5, 7, 5, 9};
612 EXPECT_EQ(vec.first_index_of_try(2), 0);
613 EXPECT_EQ(vec.first_index_of_try(4), -1);
614 EXPECT_EQ(vec.first_index_of_try(5), 2);
615 EXPECT_EQ(vec.first_index_of_try(9), 5);
616 EXPECT_EQ(vec.first_index_of_try(1), -1);
617 }
618
TEST(vector,OveralignedValues)619 TEST(vector, OveralignedValues)
620 {
621 Vector<AlignedBuffer<1, 512>, 2> vec;
622 for (int i = 0; i < 100; i++) {
623 vec.append({});
624 EXPECT_EQ((uintptr_t)&vec.last() % 512, 0);
625 }
626 }
627
TEST(vector,ConstructVoidPointerVector)628 TEST(vector, ConstructVoidPointerVector)
629 {
630 int a;
631 float b;
632 double c;
633 Vector<void *> vec = {&a, &b, &c};
634 EXPECT_EQ(vec.size(), 3);
635 }
636
TEST(vector,Fill)637 TEST(vector, Fill)
638 {
639 Vector<int> vec(5);
640 vec.fill(3);
641 EXPECT_EQ(vec.size(), 5u);
642 EXPECT_EQ(vec[0], 3);
643 EXPECT_EQ(vec[1], 3);
644 EXPECT_EQ(vec[2], 3);
645 EXPECT_EQ(vec[3], 3);
646 EXPECT_EQ(vec[4], 3);
647 }
648
TEST(vector,InsertAtBeginning)649 TEST(vector, InsertAtBeginning)
650 {
651 Vector<int> vec = {1, 2, 3};
652 vec.insert(0, {6, 7});
653 EXPECT_EQ(vec.size(), 5);
654 EXPECT_EQ_ARRAY(vec.data(), Span({6, 7, 1, 2, 3}).data(), 5);
655 }
656
TEST(vector,InsertAtEnd)657 TEST(vector, InsertAtEnd)
658 {
659 Vector<int> vec = {1, 2, 3};
660 vec.insert(3, {6, 7});
661 EXPECT_EQ(vec.size(), 5);
662 EXPECT_EQ_ARRAY(vec.data(), Span({1, 2, 3, 6, 7}).data(), 5);
663 }
664
TEST(vector,InsertInMiddle)665 TEST(vector, InsertInMiddle)
666 {
667 Vector<int> vec = {1, 2, 3};
668 vec.insert(1, {6, 7});
669 EXPECT_EQ(vec.size(), 5);
670 EXPECT_EQ_ARRAY(vec.data(), Span({1, 6, 7, 2, 3}).data(), 5);
671 }
672
TEST(vector,InsertAtIterator)673 TEST(vector, InsertAtIterator)
674 {
675 Vector<std::string> vec = {"1", "2", "3"};
676 Vector<std::string> other_vec = {"hello", "world"};
677 vec.insert(vec.begin() + 1, other_vec.begin(), other_vec.end());
678 EXPECT_EQ(vec.size(), 5);
679 EXPECT_EQ_ARRAY(vec.data(), Span<std::string>({"1", "hello", "world", "2", "3"}).data(), 5);
680 }
681
TEST(vector,InsertMoveOnlyType)682 TEST(vector, InsertMoveOnlyType)
683 {
684 Vector<std::unique_ptr<int>> vec;
685 vec.append(std::make_unique<int>(1));
686 vec.append(std::make_unique<int>(2));
687 vec.insert(1, std::make_unique<int>(30));
688 EXPECT_EQ(vec.size(), 3);
689 EXPECT_EQ(*vec[0], 1);
690 EXPECT_EQ(*vec[1], 30);
691 EXPECT_EQ(*vec[2], 2);
692 }
693
TEST(vector,Prepend)694 TEST(vector, Prepend)
695 {
696 Vector<int> vec = {1, 2, 3};
697 vec.prepend({7, 8});
698 EXPECT_EQ(vec.size(), 5);
699 EXPECT_EQ_ARRAY(vec.data(), Span({7, 8, 1, 2, 3}).data(), 5);
700 }
701
TEST(vector,ReverseIterator)702 TEST(vector, ReverseIterator)
703 {
704 Vector<int> vec = {4, 5, 6, 7};
705 Vector<int> reversed_vec;
706 for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
707 reversed_vec.append(*it);
708 }
709 EXPECT_EQ(reversed_vec.size(), 4);
710 EXPECT_EQ_ARRAY(reversed_vec.data(), Span({7, 6, 5, 4}).data(), 4);
711 }
712
TEST(vector,SizeValueConstructorExceptions)713 TEST(vector, SizeValueConstructorExceptions)
714 {
715 ExceptionThrower value;
716 value.throw_during_copy = true;
717 EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(5, value); });
718 }
719
TEST(vector,SpanConstructorExceptions)720 TEST(vector, SpanConstructorExceptions)
721 {
722 std::array<ExceptionThrower, 5> values;
723 values[3].throw_during_copy = true;
724 EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(values); });
725 }
726
TEST(vector,MoveConstructorExceptions)727 TEST(vector, MoveConstructorExceptions)
728 {
729 Vector<ExceptionThrower, 4> vec(3);
730 vec[2].throw_during_move = true;
731 EXPECT_ANY_THROW({ Vector<ExceptionThrower> moved_vector{std::move(vec)}; });
732 }
733
TEST(vector,AppendExceptions)734 TEST(vector, AppendExceptions)
735 {
736 Vector<ExceptionThrower, 4> vec(2);
737 ExceptionThrower *ptr1 = &vec.last();
738 ExceptionThrower value;
739 value.throw_during_copy = true;
740 EXPECT_ANY_THROW({ vec.append(value); });
741 EXPECT_EQ(vec.size(), 2);
742 ExceptionThrower *ptr2 = &vec.last();
743 EXPECT_EQ(ptr1, ptr2);
744 }
745
TEST(vector,ExtendExceptions)746 TEST(vector, ExtendExceptions)
747 {
748 Vector<ExceptionThrower> vec(5);
749 std::array<ExceptionThrower, 10> values;
750 values[6].throw_during_copy = true;
751 EXPECT_ANY_THROW({ vec.extend(values); });
752 EXPECT_EQ(vec.size(), 5);
753 }
754
TEST(vector,Insert1Exceptions)755 TEST(vector, Insert1Exceptions)
756 {
757 Vector<ExceptionThrower> vec(10);
758 std::array<ExceptionThrower, 5> values;
759 values[3].throw_during_copy = true;
760 EXPECT_ANY_THROW({ vec.insert(7, values); });
761 }
762
TEST(vector,Insert2Exceptions)763 TEST(vector, Insert2Exceptions)
764 {
765 Vector<ExceptionThrower> vec(10);
766 vec.reserve(100);
767 vec[8].throw_during_move = true;
768 std::array<ExceptionThrower, 5> values;
769 EXPECT_ANY_THROW({ vec.insert(3, values); });
770 }
771
TEST(vector,PopLastExceptions)772 TEST(vector, PopLastExceptions)
773 {
774 Vector<ExceptionThrower> vec(10);
775 vec.last().throw_during_move = true;
776 EXPECT_ANY_THROW({ vec.pop_last(); }); /* NOLINT: bugprone-throw-keyword-missing */
777 EXPECT_EQ(vec.size(), 10);
778 }
779
TEST(vector,RemoveAndReorderExceptions)780 TEST(vector, RemoveAndReorderExceptions)
781 {
782 Vector<ExceptionThrower> vec(10);
783 vec.last().throw_during_move = true;
784 EXPECT_ANY_THROW({ vec.remove_and_reorder(3); });
785 EXPECT_EQ(vec.size(), 10);
786 }
787
TEST(vector,RemoveExceptions)788 TEST(vector, RemoveExceptions)
789 {
790 Vector<ExceptionThrower> vec(10);
791 vec[8].throw_during_move = true;
792 EXPECT_ANY_THROW({ vec.remove(2); });
793 EXPECT_EQ(vec.size(), 10);
794 }
795
TEST(vector,RemoveChunk)796 TEST(vector, RemoveChunk)
797 {
798 Vector<int> vec = {2, 3, 4, 5, 6, 7, 8};
799 EXPECT_EQ(vec.size(), 7);
800 vec.remove(2, 4);
801 EXPECT_EQ(vec.size(), 3);
802 EXPECT_EQ(vec[0], 2);
803 EXPECT_EQ(vec[1], 3);
804 EXPECT_EQ(vec[2], 8);
805 vec.remove(0, 1);
806 EXPECT_EQ(vec.size(), 2);
807 EXPECT_EQ(vec[0], 3);
808 EXPECT_EQ(vec[1], 8);
809 vec.remove(1, 1);
810 EXPECT_EQ(vec.size(), 1);
811 EXPECT_EQ(vec[0], 3);
812 vec.remove(0, 1);
813 EXPECT_EQ(vec.size(), 0);
814 vec.remove(0, 0);
815 EXPECT_EQ(vec.size(), 0);
816 }
817
TEST(vector,RemoveChunkExceptions)818 TEST(vector, RemoveChunkExceptions)
819 {
820 Vector<ExceptionThrower> vec(10);
821 vec.remove(1, 3);
822 EXPECT_EQ(vec.size(), 7);
823 vec[5].throw_during_move = true;
824 EXPECT_ANY_THROW({ vec.remove(2, 3); });
825 EXPECT_EQ(vec.size(), 7);
826 }
827
828 } // namespace blender::tests
829