7#include "testing/testing.h"
15TEST(vector, DefaultConstructor)
21TEST(vector, SizeConstructor)
31TEST(vector, TrivialTypeSizeConstructor)
34 char *ptr = vec->data();
37 const char magic = 42;
41 new (vec) Vector<char, 1>(1);
47TEST(vector, SizeValueConstructor)
49 Vector<int> vec(4, 10);
57TEST(vector, InitializerListConstructor)
59 Vector<int> vec = {1, 3, 4, 6};
67TEST(vector, ConvertingConstructor)
69 std::array<float, 5> values = {5.4f, 7.3f, -8.1f, 5.0f, 0.0f};
70 Vector<int> vec = values;
80 TestListValue *next, *prev;
106TEST(vector, IteratorConstructor)
108 std::forward_list<int> list;
113 Vector<int> vec = Vector<int>(list.begin(), list.end());
120TEST(vector, CopyConstructor)
122 Vector<int> vec1 = {1, 2, 3};
123 Vector<int> vec2(vec1);
134TEST(vector, CopyConstructor2)
136 Vector<int, 2> vec1 = {1, 2, 3, 4};
137 Vector<int, 3> vec2(vec1);
148TEST(vector, CopyConstructor3)
150 Vector<int, 20> vec1 = {1, 2, 3, 4};
151 Vector<int, 1> vec2(vec1);
159TEST(vector, CopyConstructor4)
161 Vector<int, 5> vec1 = {1, 2, 3, 4};
162 Vector<int, 6> vec2(vec1);
170TEST(vector, MoveConstructor)
172 Vector<int> vec1 = {1, 2, 3, 4};
173 Vector<int> vec2(std::move(vec1));
183TEST(vector, MoveConstructor2)
185 Vector<int, 2> vec1 = {1, 2, 3, 4};
186 Vector<int, 3> vec2(std::move(vec1));
196TEST(vector, MoveConstructor3)
198 Vector<int, 20> vec1 = {1, 2, 3, 4};
199 Vector<int, 1> vec2(std::move(vec1));
206TEST(vector, MoveConstructor4)
208 Vector<int, 5> vec1 = {1, 2, 3, 4};
209 Vector<int, 6> vec2(std::move(vec1));
216TEST(vector, MoveAssignment)
218 Vector<int> vec = {1, 2};
223 vec = Vector<int>({5});
228TEST(vector, CopyAssignment)
230 Vector<int> vec1 = {1, 2, 3};
231 Vector<int> vec2 = {4, 5};
255TEST(vector, AppendAs)
257 Vector<StringRef> vec;
258 vec.append_as(
"hello", 2);
259 vec.append_as(
"world", 3);
264TEST(vector, AppendAndGetIndex)
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);
272 EXPECT_EQ(vec.append_and_get_index(value), 4);
275TEST(vector, AppendNonDuplicates)
278 vec.append_non_duplicates(4);
280 vec.append_non_duplicates(5);
282 vec.append_non_duplicates(4);
286TEST(vector, ExtendNonDuplicates)
289 vec.extend_non_duplicates({1, 2});
291 vec.extend_non_duplicates({3, 4});
293 vec.extend_non_duplicates({0, 1, 2, 3});
297TEST(vector, ExtendIterator)
299 Vector<int> vec = {3, 4, 5};
300 std::forward_list<int> list = {8, 9};
301 vec.extend(list.begin(), list.end());
303 EXPECT_EQ_SPAN<int>(vec,
Span({3, 4, 5, 8, 9}));
306TEST(vector, Iterator)
308 Vector<int> vec({1, 4, 9, 16});
310 for (
int value : vec) {
316TEST(vector, BecomeLarge)
319 for (
int i = 0; i < 100; i++) {
323 for (
int i = 0; i < 100; i++) {
328static Vector<int> return_by_value_helper()
330 return Vector<int>({3, 5, 1});
333TEST(vector, ReturnByValue)
335 Vector<int> vec = return_by_value_helper();
342TEST(vector, VectorOfVectors_Append)
344 Vector<Vector<int>> vec;
347 Vector<int>
v({1, 2});
357TEST(vector, RemoveLast)
359 Vector<int> vec = {5, 6};
377TEST(vector, RemoveReorder)
379 Vector<int> vec = {4, 5, 6, 7};
380 vec.remove_and_reorder(1);
384 vec.remove_and_reorder(2);
387 vec.remove_and_reorder(0);
389 vec.remove_and_reorder(0);
393TEST(vector, RemoveFirstOccurrenceAndReorder)
395 Vector<int> vec = {4, 5, 6, 7};
396 vec.remove_first_occurrence_and_reorder(5);
400 vec.remove_first_occurrence_and_reorder(6);
403 vec.remove_first_occurrence_and_reorder(4);
405 vec.remove_first_occurrence_and_reorder(7);
411 Vector<int> vec = {1, 2, 3, 4, 5, 6};
413 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({1, 2, 3, 5, 6}).begin()));
415 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5, 6}).begin()));
417 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5}).begin()));
419 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 5}).begin()));
421 EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2}).begin()));
426TEST(vector, RemoveIf)
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; });
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);
436TEST(vector, RemoveIfNonTrivialDestructible)
438 Vector<Vector<int, 0, GuardedAllocator>> vec;
441 vec.append(Vector<int, 0, GuardedAllocator>(100));
443 vec.remove_if([&](
const auto & ) {
return true; });
447TEST(vector, ExtendSmallVector)
449 Vector<int> a = {2, 3, 4};
450 Vector<int>
b = {11, 12};
460TEST(vector, ExtendArray)
462 int array[] = {3, 4, 5, 6};
472TEST(vector, ExtendMoveFromSmallVector)
474 Vector<Vector<uint64_t, 0>> a = {
478 Vector<Vector<uint64_t, 0>>
b = {
482 const Vector<Vector<uint64_t, 0>> c = {
489 a.extend(std::move(
b));
495TEST(vector, ExtendMoveFromUniquePtrVector)
497 Vector<int *> ptr_vec;
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));
504 for (std::unique_ptr<int> &i : a) {
505 ptr_vec.append(i.get());
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));
514 for (std::unique_ptr<int> &i :
b) {
515 ptr_vec.append(i.get());
518 ASSERT_EQ(a.size(), 3);
519 ASSERT_EQ(
b.size(), 4);
521 a.extend(std::move(
b));
523 std::array<int, 7> values = {0, 1, 2, 7, 8, 9, 20};
525 ASSERT_EQ(
size_t(a.size()), values.size());
526 ASSERT_TRUE(
b.is_empty());
527 ASSERT_EQ(a.size(), ptr_vec.size());
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]);
537 Vector<int> a{3, 5, 7};
544TEST(vector, AppendNTimes)
547 a.append_n_times(5, 3);
548 a.append_n_times(2, 2);
557TEST(vector, UniquePtrValue)
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>());
566 std::unique_ptr<int> &a = vec.last();
567 std::unique_ptr<int>
b = vec.pop_last();
568 vec.remove_and_reorder(0);
571 EXPECT_EQ(vec.append_and_get_index(std::make_unique<int>(4)), 1);
576class TypeConstructMock {
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;
584 TypeConstructMock() : default_constructed(
true) {}
586 TypeConstructMock(
const TypeConstructMock & ) : copy_constructed(
true) {}
588 TypeConstructMock(TypeConstructMock && ) noexcept : move_constructed(
true) {}
590 TypeConstructMock &
operator=(
const TypeConstructMock &other)
592 if (
this == &other) {
596 copy_assigned =
true;
600 TypeConstructMock &
operator=(TypeConstructMock &&other)
noexcept
602 if (
this == &other) {
606 move_assigned =
true;
611TEST(vector, SizeConstructorCallsDefaultConstructor)
613 Vector<TypeConstructMock> vec(3);
619TEST(vector, SizeValueConstructorCallsCopyConstructor)
621 Vector<TypeConstructMock> vec(3, TypeConstructMock());
627TEST(vector, AppendCallsCopyConstructor)
629 Vector<TypeConstructMock> vec;
630 TypeConstructMock value;
635TEST(vector, AppendCallsMoveConstructor)
637 Vector<TypeConstructMock> vec;
638 vec.append(TypeConstructMock());
642TEST(vector, SmallVectorCopyCallsCopyConstructor)
644 Vector<TypeConstructMock, 2> src(2);
645 Vector<TypeConstructMock, 2> dst(src);
650TEST(vector, LargeVectorCopyCallsCopyConstructor)
652 Vector<TypeConstructMock, 2> src(5);
653 Vector<TypeConstructMock, 2> dst(src);
658TEST(vector, SmallVectorMoveCallsMoveConstructor)
660 Vector<TypeConstructMock, 2> src(2);
661 Vector<TypeConstructMock, 2> dst(std::move(src));
666TEST(vector, LargeVectorMoveCallsNoConstructor)
668 Vector<TypeConstructMock, 2> src(5);
669 Vector<TypeConstructMock, 2> dst(std::move(src));
678 std::string long_string =
"012345678901234567890123456789";
679 Vector<std::string> vec;
685 vec.resize(5, long_string);
697TEST(vector, FirstIndexOf)
699 Vector<int> vec = {2, 3, 5, 7, 5, 9};
705TEST(vector, FirstIndexTryOf)
707 Vector<int> vec = {2, 3, 5, 7, 5, 9};
709 EXPECT_EQ(vec.first_index_of_try(4), -1);
712 EXPECT_EQ(vec.first_index_of_try(1), -1);
715TEST(vector, OveralignedValues)
717 Vector<AlignedBuffer<1, 512>, 2> vec;
718 for (
int i = 0; i < 100; i++) {
724TEST(vector, ConstructVoidPointerVector)
729 Vector<void *> vec = {&a, &
b, &c};
745TEST(vector, InsertAtBeginning)
747 Vector<int> vec = {1, 2, 3};
748 vec.insert(0, {6, 7});
750 EXPECT_EQ_SPAN<int>(vec,
Span({6, 7, 1, 2, 3}));
753TEST(vector, InsertAtEnd)
755 Vector<int> vec = {1, 2, 3};
756 vec.insert(3, {6, 7});
758 EXPECT_EQ_SPAN<int>(vec,
Span({1, 2, 3, 6, 7}));
761TEST(vector, InsertInMiddle)
763 Vector<int> vec = {1, 2, 3};
764 vec.insert(1, {6, 7});
766 EXPECT_EQ_SPAN<int>(vec,
Span({1, 6, 7, 2, 3}));
769TEST(vector, InsertAtIterator)
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());
775 EXPECT_EQ_SPAN<std::string>(vec, Span<std::string>({
"1",
"hello",
"world",
"2",
"3"}));
778TEST(vector, InsertMoveOnlyType)
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));
792 Vector<int> vec = {1, 2, 3};
795 EXPECT_EQ_SPAN<int>(vec,
Span({7, 8, 1, 2, 3}));
798TEST(vector, PrependString)
800 std::string s =
"test";
801 Vector<std::string> vec;
803 vec.prepend(std::move(s));
809TEST(vector, ReverseIterator)
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);
817 EXPECT_EQ_SPAN<int>(reversed_vec,
Span({7, 6, 5, 4}));
820TEST(vector, SizeValueConstructorExceptions)
823 value.throw_during_copy =
true;
824 EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(5, value); });
827TEST(vector, SpanConstructorExceptions)
829 std::array<ExceptionThrower, 5> values;
830 values[3].throw_during_copy =
true;
831 EXPECT_ANY_THROW({ Vector<ExceptionThrower> vec(values); });
834TEST(vector, MoveConstructorExceptions)
836 Vector<ExceptionThrower, 4> vec(3);
837 vec[2].throw_during_move =
true;
838 EXPECT_ANY_THROW({ Vector<ExceptionThrower> moved_vector{std::move(vec)}; });
841TEST(vector, AppendExceptions)
843 Vector<ExceptionThrower, 4> vec(2);
847 EXPECT_ANY_THROW({ vec.append(value); });
853TEST(vector, ExtendExceptions)
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); });
862TEST(vector, Insert1Exceptions)
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); });
870TEST(vector, Insert2Exceptions)
872 Vector<ExceptionThrower> vec(10);
874 vec[8].throw_during_move =
true;
875 std::array<ExceptionThrower, 5> values;
876 EXPECT_ANY_THROW({ vec.insert(3, values); });
879TEST(vector, PopLastExceptions)
881 Vector<ExceptionThrower> vec(10);
882 vec.last().throw_during_move =
true;
883 EXPECT_ANY_THROW({ vec.pop_last(); });
887TEST(vector, RemoveAndReorderExceptions)
889 Vector<ExceptionThrower> vec(10);
890 vec.last().throw_during_move =
true;
891 EXPECT_ANY_THROW({ vec.remove_and_reorder(3); });
895TEST(vector, RemoveExceptions)
897 Vector<ExceptionThrower> vec(10);
898 vec[8].throw_during_move =
true;
899 EXPECT_ANY_THROW({ vec.remove(2); });
903TEST(vector, RemoveChunk)
905 Vector<int> vec = {2, 3, 4, 5, 6, 7, 8};
925TEST(vector, RemoveChunkExceptions)
927 Vector<ExceptionThrower> vec(10);
930 vec[5].throw_during_move =
true;
931 EXPECT_ANY_THROW({ vec.remove(2, 3); });
935struct RecursiveType {
936 Vector<RecursiveType, 0> my_vector;
939TEST(vector, RecursiveStructure)
941 RecursiveType my_recursive_type;
942 my_recursive_type.my_vector.append({});
947 VectorData<int, GuardedAllocator>
data;
954 Vector<int> vec{
data};
960TEST(vector, FromRawEmpty)
962 VectorData<int, GuardedAllocator>
data;
963 Vector<int> vec{
data};
967TEST(vector, ReleaseEmptyInline)
970 VectorData<int, GuardedAllocator>
data = vec.release();
974TEST(vector, ReleaseEmptyAllocated)
978 const int *data_ptr = vec.data();
981 VectorData<int, GuardedAllocator>
data = vec.release();
988 MEM_delete(
data.data);
991TEST(vector, ReleaseNonEmptyInline)
993 Vector<int> vec = {1, 2};
994 const int *inline_data_ptr = vec.data();
998 VectorData<int, GuardedAllocator>
data = vec.release();
1004 MEM_delete(
data.data);
1007TEST(vector, ReleaseAllocated)
1009 Vector<int> vec(50, 3);
1010 const int *data_ptr = vec.data();
1014 VectorData<int, GuardedAllocator>
data = vec.release();
1021 MEM_delete(
data.data);
btGeneric6DofConstraint & operator=(btGeneric6DofConstraint &other)
constexpr IndexRange()=default
#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)
ATTR_WARN_UNUSED_RESULT const BMVert * v
BMesh const char void * data
_W64 unsigned int uintptr_t
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1