Blender  V3.3
FN_multi_function_test.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0 */
2 
3 #include "testing/testing.h"
4 
5 #include "FN_multi_function.hh"
8 
9 namespace blender::fn::tests {
10 namespace {
11 
12 class AddFunction : public MultiFunction {
13  public:
14  AddFunction()
15  {
16  static MFSignature signature = create_signature();
17  this->set_signature(&signature);
18  }
19 
20  static MFSignature create_signature()
21  {
22  MFSignatureBuilder signature("Add");
23  signature.single_input<int>("A");
24  signature.single_input<int>("B");
25  signature.single_output<int>("Result");
26  return signature.build();
27  }
28 
29  void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
30  {
31  const VArray<int> &a = params.readonly_single_input<int>(0, "A");
32  const VArray<int> &b = params.readonly_single_input<int>(1, "B");
33  MutableSpan<int> result = params.uninitialized_single_output<int>(2, "Result");
34 
35  for (int64_t i : mask) {
36  result[i] = a[i] + b[i];
37  }
38  }
39 };
40 
41 TEST(multi_function, AddFunction)
42 {
43  AddFunction fn;
44 
45  Array<int> input1 = {4, 5, 6};
46  Array<int> input2 = {10, 20, 30};
47  Array<int> output(3, -1);
48 
49  MFParamsBuilder params(fn, 3);
50  params.add_readonly_single_input(input1.as_span());
51  params.add_readonly_single_input(input2.as_span());
52  params.add_uninitialized_single_output(output.as_mutable_span());
53 
54  MFContextBuilder context;
55 
56  fn.call({0, 2}, params, context);
57 
58  EXPECT_EQ(output[0], 14);
59  EXPECT_EQ(output[1], -1);
60  EXPECT_EQ(output[2], 36);
61 }
62 
63 TEST(multi_function, AddPrefixFunction)
64 {
65  AddPrefixFunction fn;
66 
67  Array<std::string> strings = {
68  "Hello",
69  "World",
70  "This is a test",
71  "Another much longer string to trigger an allocation",
72  };
73 
74  std::string prefix = "AB";
75 
76  MFParamsBuilder params(fn, strings.size());
77  params.add_readonly_single_input(&prefix);
78  params.add_single_mutable(strings.as_mutable_span());
79 
80  MFContextBuilder context;
81 
82  fn.call({0, 2, 3}, params, context);
83 
84  EXPECT_EQ(strings[0], "ABHello");
85  EXPECT_EQ(strings[1], "World");
86  EXPECT_EQ(strings[2], "ABThis is a test");
87  EXPECT_EQ(strings[3], "ABAnother much longer string to trigger an allocation");
88 }
89 
90 TEST(multi_function, CreateRangeFunction)
91 {
92  CreateRangeFunction fn;
93 
94  GVectorArray ranges(CPPType::get<int>(), 5);
95  GVectorArray_TypedMutableRef<int> ranges_ref{ranges};
96  Array<int> sizes = {3, 0, 6, 1, 4};
97 
98  MFParamsBuilder params(fn, ranges.size());
99  params.add_readonly_single_input(sizes.as_span());
100  params.add_vector_output(ranges);
101 
102  MFContextBuilder context;
103 
104  fn.call({0, 1, 2, 3}, params, context);
105 
106  EXPECT_EQ(ranges[0].size(), 3);
107  EXPECT_EQ(ranges[1].size(), 0);
108  EXPECT_EQ(ranges[2].size(), 6);
109  EXPECT_EQ(ranges[3].size(), 1);
110  EXPECT_EQ(ranges[4].size(), 0);
111 
112  EXPECT_EQ(ranges_ref[0][0], 0);
113  EXPECT_EQ(ranges_ref[0][1], 1);
114  EXPECT_EQ(ranges_ref[0][2], 2);
115  EXPECT_EQ(ranges_ref[2][0], 0);
116  EXPECT_EQ(ranges_ref[2][1], 1);
117 }
118 
119 TEST(multi_function, GenericAppendFunction)
120 {
121  GenericAppendFunction fn(CPPType::get<int32_t>());
122 
123  GVectorArray vectors(CPPType::get<int32_t>(), 4);
124  GVectorArray_TypedMutableRef<int> vectors_ref{vectors};
125  vectors_ref.append(0, 1);
126  vectors_ref.append(0, 2);
127  vectors_ref.append(2, 6);
128  Array<int> values = {5, 7, 3, 1};
129 
130  MFParamsBuilder params(fn, vectors.size());
131  params.add_vector_mutable(vectors);
132  params.add_readonly_single_input(values.as_span());
133 
134  MFContextBuilder context;
135 
136  fn.call(IndexRange(vectors.size()), params, context);
137 
138  EXPECT_EQ(vectors[0].size(), 3);
139  EXPECT_EQ(vectors[1].size(), 1);
140  EXPECT_EQ(vectors[2].size(), 2);
141  EXPECT_EQ(vectors[3].size(), 1);
142 
143  EXPECT_EQ(vectors_ref[0][0], 1);
144  EXPECT_EQ(vectors_ref[0][1], 2);
145  EXPECT_EQ(vectors_ref[0][2], 5);
146  EXPECT_EQ(vectors_ref[1][0], 7);
147  EXPECT_EQ(vectors_ref[2][0], 6);
148  EXPECT_EQ(vectors_ref[2][1], 3);
149  EXPECT_EQ(vectors_ref[3][0], 1);
150 }
151 
152 TEST(multi_function, CustomMF_SI_SO)
153 {
154  CustomMF_SI_SO<std::string, uint> fn("strlen",
155  [](const std::string &str) { return str.size(); });
156 
157  Array<std::string> strings = {"hello", "world", "test", "another test"};
158  Array<uint> sizes(strings.size(), 0);
159 
160  MFParamsBuilder params(fn, strings.size());
161  params.add_readonly_single_input(strings.as_span());
162  params.add_uninitialized_single_output(sizes.as_mutable_span());
163 
164  MFContextBuilder context;
165 
166  fn.call(IndexRange(strings.size()), params, context);
167 
168  EXPECT_EQ(sizes[0], 5);
169  EXPECT_EQ(sizes[1], 5);
170  EXPECT_EQ(sizes[2], 4);
171  EXPECT_EQ(sizes[3], 12);
172 }
173 
174 TEST(multi_function, CustomMF_SI_SI_SO)
175 {
176  CustomMF_SI_SI_SO<int, int, int> fn("mul", [](int a, int b) { return a * b; });
177 
178  Array<int> values_a = {4, 6, 8, 9};
179  int value_b = 10;
180  Array<int> outputs(values_a.size(), -1);
181 
182  MFParamsBuilder params(fn, values_a.size());
183  params.add_readonly_single_input(values_a.as_span());
184  params.add_readonly_single_input(&value_b);
185  params.add_uninitialized_single_output(outputs.as_mutable_span());
186 
187  MFContextBuilder context;
188 
189  fn.call({0, 1, 3}, params, context);
190 
191  EXPECT_EQ(outputs[0], 40);
192  EXPECT_EQ(outputs[1], 60);
193  EXPECT_EQ(outputs[2], -1);
194  EXPECT_EQ(outputs[3], 90);
195 }
196 
197 TEST(multi_function, CustomMF_SI_SI_SI_SO)
198 {
199  CustomMF_SI_SI_SI_SO<int, std::string, bool, uint> fn{
200  "custom",
201  [](int a, const std::string &b, bool c) { return (uint)((uint)a + b.size() + (uint)c); }};
202 
203  Array<int> values_a = {5, 7, 3, 8};
204  Array<std::string> values_b = {"hello", "world", "another", "test"};
205  Array<bool> values_c = {true, false, false, true};
206  Array<uint> outputs(values_a.size(), 0);
207 
208  MFParamsBuilder params(fn, values_a.size());
209  params.add_readonly_single_input(values_a.as_span());
210  params.add_readonly_single_input(values_b.as_span());
211  params.add_readonly_single_input(values_c.as_span());
212  params.add_uninitialized_single_output(outputs.as_mutable_span());
213 
214  MFContextBuilder context;
215 
216  fn.call({1, 2, 3}, params, context);
217 
218  EXPECT_EQ(outputs[0], 0);
219  EXPECT_EQ(outputs[1], 12);
220  EXPECT_EQ(outputs[2], 10);
221  EXPECT_EQ(outputs[3], 13);
222 }
223 
224 TEST(multi_function, CustomMF_SM)
225 {
226  CustomMF_SM<std::string> fn("AddSuffix", [](std::string &value) { value += " test"; });
227 
228  Array<std::string> values = {"a", "b", "c", "d", "e"};
229 
230  MFParamsBuilder params(fn, values.size());
231  params.add_single_mutable(values.as_mutable_span());
232 
233  MFContextBuilder context;
234 
235  fn.call({1, 2, 3}, params, context);
236 
237  EXPECT_EQ(values[0], "a");
238  EXPECT_EQ(values[1], "b test");
239  EXPECT_EQ(values[2], "c test");
240  EXPECT_EQ(values[3], "d test");
241  EXPECT_EQ(values[4], "e");
242 }
243 
244 TEST(multi_function, CustomMF_Constant)
245 {
246  CustomMF_Constant<int> fn{42};
247 
248  Array<int> outputs(4, 0);
249 
250  MFParamsBuilder params(fn, outputs.size());
251  params.add_uninitialized_single_output(outputs.as_mutable_span());
252 
253  MFContextBuilder context;
254 
255  fn.call({0, 2, 3}, params, context);
256 
257  EXPECT_EQ(outputs[0], 42);
258  EXPECT_EQ(outputs[1], 0);
259  EXPECT_EQ(outputs[2], 42);
260  EXPECT_EQ(outputs[3], 42);
261 }
262 
263 TEST(multi_function, CustomMF_GenericConstant)
264 {
265  int value = 42;
266  CustomMF_GenericConstant fn{CPPType::get<int32_t>(), (const void *)&value, false};
267 
268  Array<int> outputs(4, 0);
269 
270  MFParamsBuilder params(fn, outputs.size());
271  params.add_uninitialized_single_output(outputs.as_mutable_span());
272 
273  MFContextBuilder context;
274 
275  fn.call({0, 1, 2}, params, context);
276 
277  EXPECT_EQ(outputs[0], 42);
278  EXPECT_EQ(outputs[1], 42);
279  EXPECT_EQ(outputs[2], 42);
280  EXPECT_EQ(outputs[3], 0);
281 }
282 
283 TEST(multi_function, CustomMF_GenericConstantArray)
284 {
285  std::array<int, 4> values = {3, 4, 5, 6};
286  CustomMF_GenericConstantArray fn{GSpan(Span(values))};
287 
288  GVectorArray vector_array{CPPType::get<int32_t>(), 4};
289  GVectorArray_TypedMutableRef<int> vector_array_ref{vector_array};
290 
291  MFParamsBuilder params(fn, vector_array.size());
292  params.add_vector_output(vector_array);
293 
294  MFContextBuilder context;
295 
296  fn.call({1, 2, 3}, params, context);
297 
298  EXPECT_EQ(vector_array[0].size(), 0);
299  EXPECT_EQ(vector_array[1].size(), 4);
300  EXPECT_EQ(vector_array[2].size(), 4);
301  EXPECT_EQ(vector_array[3].size(), 4);
302  for (int i = 1; i < 4; i++) {
303  EXPECT_EQ(vector_array_ref[i][0], 3);
304  EXPECT_EQ(vector_array_ref[i][1], 4);
305  EXPECT_EQ(vector_array_ref[i][2], 5);
306  EXPECT_EQ(vector_array_ref[i][3], 6);
307  }
308 }
309 
310 TEST(multi_function, IgnoredOutputs)
311 {
312  OptionalOutputsFunction fn;
313  {
314  MFParamsBuilder params(fn, 10);
315  params.add_ignored_single_output("Out 1");
316  params.add_ignored_single_output("Out 2");
317  MFContextBuilder context;
318  fn.call(IndexRange(10), params, context);
319  }
320  {
321  Array<int> results_1(10);
322  Array<std::string> results_2(10, NoInitialization());
323 
324  MFParamsBuilder params(fn, 10);
325  params.add_uninitialized_single_output(results_1.as_mutable_span(), "Out 1");
326  params.add_uninitialized_single_output(results_2.as_mutable_span(), "Out 2");
327  MFContextBuilder context;
328  fn.call(IndexRange(10), params, context);
329 
330  EXPECT_EQ(results_1[0], 5);
331  EXPECT_EQ(results_1[3], 5);
332  EXPECT_EQ(results_1[9], 5);
333  EXPECT_EQ(results_2[0], "hello, this is a long string");
334  }
335 }
336 
337 } // namespace
338 } // namespace blender::fn::tests
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
unsigned int uint
Definition: BLI_sys_types.h:67
#define UNUSED(x)
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
#define str(s)
uiWidgetBaseParameters params[MAX_WIDGET_BASE_BATCH]
ccl_global KernelShaderEvalInput ccl_global float * output
ccl_device_inline float4 mask(const int4 &mask, const float4 &a)
Definition: math_float4.h:513
static unsigned c
Definition: RandGen.cpp:83
static unsigned a[3]
Definition: RandGen.cpp:78
TEST(field, ConstantFunction)
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
static bNodeSocketTemplate outputs[]
__int64 int64_t
Definition: stdint.h:89