griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Tests: EXPECT_EQ_SPAN utility macro

Browse Source 
Replaces pointer based EXPECT_EQ_ARRAY with EXPECT_EQ_SPAN in most cases
as they already used spans (or span compatible datastructures).
Currently EXPECT_EQ_ARRAY only takes in one size variable and doesn't
compare the  number of elements between arguments (requiring an
additional line to do so).

This should make the code cleaner and safer. Goal is also to promote
the use Spans in new test code.

Pull Request: https://projects.blender.org/blender/blender/pulls/140340
This commit is contained in:
Mattias Fredriksson
2025-06-16 20:31:00 +02:00
committed by Hans Goudey
parent b03e64223c
commit 407dcb39d4
9 changed files with 82 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
source/blender/blenkernel/intern/curves_geometry_test.cc
View File

@@ -482,28 +482,26 @@ TEST(knot_vector, KnotVectorUniform)
{
constexpr int8_t order = 5;
constexpr int points_num = 7;
constexpr std::array<int, 12> expectation{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_NORMAL, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}), multiplicity);
}
TEST(knot_vector, KnotVectorUniformClamped)
{
constexpr int8_t order = 3;
constexpr int points_num = 7;
constexpr std::array<int, 6> expectation{3, 1, 1, 1, 1, 3};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_ENDPOINT, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({3, 1, 1, 1, 1, 3}), multiplicity);
}
/* -------------------------------------------------------------------- */
@@ -514,70 +512,65 @@ TEST(knot_vector, KnotVectorBezierClampedSegmentDeg2)
{
constexpr int8_t order = 3;
constexpr int points_num = 3;
constexpr std::array<int, 2> expectation{3, 3};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({3, 3}), multiplicity);
}
TEST(knot_vector, KnotVectorBezierClampedSegmentDeg4)
{
constexpr int8_t order = 5;
constexpr int points_num = 5;
constexpr std::array<int, 2> expectation{5, 5};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({5, 5}), multiplicity);
}
TEST(knot_vector, KnotVectorBezierClampedDeg2)
{
constexpr int8_t order = 3;
constexpr int points_num = 9;
constexpr std::array<int, 5> expectation{3, 2, 2, 2, 3};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({3, 2, 2, 2, 3}), multiplicity);
}
TEST(knot_vector, KnotVectorBezierClampedUnevenDeg2)
{
constexpr int8_t order = 3;
constexpr int points_num = 8;
constexpr std::array<int, 4> expectation{3, 2, 2, 4};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({3, 2, 2, 4}), multiplicity);
}
TEST(knot_vector, KnotVectorBezierClampedDeg4)
{
constexpr int8_t order = 5;
constexpr int points_num = 13;
constexpr std::array<int, 4> expectation{5, 4, 4, 5};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({5, 4, 4, 5}), multiplicity);
}
TEST(knot_vector, KnotVectorBezierClampedUnevenDeg4)
@@ -595,7 +588,7 @@ TEST(knot_vector, KnotVectorBezierClampedUnevenDeg4)
points_num[i], KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation[i].data(), multiplicity.data(), multiplicity.size());
EXPECT_EQ_SPAN<int>(Span(expectation[i]), multiplicity);
}
}
@@ -603,14 +596,13 @@ TEST(knot_vector, KnotVectorCircleCyclicUnevenDeg2)
{
constexpr int8_t order = 3;
constexpr int points_num = 8;
constexpr std::array<int, 7> expectation{1, 2, 2, 2, 2, 2, 2};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, true));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, true, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({1, 2, 2, 2, 2, 2, 2}), multiplicity);
}
TEST(knot_vector, KnotVectorBezierClampedCyclicUnevenDeg4)
@@ -628,7 +620,7 @@ TEST(knot_vector, KnotVectorBezierClampedCyclicUnevenDeg4)
points_num[i], KnotsMode::NURBS_KNOT_MODE_ENDPOINT_BEZIER, order, true, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation[i].data(), multiplicity.data(), multiplicity.size());
EXPECT_EQ_SPAN<int>(Span(expectation[i]), multiplicity);
}
}
@@ -642,14 +634,13 @@ TEST(knot_vector, KnotVectorBezierSegmentDeg2)
{
constexpr int8_t order = 4;
constexpr int points_num = 4;
constexpr std::array<int, 3> expectation{2, 3, 3};
Vector<float> knots(curves::nurbs::knots_num(points_num, order, false));
curves::nurbs::calculate_knots(
points_num, KnotsMode::NURBS_KNOT_MODE_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation.data(), multiplicity.data(), expectation.size());
EXPECT_EQ_SPAN<int>(Span({2, 3, 3}), multiplicity);
}
TEST(knot_vector, KnotVectorBezierUnevenDeg2)
@@ -667,7 +658,7 @@ TEST(knot_vector, KnotVectorBezierUnevenDeg2)
points_num[i], KnotsMode::NURBS_KNOT_MODE_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation[i].data(), multiplicity.data(), multiplicity.size());
EXPECT_EQ_SPAN<int>(Span(expectation[i].data(), multiplicity.size()), multiplicity);
}
}
@@ -688,7 +679,7 @@ TEST(knot_vector, KnotVectorBezierUnevenDeg4)
points_num[i], KnotsMode::NURBS_KNOT_MODE_BEZIER, order, false, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation[i].data(), multiplicity.data(), multiplicity.size());
EXPECT_EQ_SPAN<int>(Span(expectation[i].data(), multiplicity.size()), multiplicity);
}
}
@@ -707,7 +698,7 @@ TEST(knot_vector, KnotVectorBezierCyclicUnevenDeg4)
points_num[i], KnotsMode::NURBS_KNOT_MODE_BEZIER, order, true, knots);
const Vector<int> multiplicity = curves::nurbs::calculate_multiplicity_sequence(knots);
EXPECT_EQ_ARRAY(expectation[i].data(), multiplicity.data(), multiplicity.size());
EXPECT_EQ_SPAN<int>(Span(expectation[i].data(), multiplicity.size()), multiplicity);
}
}

