diff options
Diffstat (limited to 'source/blender/blenlib/tests')
3 files changed, 213 insertions, 0 deletions
diff --git a/source/blender/blenlib/tests/BLI_generic_array_test.cc b/source/blender/blenlib/tests/BLI_generic_array_test.cc new file mode 100644 index 00000000000..52bc7728a6a --- /dev/null +++ b/source/blender/blenlib/tests/BLI_generic_array_test.cc @@ -0,0 +1,117 @@ +/* SPDX-License-Identifier: Apache-2.0 */ + +#include "testing/testing.h" + +#include "MEM_guardedalloc.h" + +#include "BLI_array.hh" +#include "BLI_generic_array.hh" + +namespace blender::tests { + +TEST(generic_array, TypeConstructor) +{ + GArray array(CPPType::get<float>()); + EXPECT_TRUE(array.data() == nullptr); + EXPECT_EQ(array.size(), 0); + EXPECT_EQ(array.as_span().typed<float>().size(), 0); + EXPECT_TRUE(array.is_empty()); +} + +TEST(generic_array, MoveConstructor) +{ + GArray array_a(CPPType::get<int32_t>(), (int64_t)10); + GMutableSpan span_a = array_a.as_mutable_span(); + MutableSpan<int32_t> typed_span_a = span_a.typed<int32_t>(); + typed_span_a.fill(42); + + const GArray array_b = std::move(array_a); + Span<int32_t> typed_span_b = array_b.as_span().typed<int32_t>(); + EXPECT_FALSE(array_b.data() == nullptr); + EXPECT_EQ(array_b.size(), 10); + EXPECT_EQ(typed_span_b[4], 42); + + /* Make sure the copy constructor cleaned up the original, but it shouldn't clear the type. */ + EXPECT_TRUE(array_a.data() == nullptr); /* NOLINT: bugprone-use-after-move */ + EXPECT_EQ(array_a.size(), 0); /* NOLINT: bugprone-use-after-move */ + EXPECT_TRUE(array_a.is_empty()); /* NOLINT: bugprone-use-after-move */ + EXPECT_EQ(array_b.type(), array_a.type()); /* NOLINT: bugprone-use-after-move */ +} + +TEST(generic_array, CopyConstructor) +{ + GArray array_a(CPPType::get<int32_t>(), (int64_t)10); + GMutableSpan span_a = array_a.as_mutable_span(); + MutableSpan<int32_t> typed_span_a = span_a.typed<int32_t>(); + typed_span_a.fill(42); + + /* From span directly. */ + const GArray array_b = array_a.as_span(); + Span<int32_t> typed_span_b = array_b.as_span().typed<int32_t>(); + EXPECT_FALSE(array_b.data() == nullptr); + EXPECT_EQ(array_b.size(), 10); + EXPECT_EQ(typed_span_b[4], 42); + EXPECT_FALSE(array_a.is_empty()); + + /* From array. */ + const GArray array_c = array_a; + Span<int32_t> typed_span_c = array_c.as_span().typed<int32_t>(); + EXPECT_FALSE(array_c.data() == nullptr); + EXPECT_EQ(array_c.size(), 10); + EXPECT_EQ(typed_span_c[4], 42); + EXPECT_FALSE(array_a.is_empty()); +} + +TEST(generic_array, BufferAndSizeConstructor) +{ + int32_t *values = (int32_t *)MEM_malloc_arrayN(12, sizeof(int32_t), __func__); + void *buffer = (void *)values; + GArray array(CPPType::get<int32_t>(), buffer, 4); + EXPECT_FALSE(array.data() == nullptr); + EXPECT_EQ(array.size(), 4); + EXPECT_FALSE(array.is_empty()); + EXPECT_EQ(array.as_span().typed<int>().size(), 4); + EXPECT_EQ(array[0], &values[0]); + EXPECT_EQ(array[1], &values[1]); + EXPECT_EQ(array[2], &values[2]); + EXPECT_EQ(array[3], &values[3]); +} + +TEST(generic_array, Reinitialize) +{ + GArray array(CPPType::get<int32_t>(), (int64_t)5); + EXPECT_FALSE(array.data() == nullptr); + GMutableSpan span = array.as_mutable_span(); + MutableSpan<int32_t> typed_span = span.typed<int32_t>(); + typed_span.fill(77); + EXPECT_FALSE(typed_span.data() == nullptr); + typed_span[2] = 8; + EXPECT_EQ(array[2], &typed_span[2]); + EXPECT_EQ(typed_span[0], 77); + EXPECT_EQ(typed_span[1], 77); + + array.reinitialize(10); + EXPECT_EQ(array.size(), 10); + span = array.as_mutable_span(); + EXPECT_EQ(span.size(), 10); + + typed_span = span.typed<int32_t>(); + EXPECT_FALSE(typed_span.data() == nullptr); + + array.reinitialize(0); + EXPECT_EQ(array.size(), 0); +} + +TEST(generic_array, InContainer) +{ + blender::Array<GArray<>> arrays; + for (GArray<> &array : arrays) { + array = GArray(CPPType::get<int32_t>(), (int64_t)5); + array.as_mutable_span().typed<int32_t>().fill(55); + } + for (GArray<> &array : arrays) { + EXPECT_EQ(array.as_span().typed<int32_t>()[3], 55); + } +} + +} // namespace blender::tests diff --git a/source/blender/blenlib/tests/BLI_generic_span_test.cc b/source/blender/blenlib/tests/BLI_generic_span_test.cc new file mode 100644 index 00000000000..fe07a67d63b --- /dev/null +++ b/source/blender/blenlib/tests/BLI_generic_span_test.cc @@ -0,0 +1,53 @@ +/* SPDX-License-Identifier: Apache-2.0 */ + +#include "testing/testing.h" + +#include "BLI_generic_span.hh" + +namespace blender::tests { + +TEST(generic_span, TypeConstructor) +{ + GSpan span(CPPType::get<float>()); + EXPECT_EQ(span.size(), 0); + EXPECT_EQ(span.typed<float>().size(), 0); + EXPECT_TRUE(span.is_empty()); +} + +TEST(generic_span, BufferAndSizeConstructor) +{ + int values[4] = {6, 7, 3, 2}; + void *buffer = (void *)values; + GSpan span(CPPType::get<int32_t>(), buffer, 4); + EXPECT_EQ(span.size(), 4); + EXPECT_FALSE(span.is_empty()); + EXPECT_EQ(span.typed<int>().size(), 4); + EXPECT_EQ(span[0], &values[0]); + EXPECT_EQ(span[1], &values[1]); + EXPECT_EQ(span[2], &values[2]); + EXPECT_EQ(span[3], &values[3]); +} + +TEST(generic_mutable_span, TypeConstructor) +{ + GMutableSpan span(CPPType::get<int32_t>()); + EXPECT_EQ(span.size(), 0); + EXPECT_TRUE(span.is_empty()); +} + +TEST(generic_mutable_span, BufferAndSizeConstructor) +{ + int values[4] = {4, 7, 3, 5}; + void *buffer = (void *)values; + GMutableSpan span(CPPType::get<int32_t>(), buffer, 4); + EXPECT_EQ(span.size(), 4); + EXPECT_FALSE(span.is_empty()); + EXPECT_EQ(span.typed<int>().size(), 4); + EXPECT_EQ(values[2], 3); + *(int *)span[2] = 10; + EXPECT_EQ(values[2], 10); + span.typed<int>()[2] = 20; + EXPECT_EQ(values[2], 20); +} + +} // namespace blender::tests diff --git a/source/blender/blenlib/tests/BLI_generic_vector_array_test.cc b/source/blender/blenlib/tests/BLI_generic_vector_array_test.cc new file mode 100644 index 00000000000..105f3603914 --- /dev/null +++ b/source/blender/blenlib/tests/BLI_generic_vector_array_test.cc @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: Apache-2.0 */ + +#include "testing/testing.h" + +#include "BLI_generic_vector_array.hh" + +namespace blender::tests { + +TEST(generic_vector_array, Construct) +{ + GVectorArray vector_array{CPPType::get<int>(), 4}; + EXPECT_EQ(vector_array.size(), 4); + EXPECT_FALSE(vector_array.is_empty()); +} + +TEST(generic_vector_array, Append) +{ + GVectorArray vector_array{CPPType::get<int>(), 3}; + int value1 = 2; + vector_array.append(1, &value1); + vector_array.append(1, &value1); + int value2 = 3; + vector_array.append(0, &value2); + vector_array.append(1, &value2); + + EXPECT_EQ(vector_array[0].size(), 1); + EXPECT_EQ(vector_array[1].size(), 3); + EXPECT_EQ(vector_array[2].size(), 0); +} + +TEST(generic_vector_array, Extend) +{ + GVectorArray vector_array{CPPType::get<int>(), 3}; + vector_array.extend(0, Span<int>({1, 4, 6, 4})); + vector_array.extend(1, Span<int>()); + vector_array.extend(0, Span<int>({10, 20, 30})); + + EXPECT_EQ(vector_array[0].size(), 7); + EXPECT_EQ(vector_array[1].size(), 0); + EXPECT_EQ(vector_array[2].size(), 0); +} + +} // namespace blender::tests |