griefith/test
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?

19
tests/gtests/testing/testing.h
View File

@@ -10,6 +10,14 @@
#include <glog/logging.h> // IWYU pragma: export
#include <gtest/gtest.h> // IWYU pragma: export
/* Fwd.
*/
namespace blender {
template<typename T> class Span;
} // namespace blender
namespace blender::tests {
/* These strings are passed on the CLI with the --test-asset-dir and --test-release-dir arguments.
@@ -134,6 +142,17 @@ inline void EXPECT_EQ_VECTOR(const std::vector<T> &expected, const std::vector<T
}
}
template<typename T>
inline void EXPECT_EQ_SPAN(const blender::Span<T> expected, const blender::Span<T> actual)
{
EXPECT_EQ(expected.size(), actual.size());
if (expected.size() == actual.size()) {
for (const int64_t i : expected.index_range()) {
EXPECT_EQ(expected[i], actual[i]) << "Element mismatch at index " << i;
}
}
}
template<typename T>
inline void EXPECT_EQ_ARRAY(const T *expected, const T *actual, const size_t N)
{