4
source/blender/blenlib/tests/BLI_array_test.cc
View File

@@ -189,8 +189,8 @@ TEST(array, ReverseIterator)
*it += 10;
}
EXPECT_EQ_ARRAY(reversed_vec.data(), Span({6, 5, 4, 3}).data(), 4);
EXPECT_EQ_ARRAY(array.data(), Span({13, 14, 15, 16}).data(), 4);
EXPECT_EQ_SPAN<int>(reversed_vec, Span({6, 5, 4, 3}));
EXPECT_EQ_SPAN<int>(array, Span({13, 14, 15, 16}));
}
TEST(array, SpanConstructorExceptions)

14
source/blender/blenlib/tests/BLI_span_test.cc
View File

@@ -367,7 +367,7 @@ TEST(span, ReverseIterator)
reversed_vec.append(*it);
}
EXPECT_EQ(reversed_vec.size(), 4);
EXPECT_EQ_ARRAY(reversed_vec.data(), Span({7, 6, 5, 4}).data(), 4);
EXPECT_EQ_SPAN<int>(reversed_vec, Span({7, 6, 5, 4}));
}
TEST(span, ReverseMutableSpan)
@@ -375,22 +375,22 @@ TEST(span, ReverseMutableSpan)
std::array<int, 0> src0 = {};
MutableSpan<int> span0 = src0;
span0.reverse();
EXPECT_EQ_ARRAY(span0.data(), Span<int>({}).data(), 0);
EXPECT_EQ_SPAN<int>(span0, Span<int>({}));
std::array<int, 1> src1 = {4};
MutableSpan<int> span1 = src1;
span1.reverse();
EXPECT_EQ_ARRAY(span1.data(), Span<int>({4}).data(), 1);
EXPECT_EQ_SPAN<int>(span1, Span({4}));
std::array<int, 2> src2 = {4, 5};
MutableSpan<int> span2 = src2;
span2.reverse();
EXPECT_EQ_ARRAY(span2.data(), Span<int>({5, 4}).data(), 2);
EXPECT_EQ_SPAN<int>(span2, Span({5, 4}));
std::array<int, 5> src5 = {4, 5, 6, 7, 8};
MutableSpan<int> span5 = src5;
span5.reverse();
EXPECT_EQ_ARRAY(span5.data(), Span<int>({8, 7, 6, 5, 4}).data(), 5);
EXPECT_EQ_SPAN<int>(span5, Span({8, 7, 6, 5, 4}));
}
TEST(span, MutableReverseIterator)
@@ -404,8 +404,8 @@ TEST(span, MutableReverseIterator)
*it += 10;
}
EXPECT_EQ(reversed_vec.size(), 4);
EXPECT_EQ_ARRAY(reversed_vec.data(), Span({7, 6, 5, 4}).data(), 4);
EXPECT_EQ_ARRAY(src.data(), Span({14, 15, 16, 17}).data(), 4);
EXPECT_EQ_SPAN<int>(reversed_vec, Span({7, 6, 5, 4}));
EXPECT_EQ_SPAN<int>(src, Span({14, 15, 16, 17}));
}
TEST(span, Constexpr)

