Blender  V3.3
BLI_vector_test.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0 */
2 
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 
11 TEST(vector, DefaultConstructor)
12 {
13  Vector<int> vec;
14  EXPECT_EQ(vec.size(), 0);
15 }
16 
17 TEST(vector, SizeConstructor)
18 {
19  Vector<int> vec(3);
20  EXPECT_EQ(vec.size(), 3);
21 }
22 
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 
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 
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 
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 {
77  int value;
78 };
79 
80 TEST(vector, ListBaseConstructor)
81 {
82  TestListValue *value1 = new TestListValue{nullptr, nullptr, 4};
83  TestListValue *value2 = new TestListValue{nullptr, nullptr, 5};
84  TestListValue *value3 = new TestListValue{nullptr, nullptr, 6};
85 
86  ListBase list = {nullptr, nullptr};
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
251 TEST(vector, AppendAs)
252 {
253  Vector<StringRef> vec;
254  vec.append_as("hello", 2);
255  vec.append_as("world", 3);
256  EXPECT_EQ(vec[0], "he");
257  EXPECT_EQ(vec[1], "wor");
258 }
259 
260 TEST(vector, AppendAndGetIndex)
261 {
262  Vector<int> vec;
263  EXPECT_EQ(vec.append_and_get_index(10), 0);
264  EXPECT_EQ(vec.append_and_get_index(10), 1);
265  EXPECT_EQ(vec.append_and_get_index(10), 2);
266  vec.append(10);
267  int value = 10;
268  EXPECT_EQ(vec.append_and_get_index(value), 4);
269 }
270 
271 TEST(vector, AppendNonDuplicates)
272 {
273  Vector<int> vec;
274  vec.append_non_duplicates(4);
275  EXPECT_EQ(vec.size(), 1);
276  vec.append_non_duplicates(5);
277  EXPECT_EQ(vec.size(), 2);
278  vec.append_non_duplicates(4);
279  EXPECT_EQ(vec.size(), 2);
280 }
281 
282 TEST(vector, ExtendNonDuplicates)
283 {
284  Vector<int> vec;
285  vec.extend_non_duplicates({1, 2});
286  EXPECT_EQ(vec.size(), 2);
287  vec.extend_non_duplicates({3, 4});
288  EXPECT_EQ(vec.size(), 4);
289  vec.extend_non_duplicates({0, 1, 2, 3});
290  EXPECT_EQ(vec.size(), 5);
291 }
292 
293 TEST(vector, ExtendIterator)
294 {
295  Vector<int> vec = {3, 4, 5};
296  std::forward_list<int> list = {8, 9};
297  vec.extend(list.begin(), list.end());
298  EXPECT_EQ(vec.size(), 5);
299  EXPECT_EQ_ARRAY(vec.data(), Span({3, 4, 5, 8, 9}).data(), 5);
300 }
301 
302 TEST(vector, Iterator)
303 {
304  Vector<int> vec({1, 4, 9, 16});
305  int i = 1;
306  for (int value : vec) {
307  EXPECT_EQ(value, i * i);
308  i++;
309  }
310 }
311 
312 TEST(vector, BecomeLarge)
313 {
314  Vector<int, 4> vec;
315  for (int i = 0; i < 100; i++) {
316  vec.append(i * 5);
317  }
318  EXPECT_EQ(vec.size(), 100);
319  for (int i = 0; i < 100; i++) {
320  EXPECT_EQ(vec[i], static_cast<int>(i * 5));
321  }
322 }
323 
325 {
326  return Vector<int>({3, 5, 1});
327 }
328 
329 TEST(vector, ReturnByValue)
330 {
332  EXPECT_EQ(vec.size(), 3);
333  EXPECT_EQ(vec[0], 3);
334  EXPECT_EQ(vec[1], 5);
335  EXPECT_EQ(vec[2], 1);
336 }
337 
338 TEST(vector, VectorOfVectors_Append)
339 {
340  Vector<Vector<int>> vec;
341  EXPECT_EQ(vec.size(), 0);
342 
343  Vector<int> v({1, 2});
344  vec.append(v);
345  vec.append({7, 8});
346  EXPECT_EQ(vec.size(), 2);
347  EXPECT_EQ(vec[0][0], 1);
348  EXPECT_EQ(vec[0][1], 2);
349  EXPECT_EQ(vec[1][0], 7);
350  EXPECT_EQ(vec[1][1], 8);
351 }
352 
353 TEST(vector, RemoveLast)
354 {
355  Vector<int> vec = {5, 6};
356  EXPECT_EQ(vec.size(), 2);
357  vec.remove_last();
358  EXPECT_EQ(vec.size(), 1);
359  vec.remove_last();
360  EXPECT_EQ(vec.size(), 0);
361 }
362 
363 TEST(vector, IsEmpty)
364 {
365  Vector<int> vec;
366  EXPECT_TRUE(vec.is_empty());
367  vec.append(1);
368  EXPECT_FALSE(vec.is_empty());
369  vec.remove_last();
370  EXPECT_TRUE(vec.is_empty());
371 }
372 
373 TEST(vector, RemoveReorder)
374 {
375  Vector<int> vec = {4, 5, 6, 7};
376  vec.remove_and_reorder(1);
377  EXPECT_EQ(vec[0], 4);
378  EXPECT_EQ(vec[1], 7);
379  EXPECT_EQ(vec[2], 6);
380  vec.remove_and_reorder(2);
381  EXPECT_EQ(vec[0], 4);
382  EXPECT_EQ(vec[1], 7);
383  vec.remove_and_reorder(0);
384  EXPECT_EQ(vec[0], 7);
385  vec.remove_and_reorder(0);
386  EXPECT_TRUE(vec.is_empty());
387 }
388 
389 TEST(vector, RemoveFirstOccurrenceAndReorder)
390 {
391  Vector<int> vec = {4, 5, 6, 7};
393  EXPECT_EQ(vec[0], 4);
394  EXPECT_EQ(vec[1], 7);
395  EXPECT_EQ(vec[2], 6);
397  EXPECT_EQ(vec[0], 4);
398  EXPECT_EQ(vec[1], 7);
400  EXPECT_EQ(vec[0], 7);
402  EXPECT_EQ(vec.size(), 0);
403 }
404 
405 TEST(vector, Remove)
406 {
407  Vector<int> vec = {1, 2, 3, 4, 5, 6};
408  vec.remove(3);
409  EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({1, 2, 3, 5, 6}).begin()));
410  vec.remove(0);
411  EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5, 6}).begin()));
412  vec.remove(3);
413  EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5}).begin()));
414  vec.remove(1);
415  EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 5}).begin()));
416  vec.remove(1);
417  EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2}).begin()));
418  vec.remove(0);
419  EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({}).begin()));
420 }
421 
422 TEST(vector, ExtendSmallVector)
423 {
424  Vector<int> a = {2, 3, 4};
425  Vector<int> b = {11, 12};
426  b.extend(a);
427  EXPECT_EQ(b.size(), 5);
428  EXPECT_EQ(b[0], 11);
429  EXPECT_EQ(b[1], 12);
430  EXPECT_EQ(b[2], 2);
431  EXPECT_EQ(b[3], 3);
432  EXPECT_EQ(b[4], 4);
433 }
434 
435 TEST(vector, ExtendArray)
436 {
437  int array[] = {3, 4, 5, 6};
438 
439  Vector<int> a;
440  a.extend(array, 2);
441 
442  EXPECT_EQ(a.size(), 2);
443  EXPECT_EQ(a[0], 3);
444  EXPECT_EQ(a[1], 4);
445 }
446 
447 TEST(vector, Last)
448 {
449  Vector<int> a{3, 5, 7};
450  EXPECT_EQ(a.last(), 7);
451  EXPECT_EQ(a.last(0), 7);
452  EXPECT_EQ(a.last(1), 5);
453  EXPECT_EQ(a.last(2), 3);
454 }
455 
456 TEST(vector, AppendNTimes)
457 {
458  Vector<int> a;
459  a.append_n_times(5, 3);
460  a.append_n_times(2, 2);
461  EXPECT_EQ(a.size(), 5);
462  EXPECT_EQ(a[0], 5);
463  EXPECT_EQ(a[1], 5);
464  EXPECT_EQ(a[2], 5);
465  EXPECT_EQ(a[3], 2);
466  EXPECT_EQ(a[4], 2);
467 }
468 
469 TEST(vector, UniquePtrValue)
470 {
472  vec.append(std::make_unique<int>());
473  vec.append(std::make_unique<int>());
474  vec.append(std::make_unique<int>());
475  vec.append(std::make_unique<int>());
476  EXPECT_EQ(vec.size(), 4);
477 
478  std::unique_ptr<int> &a = vec.last();
479  std::unique_ptr<int> b = vec.pop_last();
480  vec.remove_and_reorder(0);
481  vec.remove(0);
482  EXPECT_EQ(vec.size(), 1);
483  EXPECT_EQ(vec.append_and_get_index(std::make_unique<int>(4)), 1);
484 
485  UNUSED_VARS(a, b);
486 }
487 
489  public:
490  bool default_constructed = false;
491  bool copy_constructed = false;
492  bool move_constructed = false;
493  bool copy_assigned = false;
494  bool move_assigned = false;
495 
497  {
498  }
499 
501  {
502  }
503 
505  {
506  }
507 
509  {
510  if (this == &other) {
511  return *this;
512  }
513 
514  copy_assigned = true;
515  return *this;
516  }
517 
519  {
520  if (this == &other) {
521  return *this;
522  }
523 
524  move_assigned = true;
525  return *this;
526  }
527 };
528 
529 TEST(vector, SizeConstructorCallsDefaultConstructor)
530 {
532  EXPECT_TRUE(vec[0].default_constructed);
533  EXPECT_TRUE(vec[1].default_constructed);
534  EXPECT_TRUE(vec[2].default_constructed);
535 }
536 
537 TEST(vector, SizeValueConstructorCallsCopyConstructor)
538 {
540  EXPECT_TRUE(vec[0].copy_constructed);
541  EXPECT_TRUE(vec[1].copy_constructed);
542  EXPECT_TRUE(vec[2].copy_constructed);
543 }
544 
545 TEST(vector, AppendCallsCopyConstructor)
546 {
548  TypeConstructMock value;
549  vec.append(value);
550  EXPECT_TRUE(vec[0].copy_constructed);
551 }
552 
553 TEST(vector, AppendCallsMoveConstructor)
554 {
556  vec.append(TypeConstructMock());
557  EXPECT_TRUE(vec[0].move_constructed);
558 }
559 
560 TEST(vector, SmallVectorCopyCallsCopyConstructor)
561 {
564  EXPECT_TRUE(dst[0].copy_constructed);
565  EXPECT_TRUE(dst[1].copy_constructed);
566 }
567 
568 TEST(vector, LargeVectorCopyCallsCopyConstructor)
569 {
572  EXPECT_TRUE(dst[0].copy_constructed);
573  EXPECT_TRUE(dst[1].copy_constructed);
574 }
575 
576 TEST(vector, SmallVectorMoveCallsMoveConstructor)
577 {
579  Vector<TypeConstructMock, 2> dst(std::move(src));
580  EXPECT_TRUE(dst[0].move_constructed);
581  EXPECT_TRUE(dst[1].move_constructed);
582 }
583 
584 TEST(vector, LargeVectorMoveCallsNoConstructor)
585 {
587  Vector<TypeConstructMock, 2> dst(std::move(src));
588 
589  EXPECT_TRUE(dst[0].default_constructed);
590  EXPECT_FALSE(dst[0].move_constructed);
591  EXPECT_FALSE(dst[0].copy_constructed);
592 }
593 
594 TEST(vector, Resize)
595 {
596  std::string long_string = "012345678901234567890123456789";
598  EXPECT_EQ(vec.size(), 0);
599  vec.resize(2);
600  EXPECT_EQ(vec.size(), 2);
601  EXPECT_EQ(vec[0], "");
602  EXPECT_EQ(vec[1], "");
603  vec.resize(5, long_string);
604  EXPECT_EQ(vec.size(), 5);
605  EXPECT_EQ(vec[0], "");
606  EXPECT_EQ(vec[1], "");
607  EXPECT_EQ(vec[2], long_string);
608  EXPECT_EQ(vec[3], long_string);
609  EXPECT_EQ(vec[4], long_string);
610  vec.resize(1);
611  EXPECT_EQ(vec.size(), 1);
612  EXPECT_EQ(vec[0], "");
613 }
614 
615 TEST(vector, FirstIndexOf)
616 {
617  Vector<int> vec = {2, 3, 5, 7, 5, 9};
618  EXPECT_EQ(vec.first_index_of(2), 0);
619  EXPECT_EQ(vec.first_index_of(5), 2);
620  EXPECT_EQ(vec.first_index_of(9), 5);
621 }
622 
623 TEST(vector, FirstIndexTryOf)
624 {
625  Vector<int> vec = {2, 3, 5, 7, 5, 9};
626  EXPECT_EQ(vec.first_index_of_try(2), 0);
627  EXPECT_EQ(vec.first_index_of_try(4), -1);
628  EXPECT_EQ(vec.first_index_of_try(5), 2);
629  EXPECT_EQ(vec.first_index_of_try(9), 5);
630  EXPECT_EQ(vec.first_index_of_try(1), -1);
631 }
632 
633 TEST(vector, OveralignedValues)
634 {
636  for (int i = 0; i < 100; i++) {
637  vec.append({});
638  EXPECT_EQ((uintptr_t)&vec.last() % 512, 0);
639  }
640 }
641 
642 TEST(vector, ConstructVoidPointerVector)
643 {
644  int a;
645  float b;
646  double c;
647  Vector<void *> vec = {&a, &b, &c};
648  EXPECT_EQ(vec.size(), 3);
649 }
650 
651 TEST(vector, Fill)
652 {
653  Vector<int> vec(5);
654  vec.fill(3);
655  EXPECT_EQ(vec.size(), 5u);
656  EXPECT_EQ(vec[0], 3);
657  EXPECT_EQ(vec[1], 3);
658  EXPECT_EQ(vec[2], 3);
659  EXPECT_EQ(vec[3], 3);
660  EXPECT_EQ(vec[4], 3);
661 }
662 
663 TEST(vector, InsertAtBeginning)
664 {
665  Vector<int> vec = {1, 2, 3};
666  vec.insert(0, {6, 7});
667  EXPECT_EQ(vec.size(), 5);
668  EXPECT_EQ_ARRAY(vec.data(), Span({6, 7, 1, 2, 3}).data(), 5);
669 }
670 
671 TEST(vector, InsertAtEnd)
672 {
673  Vector<int> vec = {1, 2, 3};
674  vec.insert(3, {6, 7});
675  EXPECT_EQ(vec.size(), 5);
676  EXPECT_EQ_ARRAY(vec.data(), Span({1, 2, 3, 6, 7}).data(), 5);
677 }
678 
679 TEST(vector, InsertInMiddle)
680 {
681  Vector<int> vec = {1, 2, 3};
682  vec.insert(1, {6, 7});
683  EXPECT_EQ(vec.size(), 5);
684  EXPECT_EQ_ARRAY(vec.data(), Span({1, 6, 7, 2, 3}).data(), 5);
685 }
686 
687 TEST(vector, InsertAtIterator)
688 {
689  Vector<std::string> vec = {"1", "2", "3"};
690  Vector<std::string> other_vec = {"hello", "world"};
691  vec.insert(vec.begin() + 1, other_vec.begin(), other_vec.end());
692  EXPECT_EQ(vec.size(), 5);
693  EXPECT_EQ_ARRAY(vec.data(), Span<std::string>({"1", "hello", "world", "2", "3"}).data(), 5);
694 }
695 
696 TEST(vector, InsertMoveOnlyType)
697 {
699  vec.append(std::make_unique<int>(1));
700  vec.append(std::make_unique<int>(2));
701  vec.insert(1, std::make_unique<int>(30));
702  EXPECT_EQ(vec.size(), 3);
703  EXPECT_EQ(*vec[0], 1);
704  EXPECT_EQ(*vec[1], 30);
705  EXPECT_EQ(*vec[2], 2);
706 }
707 
708 TEST(vector, Prepend)
709 {
710  Vector<int> vec = {1, 2, 3};
711  vec.prepend({7, 8});
712  EXPECT_EQ(vec.size(), 5);
713  EXPECT_EQ_ARRAY(vec.data(), Span({7, 8, 1, 2, 3}).data(), 5);
714 }
715 
716 TEST(vector, PrependString)
717 {
718  std::string s = "test";
720  vec.prepend(s);
721  vec.prepend(std::move(s));
722  EXPECT_EQ(vec.size(), 2);
723  EXPECT_EQ(vec[0], "test");
724  EXPECT_EQ(vec[1], "test");
725 }
726 
727 TEST(vector, ReverseIterator)
728 {
729  Vector<int> vec = {4, 5, 6, 7};
730  Vector<int> reversed_vec;
731  for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
732  reversed_vec.append(*it);
733  }
734  EXPECT_EQ(reversed_vec.size(), 4);
735  EXPECT_EQ_ARRAY(reversed_vec.data(), Span({7, 6, 5, 4}).data(), 4);
736 }
737 
738 TEST(vector, SizeValueConstructorExceptions)
739 {
740  ExceptionThrower value;
741  value.throw_during_copy = true;
742  EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(5, value); });
743 }
744 
745 TEST(vector, SpanConstructorExceptions)
746 {
747  std::array<ExceptionThrower, 5> values;
748  values[3].throw_during_copy = true;
749  EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(values); });
750 }
751 
752 TEST(vector, MoveConstructorExceptions)
753 {
755  vec[2].throw_during_move = true;
756  EXPECT_ANY_THROW({ Vector<ExceptionThrower> moved_vector{std::move(vec)}; });
757 }
758 
759 TEST(vector, AppendExceptions)
760 {
762  ExceptionThrower *ptr1 = &vec.last();
763  ExceptionThrower value;
764  value.throw_during_copy = true;
765  EXPECT_ANY_THROW({ vec.append(value); });
766  EXPECT_EQ(vec.size(), 2);
767  ExceptionThrower *ptr2 = &vec.last();
768  EXPECT_EQ(ptr1, ptr2);
769 }
770 
771 TEST(vector, ExtendExceptions)
772 {
774  std::array<ExceptionThrower, 10> values;
775  values[6].throw_during_copy = true;
776  EXPECT_ANY_THROW({ vec.extend(values); });
777  EXPECT_EQ(vec.size(), 5);
778 }
779 
780 TEST(vector, Insert1Exceptions)
781 {
782  Vector<ExceptionThrower> vec(10);
783  std::array<ExceptionThrower, 5> values;
784  values[3].throw_during_copy = true;
785  EXPECT_ANY_THROW({ vec.insert(7, values); });
786 }
787 
788 TEST(vector, Insert2Exceptions)
789 {
790  Vector<ExceptionThrower> vec(10);
791  vec.reserve(100);
792  vec[8].throw_during_move = true;
793  std::array<ExceptionThrower, 5> values;
794  EXPECT_ANY_THROW({ vec.insert(3, values); });
795 }
796 
797 TEST(vector, PopLastExceptions)
798 {
799  Vector<ExceptionThrower> vec(10);
800  vec.last().throw_during_move = true;
801  EXPECT_ANY_THROW({ vec.pop_last(); }); /* NOLINT: bugprone-throw-keyword-missing */
802  EXPECT_EQ(vec.size(), 10);
803 }
804 
805 TEST(vector, RemoveAndReorderExceptions)
806 {
807  Vector<ExceptionThrower> vec(10);
808  vec.last().throw_during_move = true;
809  EXPECT_ANY_THROW({ vec.remove_and_reorder(3); });
810  EXPECT_EQ(vec.size(), 10);
811 }
812 
813 TEST(vector, RemoveExceptions)
814 {
815  Vector<ExceptionThrower> vec(10);
816  vec[8].throw_during_move = true;
817  EXPECT_ANY_THROW({ vec.remove(2); });
818  EXPECT_EQ(vec.size(), 10);
819 }
820 
821 TEST(vector, RemoveChunk)
822 {
823  Vector<int> vec = {2, 3, 4, 5, 6, 7, 8};
824  EXPECT_EQ(vec.size(), 7);
825  vec.remove(2, 4);
826  EXPECT_EQ(vec.size(), 3);
827  EXPECT_EQ(vec[0], 2);
828  EXPECT_EQ(vec[1], 3);
829  EXPECT_EQ(vec[2], 8);
830  vec.remove(0, 1);
831  EXPECT_EQ(vec.size(), 2);
832  EXPECT_EQ(vec[0], 3);
833  EXPECT_EQ(vec[1], 8);
834  vec.remove(1, 1);
835  EXPECT_EQ(vec.size(), 1);
836  EXPECT_EQ(vec[0], 3);
837  vec.remove(0, 1);
838  EXPECT_EQ(vec.size(), 0);
839  vec.remove(0, 0);
840  EXPECT_EQ(vec.size(), 0);
841 }
842 
843 TEST(vector, RemoveChunkExceptions)
844 {
845  Vector<ExceptionThrower> vec(10);
846  vec.remove(1, 3);
847  EXPECT_EQ(vec.size(), 7);
848  vec[5].throw_during_move = true;
849  EXPECT_ANY_THROW({ vec.remove(2, 3); });
850  EXPECT_EQ(vec.size(), 7);
851 }
852 
853 } // namespace blender::tests
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
Strict compiler flags for areas of code we want to ensure don't do conversions without us knowing abo...
#define UNUSED_VARS(...)
#define UNUSED(x)
ATTR_WARN_UNUSED_RESULT const BMVert * v
constexpr const T * data() const
Definition: BLI_span.hh:203
constexpr const T * begin() const
Definition: BLI_span.hh:208
std::reverse_iterator< T * > rbegin()
Definition: BLI_vector.hh:884
int64_t size() const
Definition: BLI_vector.hh:694
void remove_and_reorder(const int64_t index)
Definition: BLI_vector.hh:743
int64_t append_and_get_index(const T &value)
Definition: BLI_vector.hh:452
void prepend(const T &value)
Definition: BLI_vector.hh:642
void append(const T &value)
Definition: BLI_vector.hh:433
void insert(const int64_t insert_index, const T &value)
Definition: BLI_vector.hh:579
const T & last(const int64_t n=0) const
Definition: BLI_vector.hh:663
void remove(const int64_t index)
Definition: BLI_vector.hh:774
bool is_empty() const
Definition: BLI_vector.hh:706
void remove_first_occurrence_and_reorder(const T &value)
Definition: BLI_vector.hh:761
void resize(const int64_t new_size)
Definition: BLI_vector.hh:353
int64_t first_index_of(const T &value) const
Definition: BLI_vector.hh:826
void remove_last()
Definition: BLI_vector.hh:715
std::reverse_iterator< T * > rend()
Definition: BLI_vector.hh:888
void reserve(const int64_t min_capacity)
Definition: BLI_vector.hh:340
void extend(Span< T > array)
Definition: BLI_vector.hh:530
void extend_non_duplicates(Span< T > array)
Definition: BLI_vector.hh:545
void append_non_duplicates(const T &value)
Definition: BLI_vector.hh:472
void fill(const T &value) const
Definition: BLI_vector.hh:845
void append_as(ForwardValue &&...value)
Definition: BLI_vector.hh:442
int64_t first_index_of_try(const T &value) const
Definition: BLI_vector.hh:812
TypeConstructMock(const TypeConstructMock &UNUSED(other))
TypeConstructMock & operator=(TypeConstructMock &&other) noexcept
TypeConstructMock & operator=(const TypeConstructMock &other)
TypeConstructMock(TypeConstructMock &&UNUSED(other)) noexcept
SyclQueue void void * src
static unsigned c
Definition: RandGen.cpp:83
static unsigned a[3]
Definition: RandGen.cpp:78
static Vector< int > return_by_value_helper()
TEST(any, DefaultConstructor)
Definition: BLI_any_test.cc:10
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
_W64 unsigned int uintptr_t
Definition: stdint.h:119
static int magic(const Tex *tex, const float texvec[3], TexResult *texres)
PointerRNA * ptr
Definition: wm_files.c:3480