Blender V5.3
FN_multi_function_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 "testing/testing.h"
6
10
11#include "BKE_gtest_base.hh"
12
14
15namespace {
16class MultiFunctionTest : public bke::BlenderGTestBase {};
17
18class AddFunction : public MultiFunction {
19 public:
20 AddFunction()
21 {
22 static Signature signature = []() {
23 Signature signature;
24 SignatureBuilder builder("Add", signature);
25 builder.single_input<int>("A");
26 builder.single_input<int>("B");
27 builder.single_output<int>("Result");
28 return signature;
29 }();
30 this->set_signature(&signature);
31 }
32
33 void call(const IndexMask &mask, Params params, Context /*context*/) const override
34 {
35 const VArray<int> &a = params.readonly_single_input<int>(0, "A");
36 const VArray<int> &b = params.readonly_single_input<int>(1, "B");
37 MutableSpan<int> result = params.uninitialized_single_output<int>(2, "Result");
38
39 mask.foreach_index([&](const int64_t i) { result[i] = a[i] + b[i]; });
40 }
41};
42
43TEST_F(MultiFunctionTest, AddFunction)
44{
45 AddFunction fn;
46
47 Array<int> input1 = {4, 5, 6};
48 Array<int> input2 = {10, 20, 30};
49 Array<int> output(3, -1);
50
51 IndexMaskMemory memory;
52 const IndexMask mask = IndexMask::from_indices<int>({0, 2}, memory);
53 ParamsBuilder params(fn, &mask);
54 params.add_readonly_single_input(input1.as_span());
55 params.add_readonly_single_input(input2.as_span());
56 params.add_uninitialized_single_output(output.as_mutable_span());
57
58 ContextBuilder context;
59
60 fn.call(mask, params, context);
61
62 EXPECT_EQ(output[0], 14);
63 EXPECT_EQ(output[1], -1);
64 EXPECT_EQ(output[2], 36);
65}
66
67TEST_F(MultiFunctionTest, AddPrefixFunction)
68{
70
71 Array<std::string> strings = {
72 "Hello",
73 "World",
74 "This is a test",
75 "Another much longer string to trigger an allocation",
76 };
77
78 std::string prefix = "AB";
79
80 IndexMaskMemory memory;
81 const IndexMask mask = IndexMask::from_indices<int>({0, 2, 3}, memory);
82 ParamsBuilder params(fn, &mask);
83 params.add_readonly_single_input(&prefix);
84 params.add_single_mutable(strings.as_mutable_span());
85
86 ContextBuilder context;
87
88 fn.call(mask, params, context);
89
90 EXPECT_EQ(strings[0], "ABHello");
91 EXPECT_EQ(strings[1], "World");
92 EXPECT_EQ(strings[2], "ABThis is a test");
93 EXPECT_EQ(strings[3], "ABAnother much longer string to trigger an allocation");
94}
95
96TEST_F(MultiFunctionTest, CreateRangeFunction)
97{
99
100 GVectorArray ranges(CPPType::get<int>(), 5);
101 GVectorArray_TypedMutableRef<int> ranges_ref{ranges};
102 Array<int> sizes = {3, 0, 6, 1, 4};
103
104 IndexMaskMemory memory;
105 const IndexMask mask = IndexMask::from_indices<int>({0, 1, 2, 3}, memory);
106 ParamsBuilder params(fn, &mask);
107 params.add_readonly_single_input(sizes.as_span());
108 params.add_vector_output(ranges);
109
110 ContextBuilder context;
111
112 fn.call(mask, params, context);
113
114 EXPECT_EQ(ranges[0].size(), 3);
115 EXPECT_EQ(ranges[1].size(), 0);
116 EXPECT_EQ(ranges[2].size(), 6);
117 EXPECT_EQ(ranges[3].size(), 1);
118 EXPECT_EQ(ranges[4].size(), 0);
119
120 EXPECT_EQ(ranges_ref[0][0], 0);
121 EXPECT_EQ(ranges_ref[0][1], 1);
122 EXPECT_EQ(ranges_ref[0][2], 2);
123 EXPECT_EQ(ranges_ref[2][0], 0);
124 EXPECT_EQ(ranges_ref[2][1], 1);
125}
126
127TEST_F(MultiFunctionTest, GenericAppendFunction)
128{
130
131 GVectorArray vectors(CPPType::get<int32_t>(), 4);
132 GVectorArray_TypedMutableRef<int> vectors_ref{vectors};
133 vectors_ref.append(0, 1);
134 vectors_ref.append(0, 2);
135 vectors_ref.append(2, 6);
136 Array<int> values = {5, 7, 3, 1};
137
138 const IndexMask mask(IndexRange(vectors.size()));
139 ParamsBuilder params(fn, &mask);
140 params.add_vector_mutable(vectors);
141 params.add_readonly_single_input(values.as_span());
142
143 ContextBuilder context;
144
145 fn.call(mask, params, context);
146
147 EXPECT_EQ(vectors[0].size(), 3);
148 EXPECT_EQ(vectors[1].size(), 1);
149 EXPECT_EQ(vectors[2].size(), 2);
150 EXPECT_EQ(vectors[3].size(), 1);
151
152 EXPECT_EQ(vectors_ref[0][0], 1);
153 EXPECT_EQ(vectors_ref[0][1], 2);
154 EXPECT_EQ(vectors_ref[0][2], 5);
155 EXPECT_EQ(vectors_ref[1][0], 7);
156 EXPECT_EQ(vectors_ref[2][0], 6);
157 EXPECT_EQ(vectors_ref[2][1], 3);
158 EXPECT_EQ(vectors_ref[3][0], 1);
159}
160
161TEST_F(MultiFunctionTest, CustomMF_Constant)
162{
163 CustomMF_Constant<int> fn{42};
164
165 Array<int> outputs(4, 0);
166
167 IndexMaskMemory memory;
168 const IndexMask mask = IndexMask::from_indices<int>({0, 2, 3}, memory);
169 ParamsBuilder params(fn, &mask);
170 params.add_uninitialized_single_output(outputs.as_mutable_span());
171
172 ContextBuilder context;
173
174 fn.call(mask, params, context);
175
176 EXPECT_EQ(outputs[0], 42);
177 EXPECT_EQ(outputs[1], 0);
178 EXPECT_EQ(outputs[2], 42);
179 EXPECT_EQ(outputs[3], 42);
180}
181
182TEST_F(MultiFunctionTest, CustomMF_GenericConstant)
183{
184 int value = 42;
185 CustomMF_GenericConstant fn{CPPType::get<int32_t>(), (const void *)&value, false};
186
187 Array<int> outputs(4, 0);
188
189 IndexMaskMemory memory;
190 const IndexMask mask = IndexMask::from_indices<int>({0, 1, 2}, memory);
191 ParamsBuilder params(fn, &mask);
192 params.add_uninitialized_single_output(outputs.as_mutable_span());
193
194 ContextBuilder context;
195
196 fn.call(mask, params, context);
197
198 EXPECT_EQ(outputs[0], 42);
199 EXPECT_EQ(outputs[1], 42);
200 EXPECT_EQ(outputs[2], 42);
201 EXPECT_EQ(outputs[3], 0);
202}
203
204TEST_F(MultiFunctionTest, CustomMF_GenericConstantArray)
205{
206 std::array<int, 4> values = {3, 4, 5, 6};
207 CustomMF_GenericConstantArray fn{GSpan(Span(values))};
208
209 GVectorArray vector_array{CPPType::get<int32_t>(), 4};
210 GVectorArray_TypedMutableRef<int> vector_array_ref{vector_array};
211
212 IndexMaskMemory memory;
213 const IndexMask mask = IndexMask::from_indices<int>({1, 2, 3}, memory);
214 ParamsBuilder params(fn, &mask);
215 params.add_vector_output(vector_array);
216
217 ContextBuilder context;
218
219 fn.call(mask, params, context);
220
221 EXPECT_EQ(vector_array[0].size(), 0);
222 EXPECT_EQ(vector_array[1].size(), 4);
223 EXPECT_EQ(vector_array[2].size(), 4);
224 EXPECT_EQ(vector_array[3].size(), 4);
225 for (int i = 1; i < 4; i++) {
226 EXPECT_EQ(vector_array_ref[i][0], 3);
227 EXPECT_EQ(vector_array_ref[i][1], 4);
228 EXPECT_EQ(vector_array_ref[i][2], 5);
229 EXPECT_EQ(vector_array_ref[i][3], 6);
230 }
231}
232
233TEST_F(MultiFunctionTest, IgnoredOutputs)
234{
236 {
237 const IndexMask mask(10);
238 ParamsBuilder params(fn, &mask);
239 params.add_ignored_single_output("Out 1");
240 params.add_ignored_single_output("Out 2");
241 ContextBuilder context;
242 fn.call(mask, params, context);
243 }
244 {
245 Array<int> results_1(10);
246 Array<std::string> results_2(10, NoInitialization());
247 const IndexMask mask(10);
248
249 ParamsBuilder params(fn, &mask);
250 params.add_uninitialized_single_output(results_1.as_mutable_span(), "Out 1");
251 params.add_uninitialized_single_output(results_2.as_mutable_span(), "Out 2");
252 ContextBuilder context;
253 fn.call(mask, params, context);
254
255 EXPECT_EQ(results_1[0], 5);
256 EXPECT_EQ(results_1[3], 5);
257 EXPECT_EQ(results_1[9], 5);
258 EXPECT_EQ(results_2[0], "hello, this is a long string");
259 }
260}
261
262TEST_F(MultiFunctionTest, build_move_only)
263{
264 auto adder = std::make_unique<int>(10);
265 const auto fn = mf::build::SI1_SO<int, int>(
266 "add", [adder = std::move(adder)](const int a) { return a + *adder; });
267
268 const IndexMask mask(2);
269 ParamsBuilder params(fn, &mask);
270
271 Array<int> inputs = {3, 5};
272 Array<int> outputs(2);
273 params.add_readonly_single_input(inputs.as_span());
274 params.add_uninitialized_single_output(outputs.as_mutable_span());
275
276 ContextBuilder context;
277 fn.call(mask, params, context);
278
279 EXPECT_EQ(outputs[0], 13);
280 EXPECT_EQ(outputs[1], 15);
281}
282
283} // namespace
284} // namespace blender::fn::multi_function::tests
#define output
static const CPPType & get()
GSpan()=default
static IndexMask from_indices(Span< T > indices, LinearAllocator<> &memory)
constexpr IndexRange()=default
constexpr Span()=default
#define EXPECT_EQ(result, expect)
int size(const AssetLibraryReference *library_reference)
int context(const bContext *C, const char *member, bContextDataResult *result)
TEST_F(MultiFunctionProcedureTest, ConstantOutput)
__int64 int64_t
Definition BKE_text.h:90
void mask(PageMask &srt, TileMaps &tilemaps, const uint3 global_id, const uint local_tile_index)