16
source/blender/blenlib/tests/BLI_vector_test.cc
View File

@@ -299,7 +299,7 @@ TEST(vector, ExtendIterator)
std::forward_list<int> list = {8, 9};
vec.extend(list.begin(), list.end());
EXPECT_EQ(vec.size(), 5);
EXPECT_EQ_ARRAY(vec.data(), Span({3, 4, 5, 8, 9}).data(), 5);
EXPECT_EQ_SPAN<int>(vec, Span({3, 4, 5, 8, 9}));
}
TEST(vector, Iterator)
@@ -429,7 +429,7 @@ TEST(vector, RemoveIf)
EXPECT_EQ(vec.size() + removed, 8);
const Vector<int> expected_vec = {1, 3, 5, 7};
EXPECT_EQ(vec.size(), expected_vec.size());
EXPECT_EQ_ARRAY(vec.data(), expected_vec.data(), size_t(vec.size()));
EXPECT_EQ_SPAN<int>(vec, expected_vec);
}
TEST(vector, RemoveIfNonTrivialDestructible)
@@ -746,7 +746,7 @@ TEST(vector, InsertAtBeginning)
Vector<int> vec = {1, 2, 3};
vec.insert(0, {6, 7});
EXPECT_EQ(vec.size(), 5);
EXPECT_EQ_ARRAY(vec.data(), Span({6, 7, 1, 2, 3}).data(), 5);
EXPECT_EQ_SPAN<int>(vec, Span({6, 7, 1, 2, 3}));
}
TEST(vector, InsertAtEnd)
@@ -754,7 +754,7 @@ TEST(vector, InsertAtEnd)
Vector<int> vec = {1, 2, 3};
vec.insert(3, {6, 7});
EXPECT_EQ(vec.size(), 5);
EXPECT_EQ_ARRAY(vec.data(), Span({1, 2, 3, 6, 7}).data(), 5);
EXPECT_EQ_SPAN<int>(vec, Span({1, 2, 3, 6, 7}));
}
TEST(vector, InsertInMiddle)
@@ -762,7 +762,7 @@ TEST(vector, InsertInMiddle)
Vector<int> vec = {1, 2, 3};
vec.insert(1, {6, 7});
EXPECT_EQ(vec.size(), 5);
EXPECT_EQ_ARRAY(vec.data(), Span({1, 6, 7, 2, 3}).data(), 5);
EXPECT_EQ_SPAN<int>(vec, Span({1, 6, 7, 2, 3}));
}
TEST(vector, InsertAtIterator)
@@ -771,7 +771,7 @@ TEST(vector, InsertAtIterator)
Vector<std::string> other_vec = {"hello", "world"};
vec.insert(vec.begin() + 1, other_vec.begin(), other_vec.end());
EXPECT_EQ(vec.size(), 5);
EXPECT_EQ_ARRAY(vec.data(), Span<std::string>({"1", "hello", "world", "2", "3"}).data(), 5);
EXPECT_EQ_SPAN<std::string>(vec, Span<std::string>({"1", "hello", "world", "2", "3"}));
}
TEST(vector, InsertMoveOnlyType)
@@ -791,7 +791,7 @@ TEST(vector, Prepend)
Vector<int> vec = {1, 2, 3};
vec.prepend({7, 8});
EXPECT_EQ(vec.size(), 5);
EXPECT_EQ_ARRAY(vec.data(), Span({7, 8, 1, 2, 3}).data(), 5);
EXPECT_EQ_SPAN<int>(vec, Span({7, 8, 1, 2, 3}));
}
TEST(vector, PrependString)
@@ -813,7 +813,7 @@ TEST(vector, ReverseIterator)
reversed_vec.append(*it);
}
EXPECT_EQ(reversed_vec.size(), 4);
EXPECT_EQ_ARRAY(reversed_vec.data(), Span({7, 6, 5, 4}).data(), 4);
EXPECT_EQ_SPAN<int>(reversed_vec, Span({7, 6, 5, 4}));
}
TEST(vector, SizeValueConstructorExceptions)

