Blender  V3.3
BLI_virtual_array_test.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0 */
2 
3 #include "BLI_array.hh"
5 #include "BLI_strict_flags.h"
6 #include "BLI_vector.hh"
7 #include "BLI_vector_set.hh"
8 #include "BLI_virtual_array.hh"
9 #include "testing/testing.h"
10 
11 namespace blender::tests {
12 
13 TEST(virtual_array, Span)
14 {
15  std::array<int, 5> data = {3, 4, 5, 6, 7};
17  EXPECT_EQ(varray.size(), 5);
18  EXPECT_EQ(varray.get(0), 3);
19  EXPECT_EQ(varray.get(4), 7);
20  EXPECT_TRUE(varray.is_span());
21  EXPECT_FALSE(varray.is_single());
22  EXPECT_EQ(varray.get_internal_span().data(), data.data());
23 }
24 
25 TEST(virtual_array, Single)
26 {
27  VArray<int> varray = VArray<int>::ForSingle(10, 4);
28  EXPECT_EQ(varray.size(), 4);
29  EXPECT_EQ(varray.get(0), 10);
30  EXPECT_EQ(varray.get(3), 10);
31  EXPECT_FALSE(varray.is_span());
32  EXPECT_TRUE(varray.is_single());
33 }
34 
35 TEST(virtual_array, Array)
36 {
37  Array<int> array = {1, 2, 3, 5, 8};
38  {
40  EXPECT_EQ(varray.size(), 5);
41  EXPECT_EQ(varray[0], 1);
42  EXPECT_EQ(varray[2], 3);
43  EXPECT_EQ(varray[3], 5);
44  EXPECT_TRUE(varray.is_span());
45  }
46  {
47  VArray<int> varray = VArray<int>::ForContainer(std::move(array));
48  EXPECT_EQ(varray.size(), 5);
49  EXPECT_EQ(varray[0], 1);
50  EXPECT_EQ(varray[2], 3);
51  EXPECT_EQ(varray[3], 5);
52  EXPECT_TRUE(varray.is_span());
53  }
54  {
55  VArray<int> varray = VArray<int>::ForContainer(array); /* NOLINT: bugprone-use-after-move */
56  EXPECT_TRUE(varray.is_empty());
57  }
58 }
59 
60 TEST(virtual_array, Vector)
61 {
62  Vector<int> vector = {9, 8, 7, 6};
63  VArray<int> varray = VArray<int>::ForContainer(std::move(vector));
64  EXPECT_EQ(varray.size(), 4);
65  EXPECT_EQ(varray[0], 9);
66  EXPECT_EQ(varray[3], 6);
67 }
68 
69 TEST(virtual_array, StdVector)
70 {
71  std::vector<int> vector = {5, 6, 7, 8};
72  VArray<int> varray = VArray<int>::ForContainer(std::move(vector));
73  EXPECT_EQ(varray.size(), 4);
74  EXPECT_EQ(varray[0], 5);
75  EXPECT_EQ(varray[1], 6);
76 }
77 
78 TEST(virtual_array, StdArray)
79 {
80  std::array<int, 4> array = {2, 3, 4, 5};
81  VArray<int> varray = VArray<int>::ForContainer(std::move(array));
82  EXPECT_EQ(varray.size(), 4);
83  EXPECT_EQ(varray[0], 2);
84  EXPECT_EQ(varray[1], 3);
85 }
86 
87 TEST(virtual_array, VectorSet)
88 {
89  VectorSet<int> vector_set = {5, 3, 7, 3, 3, 5, 1};
90  VArray<int> varray = VArray<int>::ForContainer(std::move(vector_set));
91  EXPECT_TRUE(vector_set.is_empty()); /* NOLINT: bugprone-use-after-move. */
92  EXPECT_EQ(varray.size(), 4);
93  EXPECT_EQ(varray[0], 5);
94  EXPECT_EQ(varray[1], 3);
95  EXPECT_EQ(varray[2], 7);
96  EXPECT_EQ(varray[3], 1);
97 }
98 
99 TEST(virtual_array, Func)
100 {
101  auto func = [](int64_t index) { return (int)(index * index); };
102  VArray<int> varray = VArray<int>::ForFunc(10, func);
103  EXPECT_EQ(varray.size(), 10);
104  EXPECT_EQ(varray[0], 0);
105  EXPECT_EQ(varray[3], 9);
106  EXPECT_EQ(varray[9], 81);
107 }
108 
109 TEST(virtual_array, AsSpan)
110 {
111  auto func = [](int64_t index) { return (int)(10 * index); };
112  VArray<int> func_varray = VArray<int>::ForFunc(10, func);
113  VArraySpan span_varray{func_varray};
114  EXPECT_EQ(span_varray.size(), 10);
115  Span<int> span = span_varray;
116  EXPECT_EQ(span.size(), 10);
117  EXPECT_EQ(span[0], 0);
118  EXPECT_EQ(span[3], 30);
119  EXPECT_EQ(span[6], 60);
120 }
121 
122 static int get_x(const std::array<int, 3> &item)
123 {
124  return item[0];
125 }
126 
127 static void set_x(std::array<int, 3> &item, int value)
128 {
129  item[0] = value;
130 }
131 
132 TEST(virtual_array, DerivedSpan)
133 {
135  vector.append({3, 4, 5});
136  vector.append({1, 1, 1});
137  {
138  VArray<int> varray = VArray<int>::ForDerivedSpan<std::array<int, 3>, get_x>(vector);
139  EXPECT_EQ(varray.size(), 2);
140  EXPECT_EQ(varray[0], 3);
141  EXPECT_EQ(varray[1], 1);
142  }
143  {
144  VMutableArray<int> varray =
145  VMutableArray<int>::ForDerivedSpan<std::array<int, 3>, get_x, set_x>(vector);
146  EXPECT_EQ(varray.size(), 2);
147  EXPECT_EQ(varray[0], 3);
148  EXPECT_EQ(varray[1], 1);
149  varray.set(0, 10);
150  varray.set(1, 20);
151  EXPECT_EQ(vector[0][0], 10);
152  EXPECT_EQ(vector[1][0], 20);
153  }
154 }
155 
156 TEST(virtual_array, MutableToImmutable)
157 {
158  std::array<int, 4> array = {4, 2, 6, 4};
159  {
161  VArray<int> varray = mutable_varray;
162  EXPECT_TRUE(varray.is_span());
163  EXPECT_EQ(varray.size(), 4);
164  EXPECT_EQ(varray[1], 2);
165  EXPECT_EQ(mutable_varray.size(), 4);
166  }
167  {
169  EXPECT_EQ(mutable_varray.size(), 4);
170  VArray<int> varray = std::move(mutable_varray);
171  EXPECT_TRUE(varray.is_span());
172  EXPECT_EQ(varray.size(), 4);
173  EXPECT_EQ(varray[1], 2);
174  EXPECT_EQ(mutable_varray.size(), 0); /* NOLINT: bugprone-use-after-move */
175  }
176  {
178  EXPECT_TRUE(varray.is_span());
179  EXPECT_EQ(varray.size(), 4);
180  EXPECT_EQ(varray[1], 2);
181  }
182 }
183 
184 TEST(virtual_array, MaterializeCompressed)
185 {
186  {
187  std::array<int, 10> array = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
189  std::array<int, 3> compressed_array;
190  varray.materialize_compressed({3, 6, 7}, compressed_array);
191  EXPECT_EQ(compressed_array[0], 30);
192  EXPECT_EQ(compressed_array[1], 60);
193  EXPECT_EQ(compressed_array[2], 70);
194  varray.materialize_compressed_to_uninitialized({2, 8, 9}, compressed_array);
195  EXPECT_EQ(compressed_array[0], 20);
196  EXPECT_EQ(compressed_array[1], 80);
197  EXPECT_EQ(compressed_array[2], 90);
198  }
199  {
200  VArray<int> varray = VArray<int>::ForSingle(4, 10);
201  std::array<int, 3> compressed_array;
202  varray.materialize_compressed({2, 6, 7}, compressed_array);
203  EXPECT_EQ(compressed_array[0], 4);
204  EXPECT_EQ(compressed_array[1], 4);
205  EXPECT_EQ(compressed_array[2], 4);
206  compressed_array.fill(0);
207  varray.materialize_compressed_to_uninitialized({0, 1, 2}, compressed_array);
208  EXPECT_EQ(compressed_array[0], 4);
209  EXPECT_EQ(compressed_array[1], 4);
210  EXPECT_EQ(compressed_array[2], 4);
211  }
212  {
213  VArray<int> varray = VArray<int>::ForFunc(10, [](const int64_t i) { return (int)(i * i); });
214  std::array<int, 3> compressed_array;
215  varray.materialize_compressed({5, 7, 8}, compressed_array);
216  EXPECT_EQ(compressed_array[0], 25);
217  EXPECT_EQ(compressed_array[1], 49);
218  EXPECT_EQ(compressed_array[2], 64);
219  varray.materialize_compressed_to_uninitialized({1, 2, 3}, compressed_array);
220  EXPECT_EQ(compressed_array[0], 1);
221  EXPECT_EQ(compressed_array[1], 4);
222  EXPECT_EQ(compressed_array[2], 9);
223  }
224 }
225 
226 TEST(virtual_array, EmptySpanWrapper)
227 {
228  {
229  VArray<int> varray;
230  VArraySpan<int> span1 = varray;
231  EXPECT_TRUE(span1.is_empty());
232  VArraySpan<int> span2 = std::move(span1);
233  EXPECT_TRUE(span2.is_empty());
234  }
235  {
236  VMutableArray<int> varray;
237  MutableVArraySpan<int> span1 = varray;
238  EXPECT_TRUE(span1.is_empty());
239  MutableVArraySpan<int> span2 = std::move(span1);
240  EXPECT_TRUE(span2.is_empty());
241  }
242  {
243  GVArray varray;
244  GVArraySpan span1 = varray;
245  EXPECT_TRUE(span1.is_empty());
246  GVArraySpan span2 = std::move(span1);
247  EXPECT_TRUE(span2.is_empty());
248  }
249  {
250  GVMutableArray varray;
251  GMutableVArraySpan span1 = varray;
252  EXPECT_TRUE(span1.is_empty());
253  GMutableVArraySpan span2 = std::move(span1);
254  EXPECT_TRUE(span2.is_empty());
255  }
256 }
257 
258 } // namespace blender::tests
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
Strict compiler flags for areas of code we want to ensure don't do conversions without us knowing abo...
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a vector
bool is_empty() const
constexpr bool is_empty() const
Definition: BLI_span.hh:519
constexpr int64_t size() const
Definition: BLI_span.hh:240
constexpr bool is_empty() const
Definition: BLI_span.hh:248
void materialize_compressed(IndexMask mask, MutableSpan< T > r_span) const
T get(const int64_t index) const
void materialize_compressed_to_uninitialized(IndexMask mask, MutableSpan< T > r_span) const
Span< T > get_internal_span() const
static VArray ForContainer(ContainerT container)
static VArray ForSingle(T value, const int64_t size)
static VArray ForSpan(Span< T > values)
static VArray ForFunc(const int64_t size, GetFunc get_func)
void set(const int64_t index, T value)
static VMutableArray ForSpan(MutableSpan< T > values)
bool is_empty() const
static int get_x(const std::array< int, 3 > &item)
static void set_x(std::array< int, 3 > &item, int value)
TEST(any, DefaultConstructor)
Definition: BLI_any_test.cc:10
__int64 int64_t
Definition: stdint.h:89