Blender V5.3
BLI_virtual_array_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "BLI_array.hh"
7#include "BLI_vector.hh"
8#include "BLI_vector_set.hh"
11
12#include "testing/testing.h"
13
14#include "BLI_strict_flags.hh" /* IWYU pragma: keep. Keep last. */
15
16namespace blender::tests {
17
18class VirtualArrayTest : public testing::Test {
19 public:
20 static void SetUpTestSuite()
21 {
23 }
24};
25
27{
28 std::array<int, 5> data = {3, 4, 5, 6, 7};
30 EXPECT_EQ(varray.size(), 5);
31 EXPECT_EQ(varray.get(0), 3);
32 EXPECT_EQ(varray.get(4), 7);
33 EXPECT_TRUE(varray.is_span());
34 EXPECT_FALSE(varray.is_single());
35 EXPECT_EQ(varray.get_internal_span().data(), data.data());
36}
37
39{
41 EXPECT_EQ(varray.size(), 4);
42 EXPECT_EQ(varray.get(0), 10);
43 EXPECT_EQ(varray.get(3), 10);
44 EXPECT_FALSE(varray.is_span());
45 EXPECT_TRUE(varray.is_single());
46 EXPECT_EQ(varray.get_internal_single(), 10);
47}
48
50{
51 Array<int> array = {1, 2, 3, 5, 8};
52 {
54 EXPECT_EQ(varray.size(), 5);
55 EXPECT_EQ(varray[0], 1);
56 EXPECT_EQ(varray[2], 3);
57 EXPECT_EQ(varray[3], 5);
58 EXPECT_TRUE(varray.is_span());
59 }
60 {
62 EXPECT_EQ(varray.size(), 5);
63 EXPECT_EQ(varray[0], 1);
64 EXPECT_EQ(varray[2], 3);
65 EXPECT_EQ(varray[3], 5);
66 EXPECT_TRUE(varray.is_span());
67 }
68 {
69 VArray<int> varray = VArray<int>::from_container(array); /* NOLINT: bugprone-use-after-move */
70 EXPECT_TRUE(varray.is_empty());
71 }
72}
73
75{
76 Array<int, 0> array = {1, 2, 3, 5, 8};
77 const Span<int> array_span = array;
79 EXPECT_TRUE(varray.is_span());
80 EXPECT_EQ(varray.size(), 5);
81 EXPECT_EQ(varray[0], 1);
82 EXPECT_EQ(varray[2], 3);
83 EXPECT_EQ(varray[3], 5);
84 EXPECT_EQ(varray[4], 8);
85 varray.set(2, 100);
86 EXPECT_EQ(varray[2], 100);
87
88 const Span<int> varray_span = varray.get_internal_span();
89 EXPECT_EQ(array_span, varray_span);
90 EXPECT_EQ(array_span.data(), varray_span.data());
91}
92
94{
95 Vector<int> vector = {9, 8, 7, 6};
96 VArray<int> varray = VArray<int>::from_container(std::move(vector));
97 EXPECT_EQ(varray.size(), 4);
98 EXPECT_EQ(varray[0], 9);
99 EXPECT_EQ(varray[3], 6);
100}
101
103{
104 std::vector<int> vector = {5, 6, 7, 8};
105 VArray<int> varray = VArray<int>::from_container(std::move(vector));
106 EXPECT_EQ(varray.size(), 4);
107 EXPECT_EQ(varray[0], 5);
108 EXPECT_EQ(varray[1], 6);
109}
110
112{
113 std::array<int, 4> array = {2, 3, 4, 5};
114 VArray<int> varray = VArray<int>::from_container(std::move(array));
115 EXPECT_EQ(varray.size(), 4);
116 EXPECT_EQ(varray[0], 2);
117 EXPECT_EQ(varray[1], 3);
118}
119
121{
122 VectorSet<int> vector_set = {5, 3, 7, 3, 3, 5, 1};
123 VArray<int> varray = VArray<int>::from_container(std::move(vector_set));
124 EXPECT_TRUE(vector_set.is_empty()); /* NOLINT: bugprone-use-after-move. */
125 EXPECT_EQ(varray.size(), 4);
126 EXPECT_EQ(varray[0], 5);
127 EXPECT_EQ(varray[1], 3);
128 EXPECT_EQ(varray[2], 7);
129 EXPECT_EQ(varray[3], 1);
130}
131
133{
134 auto func = [](int64_t index) { return int(index * index); };
135 VArray<int> varray = VArray<int>::from_func(10, func);
136 EXPECT_EQ(varray.size(), 10);
137 EXPECT_EQ(varray[0], 0);
138 EXPECT_EQ(varray[3], 9);
139 EXPECT_EQ(varray[9], 81);
140}
141
143{
144 auto func = [](int64_t index) { return int(10 * index); };
145 VArray<int> func_varray = VArray<int>::from_func(10, func);
146 VArraySpan span_varray{func_varray};
147 EXPECT_EQ(span_varray.size(), 10);
148 Span<int> span = span_varray;
149 EXPECT_EQ(span.size(), 10);
150 EXPECT_EQ(span[0], 0);
151 EXPECT_EQ(span[3], 30);
152 EXPECT_EQ(span[6], 60);
153}
154
155static int get_x(const std::array<int, 3> &item)
156{
157 return item[0];
158}
159
160static void set_x(std::array<int, 3> &item, int value)
161{
162 item[0] = value;
163}
164
166{
168 vector.append({3, 4, 5});
169 vector.append({1, 1, 1});
170 {
171 VArray<int> varray = VArray<int>::from_derived_span<std::array<int, 3>, get_x>(vector);
172 EXPECT_EQ(varray.size(), 2);
173 EXPECT_EQ(varray[0], 3);
174 EXPECT_EQ(varray[1], 1);
175 }
176 {
177 VMutableArray<int> varray =
178 VMutableArray<int>::from_derived_span<std::array<int, 3>, get_x, set_x>(vector);
179 EXPECT_EQ(varray.size(), 2);
180 EXPECT_EQ(varray[0], 3);
181 EXPECT_EQ(varray[1], 1);
182 varray.set(0, 10);
183 varray.set(1, 20);
184 EXPECT_EQ(vector[0][0], 10);
185 EXPECT_EQ(vector[1][0], 20);
186 }
187}
188
189TEST_F(VirtualArrayTest, MutableToImmutable)
190{
191 std::array<int, 4> array = {4, 2, 6, 4};
192 {
194 VArray<int> varray = mutable_varray;
195 EXPECT_TRUE(varray.is_span());
196 EXPECT_EQ(varray.size(), 4);
197 EXPECT_EQ(varray[1], 2);
198 EXPECT_EQ(mutable_varray.size(), 4);
199 }
200 {
202 EXPECT_EQ(mutable_varray.size(), 4);
203 VArray<int> varray = std::move(mutable_varray);
204 EXPECT_TRUE(varray.is_span());
205 EXPECT_EQ(varray.size(), 4);
206 EXPECT_EQ(varray[1], 2);
207 EXPECT_EQ(mutable_varray.size(), 0); /* NOLINT: bugprone-use-after-move */
208 }
209 {
211 EXPECT_TRUE(varray.is_span());
212 EXPECT_EQ(varray.size(), 4);
213 EXPECT_EQ(varray[1], 2);
214 }
215}
216
217TEST_F(VirtualArrayTest, MaterializeCompressed)
218{
219 IndexMaskMemory memory;
220 {
221 std::array<int, 10> array = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
223 std::array<int, 3> compressed_array;
225 compressed_array);
226 EXPECT_EQ(compressed_array[0], 30);
227 EXPECT_EQ(compressed_array[1], 60);
228 EXPECT_EQ(compressed_array[2], 70);
230 compressed_array);
231 EXPECT_EQ(compressed_array[0], 20);
232 EXPECT_EQ(compressed_array[1], 80);
233 EXPECT_EQ(compressed_array[2], 90);
234 }
235 {
237 std::array<int, 3> compressed_array;
239 compressed_array);
240 EXPECT_EQ(compressed_array[0], 4);
241 EXPECT_EQ(compressed_array[1], 4);
242 EXPECT_EQ(compressed_array[2], 4);
243 compressed_array.fill(0);
245 compressed_array);
246 EXPECT_EQ(compressed_array[0], 4);
247 EXPECT_EQ(compressed_array[1], 4);
248 EXPECT_EQ(compressed_array[2], 4);
249 }
250 {
251 VArray<int> varray = VArray<int>::from_func(10, [](const int64_t i) { return int(i * i); });
252 std::array<int, 3> compressed_array;
254 compressed_array);
255 EXPECT_EQ(compressed_array[0], 25);
256 EXPECT_EQ(compressed_array[1], 49);
257 EXPECT_EQ(compressed_array[2], 64);
259 compressed_array);
260 EXPECT_EQ(compressed_array[0], 1);
261 EXPECT_EQ(compressed_array[1], 4);
262 EXPECT_EQ(compressed_array[2], 9);
263 }
264}
265
266TEST_F(VirtualArrayTest, EmptySpanWrapper)
267{
268 {
269 VArray<int> varray;
270 VArraySpan<int> span1 = varray;
271 EXPECT_TRUE(span1.is_empty());
272 VArraySpan<int> span2 = std::move(span1);
273 EXPECT_TRUE(span2.is_empty());
274 }
275 {
276 VMutableArray<int> varray;
277 MutableVArraySpan<int> span1 = varray;
278 EXPECT_TRUE(span1.is_empty());
279 MutableVArraySpan<int> span2 = std::move(span1);
280 EXPECT_TRUE(span2.is_empty());
281 }
282 {
283 GVArray varray;
284 GVArraySpan span1 = varray;
285 EXPECT_TRUE(span1.is_empty());
286 GVArraySpan span2 = std::move(span1);
287 EXPECT_TRUE(span2.is_empty());
288 }
289 {
290 GVMutableArray varray;
291 GMutableVArraySpan span1 = varray;
292 EXPECT_TRUE(span1.is_empty());
293 GMutableVArraySpan span2 = std::move(span1);
294 EXPECT_TRUE(span2.is_empty());
295 }
296}
297
298TEST_F(VirtualArrayTest, SingleValueRangeSpans)
299{
300 const VArray<int> varray = VArray<int>::from_single(42, 10);
301 ResourceScope scope;
302 const VArrayRangeSpans<int> spans(scope, varray, 3);
303
307 EXPECT_EQ_SPAN(span1, {42, 42, 42});
308 EXPECT_EQ(span1.data(), span2.data());
309 EXPECT_EQ(span1.data(), span3.data());
310}
311
312TEST_F(VirtualArrayTest, SpanRangeSpans)
313{
314 const Array<int> array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
316 ResourceScope scope;
317 const VArrayRangeSpans<int> spans(scope, varray, 3);
318
320 EXPECT_EQ(span1.data(), array.data());
321
323 EXPECT_EQ(span2.data(), &array[7]);
324
326 EXPECT_EQ(span3.data(), &array[5]);
327}
328
329TEST_F(VirtualArrayTest, ArrayRangeSpans)
330{
331 const VArray<int> varray = VArray<int>::from_container(Array<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
332 ResourceScope scope;
333 const VArrayRangeSpans<int> spans(scope, varray, 3);
334
338
339 EXPECT_EQ(span1.data() + 7, span2.data());
340 EXPECT_EQ(span1.data() + 5, span3.data());
341}
342
343TEST_F(VirtualArrayTest, FunctionRangeSpans)
344{
345 const VArray<int> varray = VArray<int>::from_std_func(10, [](const int64_t i) { return i; });
346 ResourceScope scope;
347 const VArrayRangeSpans<int> spans(scope, varray, 3);
348
350 EXPECT_EQ_SPAN(span1, {0, 1, 2});
351
353 EXPECT_EQ_SPAN(span2, {7, 8, 9});
354
356 EXPECT_EQ_SPAN(span3, {5});
357}
358
359TEST(generic_virtual_array, FromFunc)
360{
361 GVArray gvarray = GVArray::from_func(
362 CPPType::get<std::string>(), 10, [](const int64_t i, void *r_value) {
363 new (r_value) std::string(std::to_string(i));
364 });
365 VArray<std::string> varray = gvarray.typed<std::string>();
366 EXPECT_EQ(varray.size(), 10);
367 EXPECT_EQ(varray[0], "0");
368 EXPECT_EQ(varray[3], "3");
369 EXPECT_EQ(varray[9], "9");
370}
371
372} // namespace blender::tests
static const CPPType & get()
bool is_empty() const
static GVArray from_func(const CPPType &type, int64_t size, GetToUninitFn &&get_to_uninit)
static IndexMask from_indices(Span< T > indices, LinearAllocator<> &memory)
static constexpr IndexRange from_begin_size(const int64_t begin, const int64_t size)
constexpr const T * data() const
Definition BLI_span.hh:219
constexpr int64_t size() const
Definition BLI_span.hh:256
void materialize_compressed_to_uninitialized(const IndexMask &mask, MutableSpan< T > r_span) const
T get(const int64_t index) const
void materialize_compressed(const IndexMask &mask, MutableSpan< T > r_span) const
Span< T > get_internal_span() const
Span< T > get_span_for_range(const IndexRange range) const
static VArray from_derived_span(Span< StructT > values)
static VArray from_std_func(const int64_t size, std::function< T(int64_t index)> get_func)
static VArray from_single(T value, const int64_t size)
static VArray from_func(const int64_t size, GetFunc get_func)
static VArray from_span(Span< T > values)
static VArray from_container(ContainerT container)
static VMutableArray from_derived_span(MutableSpan< StructT > values)
void set(const int64_t index, T value)
static VMutableArray from_container(ContainerT container)
MutableSpan< T > get_internal_span() const
static VMutableArray from_span(MutableSpan< T > values)
void append(const T &value)
constexpr bool is_empty() const
constexpr bool is_empty() const
constexpr int64_t size() const
#define EXPECT_FALSE(result)
#define EXPECT_TRUE(result)
TEST_F(BlfLoadTest, load)
Definition BLF_tests.cc:37
static int get_x(const std::array< int, 3 > &item)
TEST(any_virtual, DefaultConstructor)
static void set_x(std::array< int, 3 > &item, int value)
__int64 int64_t
Definition BKE_text.h:90
BMesh const char void * data
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)