Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/blender/blenlib/tests
diff options
context:
space:
mode:
Diffstat (limited to 'source/blender/blenlib/tests')
-rw-r--r--source/blender/blenlib/tests/BLI_array_test.cc2
-rw-r--r--source/blender/blenlib/tests/BLI_bounds_test.cc57
-rw-r--r--source/blender/blenlib/tests/BLI_index_mask_test.cc149
-rw-r--r--source/blender/blenlib/tests/BLI_math_base_test.cc21
-rw-r--r--source/blender/blenlib/tests/BLI_math_vec_types_test.cc25
-rw-r--r--source/blender/blenlib/tests/BLI_memory_utils_test.cc25
-rw-r--r--source/blender/blenlib/tests/BLI_span_test.cc3
-rw-r--r--source/blender/blenlib/tests/BLI_vector_test.cc3
8 files changed, 285 insertions, 0 deletions
diff --git a/source/blender/blenlib/tests/BLI_array_test.cc b/source/blender/blenlib/tests/BLI_array_test.cc
index 6d12b54099a..74eeb5e4e5e 100644
--- a/source/blender/blenlib/tests/BLI_array_test.cc
+++ b/source/blender/blenlib/tests/BLI_array_test.cc
@@ -231,9 +231,11 @@ TEST(array, Last)
{
Array<int> array = {5, 7, 8, 9};
EXPECT_EQ(array.last(), 9);
+ EXPECT_EQ(array.last(1), 8);
array.last() = 1;
EXPECT_EQ(array[3], 1);
EXPECT_EQ(const_cast<const Array<int> &>(array).last(), 1);
+ EXPECT_EQ(const_cast<const Array<int> &>(array).last(2), 7);
}
TEST(array, Reinitialize)
diff --git a/source/blender/blenlib/tests/BLI_bounds_test.cc b/source/blender/blenlib/tests/BLI_bounds_test.cc
new file mode 100644
index 00000000000..9c123d4705c
--- /dev/null
+++ b/source/blender/blenlib/tests/BLI_bounds_test.cc
@@ -0,0 +1,57 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+
+#include "testing/testing.h"
+
+#include "BLI_math_base.hh"
+
+#include "BLI_array.hh"
+#include "BLI_bounds.hh"
+
+namespace blender::tests {
+
+TEST(bounds, Empty)
+{
+ Span<float2> empty_span{};
+ EXPECT_TRUE(empty_span.is_empty());
+ auto result = bounds::min_max(empty_span);
+ EXPECT_EQ(result, std::nullopt);
+}
+
+TEST(bounds, MinMax)
+{
+ Array<float2> data = {float2(0, 1), float2(3, -1), float2(0, -2), float2(-1, 1)};
+ auto result = bounds::min_max(data.as_span());
+ EXPECT_EQ(result->min, float2(-1, -2));
+ EXPECT_EQ(result->max, float2(3, 1));
+}
+
+TEST(bounds, MinMaxFloat)
+{
+ Array<float> data = {1.0f, 3.0f, 0.0f, -1.0f};
+ auto result = bounds::min_max(data.as_span());
+ EXPECT_EQ(result->min, -1.0f);
+ EXPECT_EQ(result->max, 3.0f);
+}
+
+TEST(bounds, MinMaxRadii)
+{
+ Array<int2> data = {int2(0, 1), int2(3, -1), int2(0, -2), int2(-1, 1)};
+ Array<int> radii = {5, 1, 1, 4};
+ auto result = bounds::min_max_with_radii(data.as_span(), radii.as_span());
+ EXPECT_EQ(result->min, int2(-5, -4));
+ EXPECT_EQ(result->max, int2(5, 6));
+}
+
+TEST(bounds, Large)
+{
+ Array<int2> data(10000);
+ for (const int64_t i : data.index_range()) {
+ data[i] = int2(i, i);
+ }
+
+ auto result = bounds::min_max(data.as_span());
+ EXPECT_EQ(result->min, int2(0, 0));
+ EXPECT_EQ(result->max, int2(9999, 9999));
+}
+
+} // namespace blender::tests
diff --git a/source/blender/blenlib/tests/BLI_index_mask_test.cc b/source/blender/blenlib/tests/BLI_index_mask_test.cc
index 179c1c58cc4..86ae31cedcc 100644
--- a/source/blender/blenlib/tests/BLI_index_mask_test.cc
+++ b/source/blender/blenlib/tests/BLI_index_mask_test.cc
@@ -64,4 +64,153 @@ TEST(index_mask, SliceAndOffset)
}
}
+TEST(index_mask, ExtractRanges)
+{
+ {
+ Vector<int64_t> indices = {1, 2, 3, 5, 7, 8};
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges();
+ EXPECT_EQ(ranges.size(), 3);
+ EXPECT_EQ(ranges[0], IndexRange(1, 3));
+ EXPECT_EQ(ranges[1], IndexRange(5, 1));
+ EXPECT_EQ(ranges[2], IndexRange(7, 2));
+ }
+ {
+ Vector<int64_t> indices;
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges();
+ EXPECT_EQ(ranges.size(), 0);
+ }
+ {
+ Vector<int64_t> indices = {5, 6, 7, 8, 9, 10};
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges();
+ EXPECT_EQ(ranges.size(), 1);
+ EXPECT_EQ(ranges[0], IndexRange(5, 6));
+ }
+ {
+ Vector<int64_t> indices = {1, 3, 6, 8};
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges();
+ EXPECT_EQ(ranges.size(), 4);
+ EXPECT_EQ(ranges[0], IndexRange(1, 1));
+ EXPECT_EQ(ranges[1], IndexRange(3, 1));
+ EXPECT_EQ(ranges[2], IndexRange(6, 1));
+ EXPECT_EQ(ranges[3], IndexRange(8, 1));
+ }
+ {
+ Vector<int64_t> indices;
+ IndexRange range1{4, 10};
+ IndexRange range2{20, 30};
+ IndexRange range3{100, 1};
+ IndexRange range4{150, 100};
+ for (const IndexRange &range : {range1, range2, range3, range4}) {
+ for (const int64_t i : range) {
+ indices.append(i);
+ }
+ }
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges();
+ EXPECT_EQ(ranges.size(), 4);
+ EXPECT_EQ(ranges[0], range1);
+ EXPECT_EQ(ranges[1], range2);
+ EXPECT_EQ(ranges[2], range3);
+ EXPECT_EQ(ranges[3], range4);
+ }
+ {
+ const int64_t max_test_range_size = 50;
+ Vector<int64_t> indices;
+ int64_t offset = 0;
+ for (const int64_t range_size : IndexRange(1, max_test_range_size)) {
+ for (const int i : IndexRange(range_size)) {
+ indices.append(offset + i);
+ }
+ offset += range_size + 1;
+ }
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges();
+ EXPECT_EQ(ranges.size(), max_test_range_size);
+ for (const int64_t range_size : IndexRange(1, max_test_range_size)) {
+ const IndexRange range = ranges[range_size - 1];
+ EXPECT_EQ(range.size(), range_size);
+ }
+ }
+}
+
+TEST(index_mask, Invert)
+{
+ {
+ Vector<int64_t> indices;
+ Vector<int64_t> new_indices;
+ IndexMask inverted_mask = IndexMask(indices).invert(IndexRange(10), new_indices);
+ EXPECT_EQ(inverted_mask.size(), 10);
+ EXPECT_TRUE(new_indices.is_empty());
+ }
+ {
+ Vector<int64_t> indices = {3, 4, 5, 6};
+ Vector<int64_t> new_indices;
+ IndexMask inverted_mask = IndexMask(indices).invert(IndexRange(3, 4), new_indices);
+ EXPECT_TRUE(inverted_mask.is_empty());
+ }
+ {
+ Vector<int64_t> indices = {5};
+ Vector<int64_t> new_indices;
+ IndexMask inverted_mask = IndexMask(indices).invert(IndexRange(10), new_indices);
+ EXPECT_EQ(inverted_mask.size(), 9);
+ EXPECT_EQ(inverted_mask.indices(), Span<int64_t>({0, 1, 2, 3, 4, 6, 7, 8, 9}));
+ }
+ {
+ Vector<int64_t> indices = {0, 1, 2, 6, 7, 9};
+ Vector<int64_t> new_indices;
+ IndexMask inverted_mask = IndexMask(indices).invert(IndexRange(10), new_indices);
+ EXPECT_EQ(inverted_mask.size(), 4);
+ EXPECT_EQ(inverted_mask.indices(), Span<int64_t>({3, 4, 5, 8}));
+ }
+}
+
+TEST(index_mask, ExtractRangesInvert)
+{
+ {
+ Vector<int64_t> indices;
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges_invert(IndexRange(10), nullptr);
+ EXPECT_EQ(ranges.size(), 1);
+ EXPECT_EQ(ranges[0], IndexRange(10));
+ }
+ {
+ Vector<int64_t> indices = {1, 2, 3, 6, 7};
+ Vector<int64_t> skip_amounts;
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges_invert(IndexRange(10),
+ &skip_amounts);
+ EXPECT_EQ(ranges.size(), 3);
+ EXPECT_EQ(ranges[0], IndexRange(0, 1));
+ EXPECT_EQ(ranges[1], IndexRange(4, 2));
+ EXPECT_EQ(ranges[2], IndexRange(8, 2));
+ EXPECT_EQ(skip_amounts[0], 0);
+ EXPECT_EQ(skip_amounts[1], 3);
+ EXPECT_EQ(skip_amounts[2], 5);
+ }
+ {
+ Vector<int64_t> indices = {0, 1, 2, 3, 4};
+ Vector<int64_t> skip_amounts;
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges_invert(IndexRange(5),
+ &skip_amounts);
+ EXPECT_TRUE(ranges.is_empty());
+ EXPECT_TRUE(skip_amounts.is_empty());
+ }
+ {
+ Vector<int64_t> indices = {5, 6, 7, 10, 11};
+ Vector<int64_t> skip_amounts;
+ Vector<IndexRange> ranges = IndexMask(indices).extract_ranges_invert(IndexRange(5, 20),
+ &skip_amounts);
+ EXPECT_EQ(ranges.size(), 2);
+ EXPECT_EQ(ranges[0], IndexRange(8, 2));
+ EXPECT_EQ(ranges[1], IndexRange(12, 13));
+ EXPECT_EQ(skip_amounts[0], 3);
+ EXPECT_EQ(skip_amounts[1], 5);
+ }
+}
+
+TEST(index_mask, ContainedIn)
+{
+ EXPECT_TRUE(IndexMask({3, 4, 5}).contained_in(IndexRange(10)));
+ EXPECT_TRUE(IndexMask().contained_in(IndexRange(5, 0)));
+ EXPECT_FALSE(IndexMask({3}).contained_in(IndexRange(3)));
+ EXPECT_FALSE(IndexMask({4, 5, 6}).contained_in(IndexRange(5, 10)));
+ EXPECT_FALSE(IndexMask({5, 6}).contained_in(IndexRange()));
+}
+
} // namespace blender::tests
diff --git a/source/blender/blenlib/tests/BLI_math_base_test.cc b/source/blender/blenlib/tests/BLI_math_base_test.cc
index 33acefeeac2..62f2b2775d0 100644
--- a/source/blender/blenlib/tests/BLI_math_base_test.cc
+++ b/source/blender/blenlib/tests/BLI_math_base_test.cc
@@ -3,6 +3,10 @@
#include "testing/testing.h"
#include "BLI_math.h"
+#include "BLI_math_base.hh"
+#include "BLI_math_vector.hh"
+
+namespace blender::tests {
/* In tests below, when we are using -1.0f as max_diff value, we actually turn the function into a
* pure-ULP one. */
@@ -131,3 +135,20 @@ TEST(math_base, FloorPowerOf10)
EXPECT_NEAR(floor_power_of_10(100.1f), 100.0f, 1e-4f);
EXPECT_NEAR(floor_power_of_10(99.9f), 10.0f, 1e-4f);
}
+
+TEST(math_base, MinVectorAndFloat)
+{
+ EXPECT_EQ(math::min(1.0f, 2.0f), 1.0f);
+}
+
+TEST(math_base, ClampInt)
+{
+ EXPECT_EQ(math::clamp(111, -50, 101), 101);
+}
+
+TEST(math_base, Midpoint)
+{
+ EXPECT_NEAR(math::midpoint(100.0f, 200.0f), 150.0f, 1e-4f);
+}
+
+} // namespace blender::tests
diff --git a/source/blender/blenlib/tests/BLI_math_vec_types_test.cc b/source/blender/blenlib/tests/BLI_math_vec_types_test.cc
index 07eb6b29a20..7590d77525b 100644
--- a/source/blender/blenlib/tests/BLI_math_vec_types_test.cc
+++ b/source/blender/blenlib/tests/BLI_math_vec_types_test.cc
@@ -146,4 +146,29 @@ TEST(math_vec_types, VectorTypeConversion)
EXPECT_EQ(d[1], -1.0);
}
+TEST(math_vec_types, Divide)
+{
+ float2 a(1.0f, 2.0f);
+ float2 b(0.5f, 2.0f);
+ float2 result = a / b;
+ EXPECT_FLOAT_EQ(result.x, 2.0f);
+ EXPECT_FLOAT_EQ(result.y, 1.0f);
+}
+
+TEST(math_vec_types, DivideFloatByVector)
+{
+ float a = 2.0f;
+ float2 b(0.5f, 2.0f);
+ float2 result = a / b;
+ EXPECT_FLOAT_EQ(result.x, 4.0f);
+ EXPECT_FLOAT_EQ(result.y, 1.0f);
+}
+
+TEST(math_vec_types, DivideFloatByVectorSmall)
+{
+ float2 result = 2.0f / float2(2.0f);
+ EXPECT_FLOAT_EQ(result.x, 1.0f);
+ EXPECT_FLOAT_EQ(result.y, 1.0f);
+}
+
} // namespace blender::tests
diff --git a/source/blender/blenlib/tests/BLI_memory_utils_test.cc b/source/blender/blenlib/tests/BLI_memory_utils_test.cc
index 993434ddeba..ab716e5d011 100644
--- a/source/blender/blenlib/tests/BLI_memory_utils_test.cc
+++ b/source/blender/blenlib/tests/BLI_memory_utils_test.cc
@@ -176,4 +176,29 @@ static_assert(!is_same_any_v<int, float, bool>);
static_assert(!is_same_any_v<int, float>);
static_assert(!is_same_any_v<int>);
+TEST(memory_utils, ScopedDefer1)
+{
+ int a = 0;
+ {
+ BLI_SCOPED_DEFER([&]() { a -= 5; });
+ {
+ BLI_SCOPED_DEFER([&]() { a *= 10; });
+ a = 5;
+ }
+ }
+ EXPECT_EQ(a, 45);
+}
+
+TEST(memory_utils, ScopedDefer2)
+{
+ std::string s;
+ {
+ BLI_SCOPED_DEFER([&]() { s += "A"; });
+ BLI_SCOPED_DEFER([&]() { s += "B"; });
+ BLI_SCOPED_DEFER([&]() { s += "C"; });
+ BLI_SCOPED_DEFER([&]() { s += "D"; });
+ }
+ EXPECT_EQ(s, "DCBA");
+}
+
} // namespace blender::tests
diff --git a/source/blender/blenlib/tests/BLI_span_test.cc b/source/blender/blenlib/tests/BLI_span_test.cc
index 35fb22b3257..0bd34250deb 100644
--- a/source/blender/blenlib/tests/BLI_span_test.cc
+++ b/source/blender/blenlib/tests/BLI_span_test.cc
@@ -247,6 +247,8 @@ TEST(span, FirstLast)
Span<int> a_span(a);
EXPECT_EQ(a_span.first(), 6);
EXPECT_EQ(a_span.last(), 9);
+ EXPECT_EQ(a_span.last(1), 8);
+ EXPECT_EQ(a_span.last(2), 7);
}
TEST(span, FirstLast_OneElement)
@@ -255,6 +257,7 @@ TEST(span, FirstLast_OneElement)
Span<int> a_span(&a, 1);
EXPECT_EQ(a_span.first(), 3);
EXPECT_EQ(a_span.last(), 3);
+ EXPECT_EQ(a_span.last(0), 3);
}
TEST(span, Get)
diff --git a/source/blender/blenlib/tests/BLI_vector_test.cc b/source/blender/blenlib/tests/BLI_vector_test.cc
index 40cda20c395..29b6d2b41fe 100644
--- a/source/blender/blenlib/tests/BLI_vector_test.cc
+++ b/source/blender/blenlib/tests/BLI_vector_test.cc
@@ -447,6 +447,9 @@ TEST(vector, Last)
{
Vector<int> a{3, 5, 7};
EXPECT_EQ(a.last(), 7);
+ EXPECT_EQ(a.last(0), 7);
+ EXPECT_EQ(a.last(1), 5);
+ EXPECT_EQ(a.last(2), 3);
}
TEST(vector, AppendNTimes)
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-09 18:32:37 +0300