6
source/blender/draw/tests/eevee_test.cc
View File

@@ -1920,10 +1920,10 @@ static void test_eevee_surfel_list()
// Span<int>(list_start_buf.data(), expect_list_start.size()).print_as_lines("list_start");
// link_next.as_span().print_as_lines("link_next");
// link_prev.as_span().print_as_lines("link_prev");
EXPECT_EQ_ARRAY(expect_list_start.data(), list_start_buf.data(), expect_list_start.size());
EXPECT_EQ_SPAN(expect_list_start, list_start_buf);
#endif
EXPECT_EQ_ARRAY(expect_link_next.data(), link_next.data(), expect_link_next.size());
EXPECT_EQ_ARRAY(expect_link_prev.data(), link_prev.data(), expect_link_prev.size());
EXPECT_EQ_SPAN(expect_link_next, link_next);
EXPECT_EQ_SPAN(expect_link_prev, link_prev);
GPU_shader_unbind();

46
source/blender/geometry/tests/GEO_merge_curves_test.cc
View File

@@ -49,8 +49,8 @@ TEST(merge_curves, NoConnections)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 4);
EXPECT_EQ_ARRAY(Span({0, 3, 6, 9, 12}).data(), dst_curves.offsets().data(), 5);
EXPECT_EQ_ARRAY(Span({false, true, true, false}).data(), cyclic.data(), 4);
EXPECT_EQ_SPAN(Span({0, 3, 6, 9, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({false, true, true, false}), cyclic);
}
TEST(merge_curves, ConnectSingleCurve)
@@ -68,9 +68,9 @@ TEST(merge_curves, ConnectSingleCurve)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 3);
EXPECT_EQ_ARRAY(Span({0, 3, 6, 12}).data(), dst_curves.offsets().data(), 4);
EXPECT_EQ_ARRAY(Span({false, true, false}).data(), cyclic.data(), 3);
EXPECT_EQ_ARRAY(Span({0, 1, 2, 6, 7, 8, 9, 10, 11, 3, 4, 5}).data(), dst_indices.data(), 12);
EXPECT_EQ_SPAN(Span({0, 3, 6, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({false, true, false}), cyclic);
EXPECT_EQ_SPAN(Span({0, 1, 2, 6, 7, 8, 9, 10, 11, 3, 4, 5}), dst_indices);
}
TEST(merge_curves, ReverseCurves)
@@ -88,9 +88,9 @@ TEST(merge_curves, ReverseCurves)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 4);
EXPECT_EQ_ARRAY(Span({0, 3, 6, 9, 12}).data(), dst_curves.offsets().data(), 5);
EXPECT_EQ_ARRAY(Span({false, true, true, false}).data(), cyclic.data(), 3);
EXPECT_EQ_ARRAY(Span({0, 1, 2, 5, 4, 3, 6, 7, 8, 11, 10, 9}).data(), dst_indices.data(), 12);
EXPECT_EQ_SPAN(Span({0, 3, 6, 9, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({false, true, true, false}), cyclic);
EXPECT_EQ_SPAN(Span({0, 1, 2, 5, 4, 3, 6, 7, 8, 11, 10, 9}), dst_indices);
}
TEST(merge_curves, ConnectAndReverseCurves)
@@ -108,9 +108,9 @@ TEST(merge_curves, ConnectAndReverseCurves)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 2);
EXPECT_EQ_ARRAY(Span({0, 9, 12}).data(), dst_curves.offsets().data(), 3);
EXPECT_EQ_ARRAY(Span({false, true}).data(), cyclic.data(), 2);
EXPECT_EQ_ARRAY(Span({3, 4, 5, 2, 1, 0, 9, 10, 11, 8, 7, 6}).data(), dst_indices.data(), 12);
EXPECT_EQ_SPAN(Span({0, 9, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({false, true}), cyclic);
EXPECT_EQ_SPAN(Span({3, 4, 5, 2, 1, 0, 9, 10, 11, 8, 7, 6}), dst_indices);
}
TEST(merge_curves, CyclicConnection)
@@ -128,9 +128,9 @@ TEST(merge_curves, CyclicConnection)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 3);
EXPECT_EQ_ARRAY(Span({0, 3, 9, 12}).data(), dst_curves.offsets().data(), 4);
EXPECT_EQ_ARRAY(Span({false, true, true}).data(), cyclic.data(), 3);
EXPECT_EQ_ARRAY(Span({0, 1, 2, 3, 4, 5, 9, 10, 11, 6, 7, 8}).data(), dst_indices.data(), 12);
EXPECT_EQ_SPAN(Span({0, 3, 9, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({false, true, true}), cyclic);
EXPECT_EQ_SPAN(Span({0, 1, 2, 3, 4, 5, 9, 10, 11, 6, 7, 8}), dst_indices);
}
TEST(merge_curves, SelfConnectCurve)
@@ -148,9 +148,9 @@ TEST(merge_curves, SelfConnectCurve)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 4);
EXPECT_EQ_ARRAY(Span({0, 3, 6, 9, 12}).data(), dst_curves.offsets().data(), 5);
EXPECT_EQ_ARRAY(Span({false, true, true, false}).data(), cyclic.data(), 4);
EXPECT_EQ_ARRAY(Span({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}).data(), dst_indices.data(), 12);
EXPECT_EQ_SPAN(Span({0, 3, 6, 9, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({false, true, true, false}), cyclic);
EXPECT_EQ_SPAN(Span({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}), dst_indices);
}
TEST(merge_curves, MergeAll)
@@ -168,9 +168,9 @@ TEST(merge_curves, MergeAll)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 1);
EXPECT_EQ_ARRAY(Span({0, 12}).data(), dst_curves.offsets().data(), 2);
EXPECT_EQ_ARRAY(Span({true}).data(), cyclic.data(), 1);
EXPECT_EQ_ARRAY(Span({0, 1, 2, 6, 7, 8, 9, 10, 11, 3, 4, 5}).data(), dst_indices.data(), 12);
EXPECT_EQ_SPAN(Span({0, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({true}), cyclic);
EXPECT_EQ_SPAN(Span({0, 1, 2, 6, 7, 8, 9, 10, 11, 3, 4, 5}), dst_indices);
}
TEST(merge_curves, Branching)
@@ -189,9 +189,9 @@ TEST(merge_curves, Branching)
EXPECT_EQ(dst_curves.points_num(), 12);
EXPECT_EQ(dst_curves.curves_num(), 3);
EXPECT_EQ_ARRAY(Span({0, 6, 9, 12}).data(), dst_curves.offsets().data(), 4);
EXPECT_EQ_ARRAY(Span({false, false, false}).data(), cyclic.data(), 3);
EXPECT_EQ_ARRAY(Span({0, 1, 2, 6, 7, 8, 3, 4, 5, 9, 10, 11}).data(), dst_indices.data(), 12);
EXPECT_EQ_SPAN(Span({0, 6, 9, 12}), dst_curves.offsets());
EXPECT_EQ_SPAN(Span({false, false, false}), cyclic);
EXPECT_EQ_SPAN(Span({0, 1, 2, 6, 7, 8, 3, 4, 5, 9, 10, 11}), dst_indices);
}
} // namespace blender::geometry::tests

