Blender V5.3
node_socket_value_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BKE_gtest_base.hh"
7#include "BKE_volume_grid.hh"
8
9#include "FN_field.hh"
11
14
15#ifdef WITH_OPENVDB
16# include <openvdb/Grid.h>
17#endif
18
19#include "testing/testing.h"
20
21namespace blender::bke::tests {
22
23using nodes::Bundle;
24using nodes::BundleKey;
26using nodes::GList;
27using nodes::GListPtr;
28using nodes::List;
29using nodes::ListPtr;
30
32
34{
36 {
37 int &x = s.ensure_type<int>();
38 x = 5;
39 }
40 {
41 const int *x = s.get_if<int>();
42 EXPECT_NE(x, nullptr);
43 EXPECT_EQ(*x, 5);
44 }
45}
46
48{
50 {
51 float &x = s.ensure_type<float>();
52 x = 5.3f;
53 }
54 {
55 const int *x = s.get_if<int>();
56 EXPECT_EQ(x, nullptr);
57 }
58 {
59 int &x = s.ensure_type<int>();
60 EXPECT_EQ(x, 5);
61 }
62}
63
65{
67 s.ensure_type<int>() = 23;
69 EXPECT_FALSE(f.depends_on_input());
71}
72
74{
76 s.ensure_type<int>() = 23;
78 EXPECT_FALSE(f.depends_on_input());
80}
81
83{
85 s.ensure_type<int>() = 23;
86 const fn::GField &f = s.ensure_type<fn::GField>();
87 EXPECT_FALSE(f.depends_on_input());
88 EXPECT_TRUE(f.cpp_type().is<int>());
89 EXPECT_EQ(fn::evaluate_constant_field(f.typed<int>()), 23);
90}
91
92TEST_F(SocketValueVariantTest, ConstantIntFieldToInt)
93{
96 const int &v = s.ensure_type<int>();
97 EXPECT_EQ(v, 42);
98}
99
100TEST_F(SocketValueVariantTest, ConstantIntFieldToFloat)
101{
104 const float &v = s.ensure_type<float>();
105 EXPECT_EQ(v, 42.0f);
106}
107
116
117TEST_F(SocketValueVariantTest, IndexFieldToFloatField)
118{
123
124 fn::FieldContext context;
125 fn::FieldEvaluator evaluator{context, 5};
126 evaluator.add(f);
127 evaluator.evaluate();
128 const VArray<float> values = evaluator.get_evaluated<float>(0);
129 EXPECT_EQ(values.size(), 5);
130 EXPECT_EQ(values[0], 0.0f);
131 EXPECT_EQ(values[1], 1.0f);
132 EXPECT_EQ(values[2], 2.0f);
133 EXPECT_EQ(values[3], 3.0f);
134 EXPECT_EQ(values[4], 4.0f);
135}
136
138{
141 VArray<int> values = s.ensure_type<ListPtr<int>>()->varray();
142 EXPECT_EQ(values.size(), 5);
143 EXPECT_EQ(values[0], 1);
144 EXPECT_EQ(values[1], 2);
145 EXPECT_EQ(values[2], 3);
146 EXPECT_EQ(values[3], 4);
147 EXPECT_EQ(values[4], 5);
148}
149
150TEST_F(SocketValueVariantTest, IntListToFloatList)
151{
154 VArray<float> values = s.ensure_type<ListPtr<float>>()->varray();
155 EXPECT_EQ(values.size(), 5);
156 EXPECT_EQ(values[0], 1.0f);
157 EXPECT_EQ(values[1], 2.0f);
158 EXPECT_EQ(values[2], 3.0f);
159 EXPECT_EQ(values[3], 4.0f);
160 EXPECT_EQ(values[4], 5.0f);
161}
162
164{
166 s.ensure_type<int>() = 42;
168 /* Implicit conversion from single value to list is not allowed. */
170}
171
173{
175 s.ensure_type<std::string>() = "Hello World!";
176 EXPECT_EQ(s.ensure_type<std::string>(), "Hello World!");
177}
178
180{
183 {
184 Bundle &b = s.ensure_type<BundlePtr>().ensure_mutable_inplace();
185 b.add(*BundleKey::from_str("A"), 42);
186 b.add(*BundleKey::from_str("B"), 42.0f);
187 }
188 {
189 const BundlePtr &b = s.ensure_type<BundlePtr>();
190 EXPECT_EQ(b->lookup(*BundleKey::from_str("A"))->as<int>(), 42);
191 EXPECT_EQ(b->lookup(*BundleKey::from_str("B"))->as<float>(), 42.0f);
192 }
193}
194
195#ifdef WITH_OPENVDB
196
197TEST_F(SocketValueVariantTest, SimpleVolumeGrid)
198{
200 s.ensure_type<GVolumeGrid>() = GVolumeGrid(openvdb::FloatGrid::create());
201 const GVolumeGrid &grid = s.ensure_type<GVolumeGrid>();
202 EXPECT_EQ(grid->active_tiles(), 0);
203}
204
205TEST_F(SocketValueVariantTest, SimpleFloatVolumeGrid)
206{
208 s.ensure_type<VolumeGrid<float>>() = VolumeGrid<float>(openvdb::FloatGrid::create());
210 EXPECT_EQ(grid->active_tiles(), 0);
211}
212
213TEST_F(SocketValueVariantTest, VolumeGridToSingle)
214{
215 SocketValueVariant s;
216 s.ensure_type<GVolumeGrid>() = GVolumeGrid(openvdb::FloatGrid::create());
217 const int &v = s.ensure_type<int>();
218 /* There is no valid conversion, so this is 0 independent of the grid. */
219 EXPECT_EQ(v, 0);
220}
221
222TEST_F(SocketValueVariantTest, SingleToVolumeGrid)
223{
224 SocketValueVariant s;
225 s.ensure_type<int>() = 42;
226 const GVolumeGrid &grid = s.ensure_type<GVolumeGrid>();
227 /* These is no valid conversion from single to volume grid. */
228 EXPECT_FALSE(grid);
229}
230
231TEST_F(SocketValueVariantTest, IntVolumeGridToFloatVolumeGrid)
232{
233 SocketValueVariant s;
234 {
235 std::shared_ptr<openvdb::Int32Grid> int_grid = std::make_shared<openvdb::Int32Grid>();
236 int_grid->tree().root().setBackground(42, true);
237 s.ensure_type<VolumeGrid<int>>() = VolumeGrid<int>(std::move(int_grid));
238 }
239 const VolumeGrid<float> &grid = s.ensure_type<VolumeGrid<float>>();
240 VolumeTreeAccessToken tree_token;
241 const openvdb::FloatGrid &float_grid = grid.grid(tree_token);
242 EXPECT_EQ(float_grid.background(), 42.0f);
243}
244
245#endif
246
247} // namespace blender::bke::tests
static std::optional< BundleKey > from_str(StringRef key)
static ListPtr< T > from_container(ContainerT &&container)
int add(GField field, GVArray *varray_ptr)
const GVArray & get_evaluated(const int field_index) const
bool depends_on_input() const
Definition FN_field.hh:513
static const Field< int > & get_field()
Definition field.cc:557
TEST_F(FFmpegTest, libaom_av1_AV_PIX_FMT_YUV420P)
#define EXPECT_FALSE(result)
#define EXPECT_NE(result, expect)
#define EXPECT_TRUE(result)
#define EXPECT_EQ(result, expect)
TEST_F(AnimDataTest, BKE_fcurves_id_cb_test)
void evaluate_constant_field(const GField &field, void *r_value)
ImplicitSharingPtr< Bundle > BundlePtr
ATTR_WARN_UNUSED_RESULT const BMVert * v
TEST_F(BrushTest, deep_copy)
Definition brush_test.cc:52
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)