Blender  V3.3
BLI_memiter_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 "MEM_guardedalloc.h"
6 
7 #include "BLI_array_utils.h"
8 #include "BLI_memiter.h"
9 
10 #include "BLI_ressource_strings.h"
11 #include "BLI_string.h"
12 
13 TEST(memiter, Nop)
14 {
17 }
18 
19 static void memiter_empty_test(int elems_num, const int chunk_size)
20 {
22  void *data;
23  for (int index = 0; index < elems_num; index++) {
24  data = BLI_memiter_alloc(mi, 0);
25  }
26  int index = 0, total_size = 0;
28  BLI_memiter_iter_init(mi, &it);
29  uint elem_size;
30  while ((data = BLI_memiter_iter_step_size(&it, &elem_size))) {
31  index += 1;
32  total_size += elem_size;
33  }
34  EXPECT_EQ(0, total_size);
35  EXPECT_EQ(elems_num, index);
36 
38 }
39 
40 #define MEMITER_NUMBER_TEST_FN(fn, number_type) \
41  static void fn(int elems_num, const int chunk_size) \
42  { \
43  BLI_memiter *mi = BLI_memiter_create(chunk_size); \
44  number_type *data; \
45  for (int index = 0; index < elems_num; index++) { \
46  data = (number_type *)BLI_memiter_alloc(mi, sizeof(number_type)); \
47  *data = index; \
48  } \
49  BLI_memiter_handle it; \
50  BLI_memiter_iter_init(mi, &it); \
51  uint elem_size; \
52  int index = 0; \
53  while ((data = (number_type *)BLI_memiter_iter_step_size(&it, &elem_size))) { \
54  EXPECT_EQ(sizeof(number_type), elem_size); \
55  EXPECT_EQ(index, *data); \
56  index += 1; \
57  } \
58  BLI_memiter_destroy(mi); \
59  }
60 
61 /* generate number functions */
62 MEMITER_NUMBER_TEST_FN(memiter_char_test, char)
63 MEMITER_NUMBER_TEST_FN(memiter_short_test, short)
64 MEMITER_NUMBER_TEST_FN(memiter_int_test, int)
65 MEMITER_NUMBER_TEST_FN(memiter_long_test, int64_t)
66 
67 static void memiter_string_test(const char *strings[], const int chunk_size)
68 {
70  char *data;
71  int index = 0;
72  int total_size_expect = 0;
73  while (strings[index]) {
74  const int size = strlen(strings[index]) + 1;
75  BLI_memiter_alloc_from(mi, size, strings[index]);
76  total_size_expect += size;
77  index += 1;
78  }
79  const int strings_len = index;
80  int total_size = 0;
82  BLI_memiter_iter_init(mi, &it);
83  uint elem_size;
84  index = 0;
85  while ((data = (char *)BLI_memiter_iter_step_size(&it, &elem_size))) {
86  EXPECT_EQ(strlen(strings[index]) + 1, elem_size);
87  EXPECT_STREQ(strings[index], data);
88  total_size += elem_size;
89  index += 1;
90  }
91  EXPECT_EQ(total_size_expect, total_size);
92  EXPECT_EQ(strings_len, index);
93 
95 }
96 
97 static void memiter_words10k_test(const char split_char, const int chunk_size)
98 {
99  const int words_len = sizeof(words10k) - 1;
100  char *words = BLI_strdupn(words10k, words_len);
101  BLI_str_replace_char(words, split_char, '\0');
102 
104 
105  char *data;
106  int index;
107  char *c_end, *c;
108  c_end = words + words_len;
109  c = words;
110  index = 0;
111  while (c < c_end) {
112  int elem_size = strlen(c) + 1;
113  data = (char *)BLI_memiter_alloc(mi, elem_size);
114  memcpy(data, c, elem_size);
115  c += elem_size;
116  index += 1;
117  }
118  const int len_expect = index;
119  c = words;
120  uint size;
122  BLI_memiter_iter_init(mi, &it);
123  index = 0;
124  while ((data = (char *)BLI_memiter_iter_step_size(&it, &size))) {
125  int size_expect = strlen(c) + 1;
126  EXPECT_EQ(size_expect, size);
127  EXPECT_STREQ(c, data);
128  c += size;
129  index += 1;
130  }
131  EXPECT_EQ(len_expect, index);
133  MEM_freeN(words);
134 }
135 
136 #define TEST_EMPTY_AT_CHUNK_SIZE(chunk_size) \
137  TEST(memiter, Empty0_##chunk_size) \
138  { \
139  memiter_empty_test(0, chunk_size); \
140  } \
141  TEST(memiter, Empty1_##chunk_size) \
142  { \
143  memiter_empty_test(1, chunk_size); \
144  } \
145  TEST(memiter, Empty2_##chunk_size) \
146  { \
147  memiter_empty_test(2, chunk_size); \
148  } \
149  TEST(memiter, Empty3_##chunk_size) \
150  { \
151  memiter_empty_test(3, chunk_size); \
152  } \
153  TEST(memiter, Empty13_##chunk_size) \
154  { \
155  memiter_empty_test(13, chunk_size); \
156  } \
157  TEST(memiter, Empty256_##chunk_size) \
158  { \
159  memiter_empty_test(256, chunk_size); \
160  }
161 
167 
168 #define TEST_NUMBER_AT_CHUNK_SIZE(chunk_size) \
169  TEST(memiter, Char1_##chunk_size) \
170  { \
171  memiter_char_test(1, chunk_size); \
172  } \
173  TEST(memiter, Short1_##chunk_size) \
174  { \
175  memiter_short_test(1, chunk_size); \
176  } \
177  TEST(memiter, Int1_##chunk_size) \
178  { \
179  memiter_int_test(1, chunk_size); \
180  } \
181  TEST(memiter, Long1_##chunk_size) \
182  { \
183  memiter_long_test(1, chunk_size); \
184  } \
185 \
186  TEST(memiter, Char2_##chunk_size) \
187  { \
188  memiter_char_test(2, chunk_size); \
189  } \
190  TEST(memiter, Short2_##chunk_size) \
191  { \
192  memiter_short_test(2, chunk_size); \
193  } \
194  TEST(memiter, Int2_##chunk_size) \
195  { \
196  memiter_int_test(2, chunk_size); \
197  } \
198  TEST(memiter, Long2_##chunk_size) \
199  { \
200  memiter_long_test(2, chunk_size); \
201  } \
202 \
203  TEST(memiter, Char3_##chunk_size) \
204  { \
205  memiter_char_test(3, chunk_size); \
206  } \
207  TEST(memiter, Short3_##chunk_size) \
208  { \
209  memiter_short_test(3, chunk_size); \
210  } \
211  TEST(memiter, Int3_##chunk_size) \
212  { \
213  memiter_int_test(3, chunk_size); \
214  } \
215  TEST(memiter, Long3_##chunk_size) \
216  { \
217  memiter_long_test(3, chunk_size); \
218  } \
219 \
220  TEST(memiter, Char256_##chunk_size) \
221  { \
222  memiter_char_test(256, chunk_size); \
223  } \
224  TEST(memiter, Short256_##chunk_size) \
225  { \
226  memiter_short_test(256, chunk_size); \
227  } \
228  TEST(memiter, Int256_##chunk_size) \
229  { \
230  memiter_int_test(256, chunk_size); \
231  } \
232  TEST(memiter, Long256_##chunk_size) \
233  { \
234  memiter_long_test(256, chunk_size); \
235  }
236 
242 
243 #define STRINGS_TEST(chunk_size, ...) \
244  { \
245  const char *data[] = {__VA_ARGS__, NULL}; \
246  memiter_string_test(data, chunk_size); \
247  }
248 
249 #define TEST_STRINGS_AT_CHUNK_SIZE(chunk_size) \
250  TEST(memiter, Strings_##chunk_size) \
251  { \
252  STRINGS_TEST(chunk_size, ""); \
253  STRINGS_TEST(chunk_size, "test", "me"); \
254  STRINGS_TEST(chunk_size, "more", "test", "data", "to", "follow"); \
255  }
256 
262 
263 #define TEST_WORDS10K_AT_CHUNK_SIZE(chunk_size) \
264  TEST(memiter, Words10kSentence_##chunk_size) \
265  { \
266  memiter_words10k_test('.', chunk_size); \
267  } \
268  TEST(memiter, Words10kWords_##chunk_size) \
269  { \
270  memiter_words10k_test(' ', chunk_size); \
271  }
272 
Generic array manipulation API.
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void * BLI_memiter_alloc(BLI_memiter *mi, unsigned int size) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
Definition: BLI_memiter.c:131
void BLI_memiter_destroy(BLI_memiter *mi) ATTR_NONNULL(1)
Definition: BLI_memiter.c:218
void BLI_memiter_alloc_from(BLI_memiter *mi, uint elem_size, const void *data_from) ATTR_NONNULL(1
void * BLI_memiter_iter_step_size(BLI_memiter_handle *iter, uint *r_size) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
BLI_memiter * BLI_memiter_create(unsigned int chunk_size_min) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
Definition: BLI_memiter.c:114
void BLI_memiter_iter_init(BLI_memiter *mi, BLI_memiter_handle *iter) ATTR_NONNULL(1
static void memiter_words10k_test(const char split_char, const int chunk_size)
#define TEST_WORDS10K_AT_CHUNK_SIZE(chunk_size)
#define TEST_NUMBER_AT_CHUNK_SIZE(chunk_size)
TEST(memiter, Nop)
#define TEST_EMPTY_AT_CHUNK_SIZE(chunk_size)
#define TEST_STRINGS_AT_CHUNK_SIZE(chunk_size)
static void memiter_string_test(const char *strings[], const int chunk_size)
#define MEMITER_NUMBER_TEST_FN(fn, number_type)
static void memiter_empty_test(int elems_num, const int chunk_size)
const char words10k[]
void BLI_str_replace_char(char *str, char src, char dst) ATTR_NONNULL()
Definition: string.c:503
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition: string.c:33
unsigned int uint
Definition: BLI_sys_types.h:67
Read Guarded memory(de)allocation.
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
static unsigned c
Definition: RandGen.cpp:83
static const int chunk_size
__int64 int64_t
Definition: stdint.h:89