Blender  V3.3
BLI_cpp_type_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 "BLI_cpp_type.hh"
6 #include "BLI_cpp_type_make.hh"
7 
8 namespace blender::tests {
9 
10 static const int default_constructed_value = 1;
11 static const int copy_constructed_value = 2;
12 static const int move_constructed_value = 3;
13 static const int copy_constructed_from_value = 4;
14 static const int move_constructed_from_value = 5;
15 static const int copy_assigned_value = 6;
16 static const int copy_assigned_from_value = 7;
17 static const int move_assigned_value = 8;
18 static const int move_assigned_from_value = 9;
19 static const int destructed_value = 10;
20 
21 struct TestType {
22  mutable volatile int value;
23 
25  {
27  }
28 
30  {
32  }
33 
34  TestType(const TestType &other)
35  {
38  }
39 
40  TestType(TestType &&other) noexcept
41  {
43  other.value = move_constructed_from_value;
44  }
45 
46  TestType &operator=(const TestType &other)
47  {
50  return *this;
51  }
52 
53  TestType &operator=(TestType &&other) noexcept
54  {
56  other.value = move_assigned_from_value;
57  return *this;
58  }
59 
60  friend std::ostream &operator<<(std::ostream &stream, const TestType &value)
61  {
62  stream << value.value;
63  return stream;
64  }
65 
66  friend bool operator==(const TestType &UNUSED(a), const TestType &UNUSED(b))
67  {
68  return false;
69  }
70 
71  uint64_t hash() const
72  {
73  return 0;
74  }
75 };
76 
77 } // namespace blender::tests
78 
80 
81 namespace blender::tests {
82 
83 static const CPPType &CPPType_TestType = CPPType::get<TestType>();
84 
85 TEST(cpp_type, Size)
86 {
88 }
89 
90 TEST(cpp_type, Alignment)
91 {
93 }
94 
95 TEST(cpp_type, Is)
96 {
97  EXPECT_TRUE(CPPType_TestType.is<TestType>());
98  EXPECT_FALSE(CPPType_TestType.is<int>());
99 }
100 
101 TEST(cpp_type, DefaultConstruction)
102 {
103  int buffer[10] = {0};
106  EXPECT_EQ(buffer[1], 0);
111  EXPECT_EQ(buffer[3], 0);
114  EXPECT_EQ(buffer[4], 0);
116  EXPECT_EQ(buffer[6], 0);
118  EXPECT_EQ(buffer[8], 0);
119 }
120 
121 TEST(cpp_type, DefaultConstructTrivial)
122 {
123  int value = 5;
124  CPPType::get<int>().default_construct(&value);
125  EXPECT_EQ(value, 5);
126 }
127 
128 TEST(cpp_type, ValueInitialize)
129 {
130  int buffer[10] = {0};
133  EXPECT_EQ(buffer[1], 0);
138  EXPECT_EQ(buffer[3], 0);
141  EXPECT_EQ(buffer[4], 0);
143  EXPECT_EQ(buffer[6], 0);
145  EXPECT_EQ(buffer[8], 0);
146 }
147 
148 TEST(cpp_type, ValueInitializeTrivial)
149 {
150  int value = 5;
151  CPPType::get<int>().value_initialize(&value);
152  EXPECT_EQ(value, 0);
153 }
154 
155 TEST(cpp_type, Destruct)
156 {
157  int buffer[10] = {0};
160  EXPECT_EQ(buffer[1], 0);
161  CPPType_TestType.destruct_n((void *)buffer, 3);
165  EXPECT_EQ(buffer[3], 0);
166  CPPType_TestType.destruct_indices((void *)buffer, {2, 5, 7});
168  EXPECT_EQ(buffer[4], 0);
170  EXPECT_EQ(buffer[6], 0);
172  EXPECT_EQ(buffer[8], 0);
173 }
174 
175 TEST(cpp_type, CopyToUninitialized)
176 {
177  int buffer1[10] = {0};
178  int buffer2[10] = {0};
179  CPPType_TestType.copy_construct((void *)buffer1, (void *)buffer2);
181  EXPECT_EQ(buffer2[0], copy_constructed_value);
182  CPPType_TestType.copy_construct_n((void *)buffer1, (void *)buffer2, 3);
184  EXPECT_EQ(buffer2[0], copy_constructed_value);
186  EXPECT_EQ(buffer2[1], copy_constructed_value);
188  EXPECT_EQ(buffer2[2], copy_constructed_value);
189  EXPECT_EQ(buffer1[3], 0);
190  EXPECT_EQ(buffer2[3], 0);
191  CPPType_TestType.copy_construct_indices((void *)buffer1, (void *)buffer2, {2, 5, 7});
193  EXPECT_EQ(buffer2[2], copy_constructed_value);
194  EXPECT_EQ(buffer1[4], 0);
195  EXPECT_EQ(buffer2[4], 0);
197  EXPECT_EQ(buffer2[5], copy_constructed_value);
198  EXPECT_EQ(buffer1[6], 0);
199  EXPECT_EQ(buffer2[6], 0);
201  EXPECT_EQ(buffer2[7], copy_constructed_value);
202  EXPECT_EQ(buffer1[8], 0);
203  EXPECT_EQ(buffer2[8], 0);
204 }
205 
206 TEST(cpp_type, CopyToInitialized)
207 {
208  int buffer1[10] = {0};
209  int buffer2[10] = {0};
210  CPPType_TestType.copy_assign((void *)buffer1, (void *)buffer2);
211  EXPECT_EQ(buffer1[0], copy_assigned_from_value);
212  EXPECT_EQ(buffer2[0], copy_assigned_value);
213  CPPType_TestType.copy_assign_n((void *)buffer1, (void *)buffer2, 3);
214  EXPECT_EQ(buffer1[0], copy_assigned_from_value);
215  EXPECT_EQ(buffer2[0], copy_assigned_value);
216  EXPECT_EQ(buffer1[1], copy_assigned_from_value);
217  EXPECT_EQ(buffer2[1], copy_assigned_value);
218  EXPECT_EQ(buffer1[2], copy_assigned_from_value);
219  EXPECT_EQ(buffer2[2], copy_assigned_value);
220  EXPECT_EQ(buffer1[3], 0);
221  EXPECT_EQ(buffer2[3], 0);
222  CPPType_TestType.copy_assign_indices((void *)buffer1, (void *)buffer2, {2, 5, 7});
223  EXPECT_EQ(buffer1[2], copy_assigned_from_value);
224  EXPECT_EQ(buffer2[2], copy_assigned_value);
225  EXPECT_EQ(buffer1[4], 0);
226  EXPECT_EQ(buffer2[4], 0);
227  EXPECT_EQ(buffer1[5], copy_assigned_from_value);
228  EXPECT_EQ(buffer2[5], copy_assigned_value);
229  EXPECT_EQ(buffer1[6], 0);
230  EXPECT_EQ(buffer2[6], 0);
231  EXPECT_EQ(buffer1[7], copy_assigned_from_value);
232  EXPECT_EQ(buffer2[7], copy_assigned_value);
233  EXPECT_EQ(buffer1[8], 0);
234  EXPECT_EQ(buffer2[8], 0);
235 }
236 
237 TEST(cpp_type, RelocateToUninitialized)
238 {
239  int buffer1[10] = {0};
240  int buffer2[10] = {0};
241  CPPType_TestType.relocate_construct((void *)buffer1, (void *)buffer2);
242  EXPECT_EQ(buffer1[0], destructed_value);
243  EXPECT_EQ(buffer2[0], move_constructed_value);
244  CPPType_TestType.relocate_construct_n((void *)buffer1, (void *)buffer2, 3);
245  EXPECT_EQ(buffer1[0], destructed_value);
246  EXPECT_EQ(buffer2[0], move_constructed_value);
247  EXPECT_EQ(buffer1[1], destructed_value);
248  EXPECT_EQ(buffer2[1], move_constructed_value);
249  EXPECT_EQ(buffer1[2], destructed_value);
250  EXPECT_EQ(buffer2[2], move_constructed_value);
251  EXPECT_EQ(buffer1[3], 0);
252  EXPECT_EQ(buffer2[3], 0);
253  CPPType_TestType.relocate_construct_indices((void *)buffer1, (void *)buffer2, {2, 5, 7});
254  EXPECT_EQ(buffer1[2], destructed_value);
255  EXPECT_EQ(buffer2[2], move_constructed_value);
256  EXPECT_EQ(buffer1[4], 0);
257  EXPECT_EQ(buffer2[4], 0);
258  EXPECT_EQ(buffer1[5], destructed_value);
259  EXPECT_EQ(buffer2[5], move_constructed_value);
260  EXPECT_EQ(buffer1[6], 0);
261  EXPECT_EQ(buffer2[6], 0);
262  EXPECT_EQ(buffer1[7], destructed_value);
263  EXPECT_EQ(buffer2[7], move_constructed_value);
264  EXPECT_EQ(buffer1[8], 0);
265  EXPECT_EQ(buffer2[8], 0);
266 }
267 
268 TEST(cpp_type, RelocateToInitialized)
269 {
270  int buffer1[10] = {0};
271  int buffer2[10] = {0};
272  CPPType_TestType.relocate_assign((void *)buffer1, (void *)buffer2);
273  EXPECT_EQ(buffer1[0], destructed_value);
274  EXPECT_EQ(buffer2[0], move_assigned_value);
275  CPPType_TestType.relocate_assign_n((void *)buffer1, (void *)buffer2, 3);
276  EXPECT_EQ(buffer1[0], destructed_value);
277  EXPECT_EQ(buffer2[0], move_assigned_value);
278  EXPECT_EQ(buffer1[1], destructed_value);
279  EXPECT_EQ(buffer2[1], move_assigned_value);
280  EXPECT_EQ(buffer1[2], destructed_value);
281  EXPECT_EQ(buffer2[2], move_assigned_value);
282  EXPECT_EQ(buffer1[3], 0);
283  EXPECT_EQ(buffer2[3], 0);
284  CPPType_TestType.relocate_assign_indices((void *)buffer1, (void *)buffer2, {2, 5, 7});
285  EXPECT_EQ(buffer1[2], destructed_value);
286  EXPECT_EQ(buffer2[2], move_assigned_value);
287  EXPECT_EQ(buffer1[4], 0);
288  EXPECT_EQ(buffer2[4], 0);
289  EXPECT_EQ(buffer1[5], destructed_value);
290  EXPECT_EQ(buffer2[5], move_assigned_value);
291  EXPECT_EQ(buffer1[6], 0);
292  EXPECT_EQ(buffer2[6], 0);
293  EXPECT_EQ(buffer1[7], destructed_value);
294  EXPECT_EQ(buffer2[7], move_assigned_value);
295  EXPECT_EQ(buffer1[8], 0);
296  EXPECT_EQ(buffer2[8], 0);
297 }
298 
299 TEST(cpp_type, FillInitialized)
300 {
301  int buffer1 = 0;
302  int buffer2[10] = {0};
303  CPPType_TestType.fill_assign_n((void *)&buffer1, (void *)buffer2, 3);
305  EXPECT_EQ(buffer2[0], copy_assigned_value);
306  EXPECT_EQ(buffer2[1], copy_assigned_value);
307  EXPECT_EQ(buffer2[2], copy_assigned_value);
308  EXPECT_EQ(buffer2[3], 0);
309 
310  buffer1 = 0;
311  CPPType_TestType.fill_assign_indices((void *)&buffer1, (void *)buffer2, {1, 6, 8});
313  EXPECT_EQ(buffer2[0], copy_assigned_value);
314  EXPECT_EQ(buffer2[1], copy_assigned_value);
315  EXPECT_EQ(buffer2[2], copy_assigned_value);
316  EXPECT_EQ(buffer2[3], 0);
317  EXPECT_EQ(buffer2[4], 0);
318  EXPECT_EQ(buffer2[5], 0);
319  EXPECT_EQ(buffer2[6], copy_assigned_value);
320  EXPECT_EQ(buffer2[7], 0);
321  EXPECT_EQ(buffer2[8], copy_assigned_value);
322  EXPECT_EQ(buffer2[9], 0);
323 }
324 
325 TEST(cpp_type, FillUninitialized)
326 {
327  int buffer1 = 0;
328  int buffer2[10] = {0};
329  CPPType_TestType.fill_construct_n((void *)&buffer1, (void *)buffer2, 3);
331  EXPECT_EQ(buffer2[0], copy_constructed_value);
332  EXPECT_EQ(buffer2[1], copy_constructed_value);
333  EXPECT_EQ(buffer2[2], copy_constructed_value);
334  EXPECT_EQ(buffer2[3], 0);
335 
336  buffer1 = 0;
337  CPPType_TestType.fill_construct_indices((void *)&buffer1, (void *)buffer2, {1, 6, 8});
339  EXPECT_EQ(buffer2[0], copy_constructed_value);
340  EXPECT_EQ(buffer2[1], copy_constructed_value);
341  EXPECT_EQ(buffer2[2], copy_constructed_value);
342  EXPECT_EQ(buffer2[3], 0);
343  EXPECT_EQ(buffer2[4], 0);
344  EXPECT_EQ(buffer2[5], 0);
345  EXPECT_EQ(buffer2[6], copy_constructed_value);
346  EXPECT_EQ(buffer2[7], 0);
347  EXPECT_EQ(buffer2[8], copy_constructed_value);
348  EXPECT_EQ(buffer2[9], 0);
349 }
350 
351 TEST(cpp_type, DebugPrint)
352 {
353  int value = 42;
354  std::stringstream ss;
355  CPPType::get<int32_t>().print((void *)&value, ss);
356  std::string text = ss.str();
357  EXPECT_EQ(text, "42");
358 }
359 
360 TEST(cpp_type, ToStaticType)
361 {
363  bool found_unsupported_type = false;
364  auto fn = [&](auto type_tag) {
365  using T = typename decltype(type_tag)::type;
366  if constexpr (!std::is_same_v<T, void>) {
367  types.append(&CPPType::get<T>());
368  }
369  else {
370  found_unsupported_type = true;
371  }
372  };
373  CPPType::get<std::string>().to_static_type_tag<int, float, std::string>(fn);
374  CPPType::get<float>().to_static_type_tag<int, float, std::string>(fn);
375  EXPECT_FALSE(found_unsupported_type);
376  CPPType::get<int64_t>().to_static_type_tag<int, float, std::string>(fn);
377  EXPECT_TRUE(found_unsupported_type);
378 
379  EXPECT_EQ(types.size(), 2);
380  EXPECT_EQ(types[0], &CPPType::get<std::string>());
381  EXPECT_EQ(types[1], &CPPType::get<float>());
382 }
383 
384 TEST(cpp_type, CopyAssignCompressed)
385 {
386  std::array<std::string, 5> array = {"a", "b", "c", "d", "e"};
387  std::array<std::string, 3> array_compressed;
388  CPPType::get<std::string>().copy_assign_compressed(&array, &array_compressed, {0, 2, 3});
389  EXPECT_EQ(array_compressed[0], "a");
390  EXPECT_EQ(array_compressed[1], "c");
391  EXPECT_EQ(array_compressed[2], "d");
392 }
393 
394 } // namespace blender::tests
typedef float(TangentPoint)[2]
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
#define UNUSED(x)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
void destruct_indices(void *ptr, IndexMask mask) const
void relocate_construct_indices(void *src, void *dst, IndexMask mask) const
void copy_construct_n(const void *src, void *dst, int64_t n) const
void value_initialize_indices(void *ptr, IndexMask mask) const
void default_construct_n(void *ptr, int64_t n) const
void fill_assign_indices(const void *value, void *dst, IndexMask mask) const
void destruct_n(void *ptr, int64_t n) const
void default_construct_indices(void *ptr, IndexMask mask) const
void fill_assign_n(const void *value, void *dst, int64_t n) const
void copy_assign_indices(const void *src, void *dst, IndexMask mask) const
void relocate_assign_n(void *src, void *dst, int64_t n) const
void fill_construct_n(const void *value, void *dst, int64_t n) const
void relocate_construct(void *src, void *dst) const
bool is() const
void copy_assign_n(const void *src, void *dst, int64_t n) const
void value_initialize_n(void *ptr, int64_t n) const
void copy_construct(const void *src, void *dst) const
void destruct(void *ptr) const
int64_t size() const
void fill_construct_indices(const void *value, void *dst, IndexMask mask) const
int64_t alignment() const
void copy_assign(const void *src, void *dst) const
void relocate_assign_indices(void *src, void *dst, IndexMask mask) const
void relocate_construct_n(void *src, void *dst, int64_t n) const
void relocate_assign(void *src, void *dst) const
void default_construct(void *ptr) const
void value_initialize(void *ptr) const
void copy_construct_indices(const void *src, void *dst, IndexMask mask) const
BLI_CPP_TYPE_MAKE(GeometrySet, GeometrySet, CPPTypeFlags::Printable)
ccl_global float * buffer
static char ** types
Definition: makesdna.c:67
#define T
static unsigned a[3]
Definition: RandGen.cpp:78
static const CPPType & CPPType_TestType
static const int move_assigned_from_value
static const int move_constructed_from_value
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
TEST(any, DefaultConstructor)
Definition: BLI_any_test.cc:10
static const int destructed_value
static const int default_constructed_value
static const int copy_assigned_value
static const int copy_constructed_value
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
unsigned __int64 uint64_t
Definition: stdint.h:90
friend std::ostream & operator<<(std::ostream &stream, const TestType &value)
TestType & operator=(TestType &&other) noexcept
friend bool operator==(const TestType &UNUSED(a), const TestType &UNUSED(b))
TestType & operator=(const TestType &other)
TestType(TestType &&other) noexcept
TestType(const TestType &other)