Blender V5.3
BLI_cpp_type_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
7#include "BLI_cpp_type.hh"
9
10namespace blender {
11
12namespace tests {
13
14static const int default_constructed_value = 1;
15static const int copy_constructed_value = 2;
16static const int move_constructed_value = 3;
17static const int copy_constructed_from_value = 4;
18static const int move_constructed_from_value = 5;
19static const int copy_assigned_value = 6;
20static const int copy_assigned_from_value = 7;
21static const int move_assigned_value = 8;
22static const int move_assigned_from_value = 9;
23static const int destructed_value = 10;
24
25struct TestType {
26 mutable volatile int value;
27
32
34 {
36 }
37
43
44 TestType(TestType &&other) noexcept
45 {
47 other.value = move_constructed_from_value;
48 }
49
51 {
54 return *this;
55 }
56
57 TestType &operator=(TestType &&other) noexcept
58 {
60 other.value = move_assigned_from_value;
61 return *this;
62 }
63
64 friend std::ostream &operator<<(std::ostream &stream, const TestType &value)
65 {
66 stream << value.value;
67 return stream;
68 }
69
70 friend bool operator==(const TestType & /*a*/, const TestType & /*b*/)
71 {
72 return false;
73 }
74
75 uint64_t hash() const
76 {
77 return 0;
78 }
79};
80
81} // namespace tests
82
84{
85 const int int_value = value.value;
86 hash.add(int_value);
87}
88
89namespace tests {
90
91class CPPTypeTest : public testing::Test {
92 public:
94
96
102};
103
105{
106 EXPECT_EQ(CPPType_TestType.size, sizeof(TestType));
107}
108
110{
111 EXPECT_EQ(CPPType_TestType.alignment, alignof(TestType));
112}
113
115{
116 EXPECT_TRUE(CPPType_TestType.is<TestType>());
117 EXPECT_FALSE(CPPType_TestType.is<int>());
118}
119
120TEST_F(CPPTypeTest, DefaultConstruction)
121{
122 int buffer[10] = {0};
123 CPPType_TestType.default_construct(static_cast<void *>(buffer));
125 EXPECT_EQ(buffer[1], 0);
126 CPPType_TestType.default_construct_n(static_cast<void *>(buffer), 3);
130 EXPECT_EQ(buffer[3], 0);
131 IndexMaskMemory memory;
132 CPPType_TestType.default_construct_indices(static_cast<void *>(buffer),
133 IndexMask::from_indices<int>({2, 5, 7}, memory));
135 EXPECT_EQ(buffer[4], 0);
137 EXPECT_EQ(buffer[6], 0);
139 EXPECT_EQ(buffer[8], 0);
140}
141
142TEST_F(CPPTypeTest, DefaultConstructTrivial)
143{
144 int value = 5;
146 EXPECT_EQ(value, 5);
147}
148
149TEST_F(CPPTypeTest, ValueInitialize)
150{
151 int buffer[10] = {0};
152 CPPType_TestType.value_initialize(static_cast<void *>(buffer));
154 EXPECT_EQ(buffer[1], 0);
155 CPPType_TestType.value_initialize_n(static_cast<void *>(buffer), 3);
159 EXPECT_EQ(buffer[3], 0);
160 IndexMaskMemory memory;
161 CPPType_TestType.value_initialize_indices(static_cast<void *>(buffer),
162 IndexMask::from_indices<int>({2, 5, 7}, memory));
164 EXPECT_EQ(buffer[4], 0);
166 EXPECT_EQ(buffer[6], 0);
168 EXPECT_EQ(buffer[8], 0);
169}
170
171TEST_F(CPPTypeTest, ValueInitializeTrivial)
172{
173 int value = 5;
175 EXPECT_EQ(value, 0);
176}
177
179{
180 int buffer[10] = {0};
181 CPPType_TestType.destruct(static_cast<void *>(buffer));
182 EXPECT_EQ(buffer[0], destructed_value);
183 EXPECT_EQ(buffer[1], 0);
184 CPPType_TestType.destruct_n(static_cast<void *>(buffer), 3);
185 EXPECT_EQ(buffer[0], destructed_value);
186 EXPECT_EQ(buffer[1], destructed_value);
187 EXPECT_EQ(buffer[2], destructed_value);
188 EXPECT_EQ(buffer[3], 0);
189 IndexMaskMemory memory;
190 CPPType_TestType.destruct_indices(static_cast<void *>(buffer),
191 IndexMask::from_indices<int>({2, 5, 7}, memory));
192 EXPECT_EQ(buffer[2], destructed_value);
193 EXPECT_EQ(buffer[4], 0);
194 EXPECT_EQ(buffer[5], destructed_value);
195 EXPECT_EQ(buffer[6], 0);
196 EXPECT_EQ(buffer[7], destructed_value);
197 EXPECT_EQ(buffer[8], 0);
198}
199
200TEST_F(CPPTypeTest, CopyToUninitialized)
201{
202 int buffer1[10] = {0};
203 int buffer2[10] = {0};
204 CPPType_TestType.copy_construct(static_cast<void *>(buffer1), static_cast<void *>(buffer2));
207 CPPType_TestType.copy_construct_n(static_cast<void *>(buffer1), static_cast<void *>(buffer2), 3);
214 EXPECT_EQ(buffer1[3], 0);
215 EXPECT_EQ(buffer2[3], 0);
216 IndexMaskMemory memory;
217 CPPType_TestType.copy_construct_indices(static_cast<void *>(buffer1),
218 static_cast<void *>(buffer2),
219 IndexMask::from_indices<int>({2, 5, 7}, memory));
222 EXPECT_EQ(buffer1[4], 0);
223 EXPECT_EQ(buffer2[4], 0);
226 EXPECT_EQ(buffer1[6], 0);
227 EXPECT_EQ(buffer2[6], 0);
230 EXPECT_EQ(buffer1[8], 0);
231 EXPECT_EQ(buffer2[8], 0);
232}
233
234TEST_F(CPPTypeTest, CopyToInitialized)
235{
236 int buffer1[10] = {0};
237 int buffer2[10] = {0};
238 CPPType_TestType.copy_assign(static_cast<void *>(buffer1), static_cast<void *>(buffer2));
240 EXPECT_EQ(buffer2[0], copy_assigned_value);
241 CPPType_TestType.copy_assign_n(static_cast<void *>(buffer1), static_cast<void *>(buffer2), 3);
243 EXPECT_EQ(buffer2[0], copy_assigned_value);
245 EXPECT_EQ(buffer2[1], copy_assigned_value);
247 EXPECT_EQ(buffer2[2], copy_assigned_value);
248 EXPECT_EQ(buffer1[3], 0);
249 EXPECT_EQ(buffer2[3], 0);
250 IndexMaskMemory memory;
251 CPPType_TestType.copy_assign_indices(static_cast<void *>(buffer1),
252 static_cast<void *>(buffer2),
253 IndexMask::from_indices<int>({2, 5, 7}, memory));
255 EXPECT_EQ(buffer2[2], copy_assigned_value);
256 EXPECT_EQ(buffer1[4], 0);
257 EXPECT_EQ(buffer2[4], 0);
259 EXPECT_EQ(buffer2[5], copy_assigned_value);
260 EXPECT_EQ(buffer1[6], 0);
261 EXPECT_EQ(buffer2[6], 0);
263 EXPECT_EQ(buffer2[7], copy_assigned_value);
264 EXPECT_EQ(buffer1[8], 0);
265 EXPECT_EQ(buffer2[8], 0);
266}
267
268TEST_F(CPPTypeTest, RelocateToUninitialized)
269{
270 int buffer1[10] = {0};
271 int buffer2[10] = {0};
272 CPPType_TestType.relocate_construct(static_cast<void *>(buffer1), static_cast<void *>(buffer2));
273 EXPECT_EQ(buffer1[0], destructed_value);
275 CPPType_TestType.relocate_construct_n(
276 static_cast<void *>(buffer1), static_cast<void *>(buffer2), 3);
277 EXPECT_EQ(buffer1[0], destructed_value);
279 EXPECT_EQ(buffer1[1], destructed_value);
281 EXPECT_EQ(buffer1[2], destructed_value);
283 EXPECT_EQ(buffer1[3], 0);
284 EXPECT_EQ(buffer2[3], 0);
285 IndexMaskMemory memory;
286 CPPType_TestType.relocate_construct_indices(static_cast<void *>(buffer1),
287 static_cast<void *>(buffer2),
288 IndexMask::from_indices<int>({2, 5, 7}, memory));
289 EXPECT_EQ(buffer1[2], destructed_value);
291 EXPECT_EQ(buffer1[4], 0);
292 EXPECT_EQ(buffer2[4], 0);
293 EXPECT_EQ(buffer1[5], destructed_value);
295 EXPECT_EQ(buffer1[6], 0);
296 EXPECT_EQ(buffer2[6], 0);
297 EXPECT_EQ(buffer1[7], destructed_value);
299 EXPECT_EQ(buffer1[8], 0);
300 EXPECT_EQ(buffer2[8], 0);
301}
302
303TEST_F(CPPTypeTest, RelocateToInitialized)
304{
305 int buffer1[10] = {0};
306 int buffer2[10] = {0};
307 CPPType_TestType.relocate_assign(static_cast<void *>(buffer1), static_cast<void *>(buffer2));
308 EXPECT_EQ(buffer1[0], destructed_value);
309 EXPECT_EQ(buffer2[0], move_assigned_value);
310 CPPType_TestType.relocate_assign_n(
311 static_cast<void *>(buffer1), static_cast<void *>(buffer2), 3);
312 EXPECT_EQ(buffer1[0], destructed_value);
313 EXPECT_EQ(buffer2[0], move_assigned_value);
314 EXPECT_EQ(buffer1[1], destructed_value);
315 EXPECT_EQ(buffer2[1], move_assigned_value);
316 EXPECT_EQ(buffer1[2], destructed_value);
317 EXPECT_EQ(buffer2[2], move_assigned_value);
318 EXPECT_EQ(buffer1[3], 0);
319 EXPECT_EQ(buffer2[3], 0);
320 IndexMaskMemory memory;
321 CPPType_TestType.relocate_assign_indices(static_cast<void *>(buffer1),
322 static_cast<void *>(buffer2),
323 IndexMask::from_indices<int>({2, 5, 7}, memory));
324 EXPECT_EQ(buffer1[2], destructed_value);
325 EXPECT_EQ(buffer2[2], move_assigned_value);
326 EXPECT_EQ(buffer1[4], 0);
327 EXPECT_EQ(buffer2[4], 0);
328 EXPECT_EQ(buffer1[5], destructed_value);
329 EXPECT_EQ(buffer2[5], move_assigned_value);
330 EXPECT_EQ(buffer1[6], 0);
331 EXPECT_EQ(buffer2[6], 0);
332 EXPECT_EQ(buffer1[7], destructed_value);
333 EXPECT_EQ(buffer2[7], move_assigned_value);
334 EXPECT_EQ(buffer1[8], 0);
335 EXPECT_EQ(buffer2[8], 0);
336}
337
338TEST_F(CPPTypeTest, FillInitialized)
339{
340 int buffer1 = 0;
341 int buffer2[10] = {0};
342 CPPType_TestType.fill_assign_n(static_cast<void *>(&buffer1), static_cast<void *>(buffer2), 3);
344 EXPECT_EQ(buffer2[0], copy_assigned_value);
345 EXPECT_EQ(buffer2[1], copy_assigned_value);
346 EXPECT_EQ(buffer2[2], copy_assigned_value);
347 EXPECT_EQ(buffer2[3], 0);
348
349 buffer1 = 0;
350 IndexMaskMemory memory;
351 CPPType_TestType.fill_assign_indices(static_cast<void *>(&buffer1),
352 static_cast<void *>(buffer2),
353 IndexMask::from_indices<int>({1, 6, 8}, memory));
355 EXPECT_EQ(buffer2[0], copy_assigned_value);
356 EXPECT_EQ(buffer2[1], copy_assigned_value);
357 EXPECT_EQ(buffer2[2], copy_assigned_value);
358 EXPECT_EQ(buffer2[3], 0);
359 EXPECT_EQ(buffer2[4], 0);
360 EXPECT_EQ(buffer2[5], 0);
361 EXPECT_EQ(buffer2[6], copy_assigned_value);
362 EXPECT_EQ(buffer2[7], 0);
363 EXPECT_EQ(buffer2[8], copy_assigned_value);
364 EXPECT_EQ(buffer2[9], 0);
365}
366
367TEST_F(CPPTypeTest, FillUninitialized)
368{
369 int buffer1 = 0;
370 int buffer2[10] = {0};
371 CPPType_TestType.fill_construct_n(
372 static_cast<void *>(&buffer1), static_cast<void *>(buffer2), 3);
377 EXPECT_EQ(buffer2[3], 0);
378
379 buffer1 = 0;
380 IndexMaskMemory memory;
381 CPPType_TestType.fill_construct_indices(static_cast<void *>(&buffer1),
382 static_cast<void *>(buffer2),
383 IndexMask::from_indices<int>({1, 6, 8}, memory));
388 EXPECT_EQ(buffer2[3], 0);
389 EXPECT_EQ(buffer2[4], 0);
390 EXPECT_EQ(buffer2[5], 0);
392 EXPECT_EQ(buffer2[7], 0);
394 EXPECT_EQ(buffer2[9], 0);
395}
396
397TEST_F(CPPTypeTest, DebugPrint)
398{
399 int value = 42;
400 std::stringstream ss;
401 CPPType::get<int32_t>().print(static_cast<void *>(&value), ss);
402 std::string text = ss.str();
403 EXPECT_EQ(text, "42");
404}
405
406TEST_F(CPPTypeTest, ToStaticType)
407{
409 auto fn = [&]<typename T>() { types.append(&CPPType::get<T>()); };
410 EXPECT_TRUE((CPPType::get<std::string>().to_static_type_try<int, float, std::string>(fn)));
411 EXPECT_TRUE((CPPType::get<float>().to_static_type_try<int, float, std::string>(fn)));
412 EXPECT_FALSE((CPPType::get<int64_t>().to_static_type_try<int, float, std::string>(fn)));
413
414 EXPECT_EQ(types.size(), 2);
416 EXPECT_EQ(types[1], &CPPType::get<float>());
417}
418
419TEST_F(CPPTypeTest, CopyAssignCompressed)
420{
421 std::array<std::string, 5> array = {"a", "b", "c", "d", "e"};
422 std::array<std::string, 3> array_compressed;
423 IndexMaskMemory memory;
424 CPPType::get<std::string>().copy_assign_compressed(
425 &array, &array_compressed, IndexMask::from_indices<int>({0, 2, 3}, memory));
426 EXPECT_EQ(array_compressed[0], "a");
427 EXPECT_EQ(array_compressed[1], "c");
428 EXPECT_EQ(array_compressed[2], "d");
429}
430
431} // namespace tests
432} // namespace blender
#define BLI_CPP_TYPE_REGISTER(TYPE_NAME, FLAGS)
static const CPPType & get()
void print(const void *value, std::stringstream &ss) const
void default_construct(void *ptr) const
void value_initialize(void *ptr) const
static IndexMask from_indices(Span< T > indices, LinearAllocator<> &memory)
int64_t size() const
void append(const T &value)
#define EXPECT_FALSE(result)
#define EXPECT_TRUE(result)
#define T
static const int move_assigned_from_value
static const int move_constructed_from_value
TEST_F(BlfLoadTest, load)
Definition BLF_tests.cc:37
static const int move_constructed_value
static const int copy_assigned_from_value
static const int copy_constructed_from_value
static const int move_assigned_value
static const int destructed_value
static const int default_constructed_value
static const int copy_assigned_value
static const int copy_constructed_value
BMesh Iterators.
unsigned __int64 uint64_t
Definition BKE_text.h:91
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void hash_unique_default(const T &value, UniqueHashBytes &hash)
#define hash
Definition noise_c.cc:156
friend std::ostream & operator<<(std::ostream &stream, const TestType &value)
TestType & operator=(const TestType &other)
friend bool operator==(const TestType &, const TestType &)
TestType & operator=(TestType &&other) noexcept
TestType(TestType &&other) noexcept
TestType(const TestType &other)