10
source/blender/gpu/tests/storage_buffer_test.cc
View File

@@ -149,7 +149,7 @@ static void test_storage_buffer_copy_from_vertex_buffer()
for (int i : IndexRange(4)) {
GPU_vertbuf_vert_set(vbo, i, &data[i]);
}
float *expected_data = static_cast<float *>(static_cast<void *>(&data));
Span<float> expected_data(static_cast<float *>(static_cast<void *>(&data)), 24);
Vector<float> read_data;
read_data.resize(SIZE, 0);
@@ -161,7 +161,7 @@ static void test_storage_buffer_copy_from_vertex_buffer()
/* Validate content of SSBO. */
GPU_storagebuf_read(ssbo, read_data.data());
EXPECT_EQ_ARRAY(expected_data, read_data.data(), 24);
EXPECT_EQ_SPAN(expected_data, read_data);
for (int i : IndexRange(24, SIZE - 24)) {
EXPECT_EQ(0.0, read_data[i]);
}
@@ -177,8 +177,7 @@ static void test_storage_buffer_copy_from_vertex_buffer()
for (int i : IndexRange(4)) {
EXPECT_EQ(0.0, read_data[i]);
}
float *expected_data = static_cast<float *>(static_cast<void *>(&data));
EXPECT_EQ_ARRAY(expected_data, &(read_data.data()[4]), 24);
EXPECT_EQ_SPAN(expected_data, read_data.as_span().slice(4, 24));
for (int i : IndexRange(28, SIZE - 28)) {
EXPECT_EQ(0.0, read_data[i]);
}
@@ -194,8 +193,7 @@ static void test_storage_buffer_copy_from_vertex_buffer()
for (int i : IndexRange(4)) {
EXPECT_EQ(0.0, read_data[i]);
}
float *expected_data = static_cast<float *>(static_cast<void *>(&data));
EXPECT_EQ_ARRAY(&expected_data[6], &(read_data.data()[4]), 12);
EXPECT_EQ_SPAN(expected_data.slice(6, 12), read_data.as_span().slice(4, 12));
for (int i : IndexRange(16, SIZE - 16)) {
EXPECT_EQ(0.0, read_data[i]);
}

6
source/blender/io/ply/tests/io_ply_importer_test.cc
View File

@@ -56,10 +56,8 @@ TEST(ply_import, BufferRefillTest)
{5, 4},
{0, 4},
{5, 1}};
EXPECT_EQ(12, data_a->edges.size());
EXPECT_EQ(12, data_b->edges.size());
EXPECT_EQ_ARRAY(exp_edges, data_a->edges.data(), 12);
EXPECT_EQ_ARRAY(exp_edges, data_b->edges.data(), 12);
EXPECT_EQ_SPAN<std::pair<int, int>>(Span(exp_edges, 12), data_a->edges);
EXPECT_EQ_SPAN<std::pair<int, int>>(Span(exp_edges, 12), data_b->edges);
}
//@TODO: now we put vertex color attribute first, maybe put position first?