diff options
author | Jacques Lucke <jacques@blender.org> | 2020-06-22 16:48:08 +0300 |
---|---|---|
committer | Jacques Lucke <jacques@blender.org> | 2020-06-22 16:50:31 +0300 |
commit | 6223385043ddc93beaa8f092dfd31a2208b8e961 (patch) | |
tree | a4e208569308d293dc02101e09d3f84bff65af93 /tests | |
parent | 7117ed96917a2b2dedf663a97f10bde5d285470f (diff) |
Functions: Various improvements to the spans and generic data structures
Most of this code is covered by unit tests.
Diffstat (limited to 'tests')
-rw-r--r-- | tests/gtests/functions/FN_array_spans_test.cc | 57 | ||||
-rw-r--r-- | tests/gtests/functions/FN_generic_vector_array_test.cc | 17 | ||||
-rw-r--r-- | tests/gtests/functions/FN_spans_test.cc | 72 |
3 files changed, 146 insertions, 0 deletions
diff --git a/tests/gtests/functions/FN_array_spans_test.cc b/tests/gtests/functions/FN_array_spans_test.cc index 47e1c129266..21e52a90e4b 100644 --- a/tests/gtests/functions/FN_array_spans_test.cc +++ b/tests/gtests/functions/FN_array_spans_test.cc @@ -18,6 +18,9 @@ #include "FN_array_spans.hh" #include "FN_cpp_types.hh" +#include "FN_generic_vector_array.hh" + +#include "BLI_array.hh" namespace blender { namespace fn { @@ -27,6 +30,10 @@ TEST(virtual_array_span, EmptyConstructor) VArraySpan<int> span; EXPECT_EQ(span.size(), 0); EXPECT_TRUE(span.is_empty()); + + GVArraySpan converted(span); + EXPECT_EQ(converted.type(), CPPType::get<int>()); + EXPECT_EQ(converted.size(), 0); } TEST(virtual_array_span, SingleArrayConstructor) @@ -44,6 +51,13 @@ TEST(virtual_array_span, SingleArrayConstructor) EXPECT_EQ(span[0][3], 6); EXPECT_EQ(span[1][3], 6); EXPECT_EQ(span[2][1], 4); + + GVArraySpan converted(span); + EXPECT_EQ(converted.type(), CPPType::get<int>()); + EXPECT_EQ(converted.size(), 3); + EXPECT_EQ(converted[0].size(), 4); + EXPECT_EQ(converted[1].size(), 4); + EXPECT_EQ(converted[1][2], &values[2]); } TEST(virtual_array_span, MultipleArrayConstructor) @@ -65,6 +79,15 @@ TEST(virtual_array_span, MultipleArrayConstructor) EXPECT_EQ(&span[2][0], values2.data()); EXPECT_EQ(span[2][0], 8); EXPECT_EQ(span[1][1], 7); + + GVArraySpan converted(span); + EXPECT_EQ(converted.type(), CPPType::get<int>()); + EXPECT_EQ(converted.size(), 3); + EXPECT_EQ(converted[0].size(), 4); + EXPECT_EQ(converted[1].size(), 2); + EXPECT_EQ(converted[2].size(), 1); + EXPECT_EQ(converted[0][0], values0.data()); + EXPECT_EQ(converted[1][1], values1.data() + 1); } TEST(generic_virtual_array_span, TypeConstructor) @@ -72,6 +95,9 @@ TEST(generic_virtual_array_span, TypeConstructor) GVArraySpan span{CPPType_int32}; EXPECT_EQ(span.size(), 0); EXPECT_TRUE(span.is_empty()); + + VArraySpan converted = span.typed<int>(); + EXPECT_EQ(converted.size(), 0); } TEST(generic_virtual_array_span, GSpanConstructor) @@ -86,6 +112,37 @@ TEST(generic_virtual_array_span, GSpanConstructor) EXPECT_EQ(span[0].size(), 3); EXPECT_EQ(span[2].size(), 3); EXPECT_EQ(*(std::string *)span[3][1], "world"); + + VArraySpan converted = span.typed<std::string>(); + EXPECT_EQ(converted.size(), 5); + EXPECT_EQ(converted[0][0], "hello"); + EXPECT_EQ(converted[1][0], "hello"); + EXPECT_EQ(converted[4][0], "hello"); + EXPECT_EQ(converted[0].size(), 3); + EXPECT_EQ(converted[2].size(), 3); +} + +TEST(generic_virtual_array_span, IsSingleArray1) +{ + Array<int> values = {5, 6, 7}; + GVArraySpan span{GSpan(values.as_span()), 4}; + EXPECT_TRUE(span.is_single_array()); + + VArraySpan converted = span.typed<int>(); + EXPECT_TRUE(converted.is_single_array()); +} + +TEST(generic_virtual_array_span, IsSingleArray2) +{ + GVectorArray vectors{CPPType_int32, 3}; + GVectorArrayRef<int> vectors_ref = vectors; + vectors_ref.append(1, 4); + + GVArraySpan span = vectors; + EXPECT_FALSE(span.is_single_array()); + + VArraySpan converted = span.typed<int>(); + EXPECT_FALSE(converted.is_single_array()); } } // namespace fn diff --git a/tests/gtests/functions/FN_generic_vector_array_test.cc b/tests/gtests/functions/FN_generic_vector_array_test.cc index 5840feb955d..c701fb9f678 100644 --- a/tests/gtests/functions/FN_generic_vector_array_test.cc +++ b/tests/gtests/functions/FN_generic_vector_array_test.cc @@ -97,5 +97,22 @@ TEST(generic_vector_array, TypedRef) EXPECT_EQ(ref[3][1], 6); } +TEST(generic_vector_array, Extend) +{ + GVectorArray vectors{CPPType_int32, 3}; + GVectorArrayRef<int> ref = vectors; + + ref.extend(1, {5, 6, 7}); + ref.extend(0, {3}); + + EXPECT_EQ(vectors[0].size(), 1); + EXPECT_EQ(vectors[1].size(), 3); + EXPECT_EQ(vectors[2].size(), 0); + EXPECT_EQ(ref[1][0], 5); + EXPECT_EQ(ref[1][1], 6); + EXPECT_EQ(ref[1][2], 7); + EXPECT_EQ(ref[0][0], 3); +} + } // namespace fn } // namespace blender diff --git a/tests/gtests/functions/FN_spans_test.cc b/tests/gtests/functions/FN_spans_test.cc index 551918a3aae..59797f69309 100644 --- a/tests/gtests/functions/FN_spans_test.cc +++ b/tests/gtests/functions/FN_spans_test.cc @@ -71,6 +71,11 @@ TEST(virtual_span, EmptyConstructor) VSpan<int> span; EXPECT_EQ(span.size(), 0); EXPECT_TRUE(span.is_empty()); + EXPECT_FALSE(span.is_single_element()); + + GVSpan converted(span); + EXPECT_EQ(converted.type(), CPPType::get<int>()); + EXPECT_EQ(converted.size(), 0); } TEST(virtual_span, SpanConstructor) @@ -83,6 +88,11 @@ TEST(virtual_span, SpanConstructor) EXPECT_EQ(virtual_span[0], 7); EXPECT_EQ(virtual_span[2], 8); EXPECT_EQ(virtual_span[3], 6); + EXPECT_FALSE(virtual_span.is_single_element()); + + GVSpan converted(span); + EXPECT_EQ(converted.type(), CPPType::get<int>()); + EXPECT_EQ(converted.size(), 5); } TEST(virtual_span, PointerSpanConstructor) @@ -98,6 +108,14 @@ TEST(virtual_span, PointerSpanConstructor) EXPECT_EQ(span[1], 7); EXPECT_EQ(span[2], 6); EXPECT_EQ(&span[1], &x2); + EXPECT_FALSE(span.is_single_element()); + + GVSpan converted(span); + EXPECT_EQ(converted.type(), CPPType::get<int>()); + EXPECT_EQ(converted.size(), 3); + EXPECT_EQ(converted[0], &x0); + EXPECT_EQ(converted[1], &x2); + EXPECT_EQ(converted[2], &x1); } TEST(virtual_span, SingleConstructor) @@ -112,6 +130,14 @@ TEST(virtual_span, SingleConstructor) EXPECT_EQ(&span[0], &value); EXPECT_EQ(&span[1], &value); EXPECT_EQ(&span[2], &value); + EXPECT_TRUE(span.is_single_element()); + + GVSpan converted(span); + EXPECT_EQ(converted.type(), CPPType::get<int>()); + EXPECT_EQ(converted.size(), 3); + EXPECT_EQ(converted[0], &value); + EXPECT_EQ(converted[1], &value); + EXPECT_EQ(converted[2], &value); } TEST(generic_virtual_span, TypeConstructor) @@ -119,6 +145,10 @@ TEST(generic_virtual_span, TypeConstructor) GVSpan span(CPPType_int32); EXPECT_EQ(span.size(), 0); EXPECT_TRUE(span.is_empty()); + EXPECT_FALSE(span.is_single_element()); + + VSpan<int> converted = span.typed<int>(); + EXPECT_EQ(converted.size(), 0); } TEST(generic_virtual_span, GenericSpanConstructor) @@ -131,6 +161,21 @@ TEST(generic_virtual_span, GenericSpanConstructor) EXPECT_EQ(span[1], &values[1]); EXPECT_EQ(span[2], &values[2]); EXPECT_EQ(span[3], &values[3]); + EXPECT_FALSE(span.is_single_element()); + + int materialized[4] = {0}; + span.materialize_to_uninitialized(materialized); + EXPECT_EQ(materialized[0], 3); + EXPECT_EQ(materialized[1], 4); + EXPECT_EQ(materialized[2], 5); + EXPECT_EQ(materialized[3], 6); + + VSpan<int> converted = span.typed<int>(); + EXPECT_EQ(converted.size(), 4); + EXPECT_EQ(converted[0], 3); + EXPECT_EQ(converted[1], 4); + EXPECT_EQ(converted[2], 5); + EXPECT_EQ(converted[3], 6); } TEST(generic_virtual_span, SpanConstructor) @@ -142,6 +187,19 @@ TEST(generic_virtual_span, SpanConstructor) EXPECT_EQ(span[0], &values[0]); EXPECT_EQ(span[1], &values[1]); EXPECT_EQ(span[2], &values[2]); + EXPECT_FALSE(span.is_single_element()); + + int materialized[3] = {0}; + span.materialize_to_uninitialized(materialized); + EXPECT_EQ(materialized[0], 6); + EXPECT_EQ(materialized[1], 7); + EXPECT_EQ(materialized[2], 8); + + VSpan<int> converted = span.typed<int>(); + EXPECT_EQ(converted.size(), 3); + EXPECT_EQ(converted[0], 6); + EXPECT_EQ(converted[1], 7); + EXPECT_EQ(converted[2], 8); } TEST(generic_virtual_span, SingleConstructor) @@ -153,6 +211,20 @@ TEST(generic_virtual_span, SingleConstructor) EXPECT_EQ(span[0], &value); EXPECT_EQ(span[1], &value); EXPECT_EQ(span[2], &value); + EXPECT_TRUE(span.is_single_element()); + EXPECT_EQ(span.as_single_element(), &value); + + int materialized[3] = {0}; + span.materialize_to_uninitialized({1, 2}, materialized); + EXPECT_EQ(materialized[0], 0); + EXPECT_EQ(materialized[1], 5); + EXPECT_EQ(materialized[2], 5); + + VSpan<int> converted = span.typed<int>(); + EXPECT_EQ(converted.size(), 3); + EXPECT_EQ(converted[0], 5); + EXPECT_EQ(converted[1], 5); + EXPECT_EQ(converted[2], 5); } } // namespace fn |