Blender V5.3
BLI_listbase_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 "MEM_guardedalloc.h"
8
10#include "BLI_listbase.hh"
11#include "BLI_path_utils.hh"
13#include "BLI_string.hh"
14
15namespace blender {
16
17/* local validation function */
18static bool listbase_is_valid(const ListBase *listbase)
19{
20#define TESTFAIL(test) \
21 if (!(test)) { \
22 goto fail; \
23 } \
24 ((void)0)
25
26 if (listbase->first_) {
27 const Link *prev, *link;
28 link = static_cast<Link *>(listbase->first_);
29 TESTFAIL(link->prev == nullptr);
30
31 link = static_cast<Link *>(listbase->last_);
32 TESTFAIL(link->next == nullptr);
33
34 prev = nullptr;
35 link = static_cast<Link *>(listbase->first_);
36 do {
37 TESTFAIL(link->prev == prev);
38 } while ((void)(prev = link), (link = link->next));
39 TESTFAIL(prev == listbase->last_);
40
41 prev = nullptr;
42 link = static_cast<Link *>(listbase->last_);
43 do {
44 TESTFAIL(link->next == prev);
45 } while ((void)(prev = link), (link = link->prev));
46 TESTFAIL(prev == listbase->first_);
47 }
48 else {
49 TESTFAIL(listbase->last_ == nullptr);
50 }
51#undef TESTFAIL
52
53 return true;
54
55fail:
56 return false;
57}
58
59static int char_switch(char *string, char ch_src, char ch_dst)
60{
61 int tot = 0;
62 while (*string != 0) {
63 if (*string == ch_src) {
64 *string = ch_dst;
65 tot++;
66 }
67 string++;
68 }
69 return tot;
70}
71
72TEST(listbase, FindLinkOrIndex)
73{
74 ListBaseT<Link> lb;
75 void *link1 = MEM_new_zeroed<Link>("link1");
76 void *link2 = MEM_new_zeroed<Link>("link2");
77
78 /* Empty list */
79 lb.clear_no_delete();
80 EXPECT_EQ(BLI_findlink(&lb, -1), static_cast<void *>(nullptr));
81 EXPECT_EQ(BLI_findlink(&lb, 0), static_cast<void *>(nullptr));
82 EXPECT_EQ(BLI_findlink(&lb, 1), static_cast<void *>(nullptr));
83 EXPECT_EQ(BLI_rfindlink(&lb, -1), static_cast<void *>(nullptr));
84 EXPECT_EQ(BLI_rfindlink(&lb, 0), static_cast<void *>(nullptr));
85 EXPECT_EQ(BLI_rfindlink(&lb, 1), static_cast<void *>(nullptr));
86 EXPECT_EQ(BLI_findindex(&lb, link1), -1);
87 EXPECT_EQ(BLI_findlinkfrom(static_cast<Link *>(lb.first_), -1), static_cast<void *>(nullptr));
88 EXPECT_EQ(BLI_findlinkfrom(static_cast<Link *>(lb.first_), 0), static_cast<void *>(nullptr));
89 EXPECT_EQ(BLI_findlinkfrom(static_cast<Link *>(lb.first_), 1), static_cast<void *>(nullptr));
90
91 /* One link */
92 BLI_addtail(&lb, link1);
93 EXPECT_EQ(BLI_findlink(&lb, 0), link1);
94 EXPECT_EQ(BLI_rfindlink(&lb, 0), link1);
95 EXPECT_EQ(BLI_findindex(&lb, link1), 0);
96 EXPECT_EQ(BLI_findlinkfrom(static_cast<Link *>(lb.first_), 0), link1);
97
98 /* Two links */
99 BLI_addtail(&lb, link2);
100 EXPECT_EQ(BLI_findlink(&lb, 1), link2);
101 EXPECT_EQ(BLI_rfindlink(&lb, 0), link2);
102 EXPECT_EQ(BLI_findindex(&lb, link2), 1);
103 EXPECT_EQ(BLI_findlinkfrom(static_cast<Link *>(lb.first_), 1), link2);
104
105 /* After end of list */
106 EXPECT_EQ(BLI_findlinkfrom(static_cast<Link *>(lb.first_), 2), static_cast<void *>(nullptr));
107
108 lb.free_no_destruct();
109}
110
111TEST(listbase, FindLinkFromStringOrPointer)
112{
113 struct TestLink {
114 TestLink *next, *prev;
115 char name[64];
116 const void *ptr;
117 };
118
119 const char *const link1_name = "Link1";
120 const char *const link2_name = "Link2";
121 const void *const link1_ptr = nullptr;
122 const void *const link2_ptr = link2_name;
123
124 const size_t name_offset = offsetof(TestLink, name);
125 const size_t ptr_offset = offsetof(TestLink, ptr);
126
127 ListBaseT<TestLink> lb;
128 TestLink *link1 = MEM_new_zeroed<TestLink>("link1");
129 STRNCPY(link1->name, link1_name);
130 link1->ptr = link1_ptr;
131 TestLink *link2 = MEM_new_zeroed<TestLink>("link2");
132 STRNCPY(link2->name, link2_name);
133 link2->ptr = link2_ptr;
134
135 /* Empty list */
136 lb.clear_no_delete();
137 EXPECT_EQ(BLI_findptr(&lb, link1_ptr, ptr_offset), static_cast<void *>(nullptr));
138 EXPECT_EQ(BLI_findstring(&lb, link1_name, name_offset), static_cast<void *>(nullptr));
139 EXPECT_EQ(BLI_rfindptr(&lb, link1_ptr, ptr_offset), static_cast<void *>(nullptr));
140 EXPECT_EQ(BLI_rfindstring(&lb, link1_name, name_offset), static_cast<void *>(nullptr));
141 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, link1_name, name_offset, 0),
142 static_cast<void *>(nullptr));
143
144 /* One link */
145 BLI_addtail(&lb, link1);
146 EXPECT_EQ(BLI_findptr(&lb, link1_ptr, ptr_offset), static_cast<void *>(link1));
147 EXPECT_EQ(BLI_findstring(&lb, link1_name, name_offset), static_cast<void *>(link1));
148 EXPECT_EQ(BLI_rfindptr(&lb, link1_ptr, ptr_offset), static_cast<void *>(link1));
149 EXPECT_EQ(BLI_rfindstring(&lb, link1_name, name_offset), static_cast<void *>(link1));
150 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, link1_name, name_offset, 0),
151 static_cast<void *>(link1));
152 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, "", name_offset, 0),
153 static_cast<void *>(link1));
154 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, nullptr, name_offset, 0),
155 static_cast<void *>(link1));
156 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, nullptr, name_offset, 1),
157 static_cast<void *>(nullptr));
158
159 /* Two links */
160 BLI_addtail(&lb, link2);
161 EXPECT_EQ(BLI_findptr(&lb, link1_ptr, ptr_offset), static_cast<void *>(link1));
162 EXPECT_EQ(BLI_findstring(&lb, link1_name, name_offset), static_cast<void *>(link1));
163 EXPECT_EQ(BLI_rfindptr(&lb, link1_ptr, ptr_offset), static_cast<void *>(link1));
164 EXPECT_EQ(BLI_rfindstring(&lb, link1_name, name_offset), static_cast<void *>(link1));
165 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, link1_name, name_offset, 0),
166 static_cast<void *>(link1));
167 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, link2_name, name_offset, 0),
168 static_cast<void *>(link2));
169 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, nullptr, name_offset, 0),
170 static_cast<void *>(link1));
171 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, nullptr, name_offset, 1),
172 static_cast<void *>(link2));
173 EXPECT_EQ(BLI_listbase_string_or_index_find(&lb, nullptr, name_offset, -1),
174 static_cast<void *>(nullptr));
175
176 lb.free_no_destruct();
177}
178
179TEST(listbase, FromLink)
180{
181 ListBaseT<Link> lb = {nullptr, nullptr};
182 Link *link1 = MEM_new_zeroed<Link>("link1");
183 Link *link2 = MEM_new_zeroed<Link>("link2");
184 Link *link3 = MEM_new_zeroed<Link>("link3");
185
186 /* Null safety. */
187 EXPECT_EQ(lb, BLI_listbase_from_link(nullptr));
188
189 /* One link. */
190 BLI_addtail(&lb, link1);
192
193 /* Two links. */
194 BLI_addtail(&lb, link2);
196
197 /* Three links, search from middle. */
198 BLI_addtail(&lb, link3);
200
201 lb.free_no_destruct();
202}
203
204TEST(listbase, SplitAfter)
205{
206 ListBaseT<Link> lb;
207 ListBaseT<Link> split_after_lb;
208 void *link1 = MEM_new_zeroed<Link>("link1");
209 void *link2 = MEM_new_zeroed<Link>("link2");
210
211 /* Empty list */
212 lb.clear_no_delete();
213 split_after_lb.clear_no_delete();
214
215 BLI_listbase_split_after(&lb, &split_after_lb, nullptr);
216 EXPECT_EQ(split_after_lb.is_empty(), true);
217
218 /* One link */
219 lb.clear_no_delete();
220 split_after_lb.clear_no_delete();
221 BLI_addtail(&lb, link1);
222
223 BLI_listbase_split_after(&lb, &split_after_lb, nullptr);
224 EXPECT_EQ(lb.is_empty(), true);
225 EXPECT_EQ(split_after_lb.count(), 1);
226 EXPECT_EQ(BLI_findindex(&split_after_lb, link1), 0);
227 EXPECT_EQ(split_after_lb.first_, link1);
228 EXPECT_EQ(split_after_lb.last(), link1);
229
230 lb.clear_no_delete();
231 split_after_lb.clear_no_delete();
232 BLI_addtail(&lb, link1);
233
234 BLI_listbase_split_after(&lb, &split_after_lb, link1);
235 EXPECT_EQ(lb.count(), 1);
236 EXPECT_EQ(BLI_findindex(&lb, link1), 0);
237 EXPECT_EQ(lb.first_, link1);
238 EXPECT_EQ(lb.last(), link1);
239 EXPECT_EQ(split_after_lb.is_empty(), true);
240
241 /* Two links */
242 lb.clear_no_delete();
243 split_after_lb.clear_no_delete();
244 BLI_addtail(&lb, link1);
245 BLI_addtail(&lb, link2);
246
247 BLI_listbase_split_after(&lb, &split_after_lb, nullptr);
248 EXPECT_EQ(lb.is_empty(), true);
249 EXPECT_EQ(split_after_lb.count(), 2);
250 EXPECT_EQ(BLI_findindex(&split_after_lb, link1), 0);
251 EXPECT_EQ(BLI_findindex(&split_after_lb, link2), 1);
252 EXPECT_EQ(split_after_lb.first_, link1);
253 EXPECT_EQ(split_after_lb.last(), link2);
254
255 lb.clear_no_delete();
256 split_after_lb.clear_no_delete();
257 BLI_addtail(&lb, link1);
258 BLI_addtail(&lb, link2);
259
260 BLI_listbase_split_after(&lb, &split_after_lb, link1);
261 EXPECT_EQ(lb.count(), 1);
262 EXPECT_EQ(BLI_findindex(&lb, link1), 0);
263 EXPECT_EQ(lb.first_, link1);
264 EXPECT_EQ(lb.last(), link1);
265 EXPECT_EQ(split_after_lb.count(), 1);
266 EXPECT_EQ(BLI_findindex(&split_after_lb, link2), 0);
267 EXPECT_EQ(split_after_lb.first_, link2);
268 EXPECT_EQ(split_after_lb.last(), link2);
269
270 lb.free_no_destruct();
271 split_after_lb.free_no_destruct();
272}
273
274TEST(listbase, EnumerateIterator)
275{
276 struct TestLink {
277 TestLink *next, *prev;
278 int value;
279 };
280
281 ListBaseT<TestLink> lb;
282 lb.clear_no_delete();
283
284 TestLink *link1 = MEM_new_zeroed<TestLink>("link1");
285 link1->value = 10;
286 BLI_addtail(&lb, link1);
287
288 TestLink *link2 = MEM_new_zeroed<TestLink>("link2");
289 link2->value = 20;
290 BLI_addtail(&lb, link2);
291
292 int count = 0;
293 for (auto [i, link] : lb.enumerate()) {
294 EXPECT_EQ(i, count);
295 if (i == 0) {
296 EXPECT_EQ(&link, link1);
297 EXPECT_EQ(link.value, 10);
298 }
299 else if (i == 1) {
300 EXPECT_EQ(&link, link2);
301 EXPECT_EQ(link.value, 20);
302 }
303 count++;
304 }
305 EXPECT_EQ(count, 2);
306
307 lb.free_no_destruct();
308}
309
310TEST(listbase, ReversedIterator)
311{
312 struct TestLink {
313 TestLink *next, *prev;
314 int value;
315 };
316
317 ListBaseT<TestLink> lb;
318 lb.clear_no_delete();
319
320 TestLink *link1 = MEM_new_zeroed<TestLink>("link1");
321 link1->value = 10;
322 BLI_addtail(&lb, link1);
323
324 TestLink *link2 = MEM_new_zeroed<TestLink>("link2");
325 link2->value = 20;
326 BLI_addtail(&lb, link2);
327
328 int count = 0;
329 for (TestLink &link : lb.items_reversed()) {
330 if (count == 0) {
331 EXPECT_EQ(&link, link2);
332 }
333 else if (count == 1) {
334 EXPECT_EQ(&link, link1);
335 }
336 count++;
337 }
338 EXPECT_EQ(count, 2);
339
340 lb.free_no_destruct();
341}
342
343TEST(listbase, MutableIterator)
344{
345 struct TestLink {
346 TestLink *next, *prev;
347 int value;
348 };
349
350 ListBaseT<TestLink> lb;
351 lb.clear_no_delete();
352
353 TestLink *link1 = MEM_new_zeroed<TestLink>("link1");
354 BLI_addtail(&lb, link1);
355
356 TestLink *link2 = MEM_new_zeroed<TestLink>("link2");
357 BLI_addtail(&lb, link2);
358
359 TestLink *link3 = MEM_new_zeroed<TestLink>("link3");
360 BLI_addtail(&lb, link3);
361
362 int count = 0;
363 for (TestLink &link : lb.items_mutable()) {
364 count++;
365 if (&link == link2) {
366 BLI_freelinkN(&lb, &link);
367 }
368 }
369 EXPECT_EQ(count, 3);
370 EXPECT_EQ(lb.count(), 2);
371 EXPECT_EQ(lb.first_, link1);
372 EXPECT_EQ(lb.last(), link3);
373
374 lb.free_no_destruct();
375}
376
377TEST(listbase, MutableReversedIterator)
378{
379 struct TestLink {
380 TestLink *next, *prev;
381 int value;
382 };
383
384 ListBaseT<TestLink> lb;
385 lb.clear_no_delete();
386
387 TestLink *link1 = MEM_new_zeroed<TestLink>("link1");
388 BLI_addtail(&lb, link1);
389
390 TestLink *link2 = MEM_new_zeroed<TestLink>("link2");
391 BLI_addtail(&lb, link2);
392
393 TestLink *link3 = MEM_new_zeroed<TestLink>("link3");
394 BLI_addtail(&lb, link3);
395
396 int count = 0;
397 for (TestLink &link : lb.items_reversed_mutable()) {
398 count++;
399 if (&link == link2) {
400 BLI_freelinkN(&lb, &link);
401 }
402 }
403 EXPECT_EQ(count, 3);
404 EXPECT_EQ(lb.count(), 2);
405 EXPECT_EQ(lb.first_, link1);
406 EXPECT_EQ(lb.last(), link3);
407
408 lb.free_no_destruct();
409}
410
411/* -------------------------------------------------------------------- */
412/* Sort utilities & test */
413
414static int testsort_array_str_cmp(const void *a, const void *b)
415{
416 int i = strcmp(*static_cast<const char **>(const_cast<void *>(a)),
417 *static_cast<const char **>(const_cast<void *>(b)));
418 return (i > 0) ? 1 : (i < 0) ? -1 : 0;
419}
420
421static int testsort_listbase_str_cmp(const void *a, const void *b)
422{
423 const LinkData *link_a = static_cast<LinkData *>(const_cast<void *>(a));
424 const LinkData *link_b = static_cast<LinkData *>(const_cast<void *>(b));
425 int i = strcmp(static_cast<const char *>(link_a->data), static_cast<const char *>(link_b->data));
426 return (i > 0) ? 1 : (i < 0) ? -1 : 0;
427}
428
429static int testsort_array_str_cmp_reverse(const void *a, const void *b)
430{
431 return -testsort_array_str_cmp(a, b);
432}
433
434static int testsort_listbase_str_cmp_reverse(const void *a, const void *b)
435{
436 return -testsort_listbase_str_cmp(a, b);
437}
438
439/* check array and listbase compare */
440static bool testsort_listbase_array_str_cmp(ListBaseT<LinkData> *lb, char **arr, int arr_num)
441{
442 LinkData *link_step;
443 int i;
444
445 link_step = static_cast<LinkData *>(lb->first_);
446 for (i = 0; i < arr_num; i++) {
447 if (!STREQ(arr[i], (char *)link_step->data)) {
448 return false;
449 }
450 link_step = link_step->next;
451 }
452 if (link_step) {
453 return false;
454 }
455
456 return true;
457}
458
459/* assumes nodes are allocated in-order */
460static bool testsort_listbase_sort_is_stable(ListBaseT<LinkData> *lb, bool forward)
461{
462 LinkData *link_step;
463
464 link_step = static_cast<LinkData *>(lb->first_);
465 while (link_step && link_step->next) {
466 if (STREQ((const char *)link_step->data, (const char *)link_step->next->data)) {
467 if ((link_step < link_step->next) != forward) {
468 return false;
469 }
470 }
471 link_step = link_step->next;
472 }
473 return true;
474}
475
476TEST(listbase, Sort)
477{
478 const int words_len = sizeof(words10k) - 1;
479 char *words = BLI_strdupn(words10k, words_len);
480 int words_num;
481 char **words_arr; /* qsort for comparison */
482 int i;
483 char *w_step;
484 ListBaseT<LinkData> words_lb;
485 LinkData *words_linkdata_arr;
486
487 /* delimit words */
488 words_num = 1 + char_switch(words, ' ', '\0');
489
490 words_arr = MEM_new_array_uninitialized<char *>(size_t(words_num), __func__);
491
492 words_linkdata_arr = MEM_new_array_uninitialized<LinkData>(size_t(words_num), __func__);
493
494 /* create array */
495 w_step = words;
496 for (i = 0; i < words_num; i++) {
497 words_arr[i] = w_step;
498 w_step += strlen(w_step) + 1;
499 }
500
501 /* sort empty list */
502 {
503 words_lb.clear_no_delete();
505 EXPECT_TRUE(listbase_is_valid(&words_lb));
506 }
507
508 /* Sort single list. */
509 {
510 LinkData link;
511 link.data = words;
512 BLI_addtail(&words_lb, &link);
514 EXPECT_TRUE(listbase_is_valid(&words_lb));
515 words_lb.clear_no_delete();
516 }
517
518 /* create listbase */
519 words_lb.clear_no_delete();
520 w_step = words;
521 for (i = 0; i < words_num; i++) {
522 LinkData *link = &words_linkdata_arr[i];
523 link->data = w_step;
524 BLI_addtail(&words_lb, link);
525 w_step += strlen(w_step) + 1;
526 }
527 EXPECT_TRUE(listbase_is_valid(&words_lb));
528
529 /* sort (forward) */
530 {
531 qsort(words_arr, words_num, sizeof(*words_arr), testsort_array_str_cmp);
532
534 EXPECT_TRUE(listbase_is_valid(&words_lb));
535 EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
537 }
538
539 /* sort (reverse) */
540 {
541 qsort(words_arr, words_num, sizeof(*words_arr), testsort_array_str_cmp_reverse);
542
544 EXPECT_TRUE(listbase_is_valid(&words_lb));
545 EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
547 }
548
549 /* sort (forward but after reversing, test stability in alternate direction) */
550 {
551 BLI_array_reverse(words_arr, words_num);
552 BLI_listbase_reverse(&words_lb);
553
554 EXPECT_TRUE(listbase_is_valid(&words_lb));
555 EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
557
558 /* and again */
559 BLI_array_reverse(words_arr, words_num);
561 EXPECT_TRUE(testsort_listbase_array_str_cmp(&words_lb, words_arr, words_num));
563 }
564
565 MEM_delete(words);
566 MEM_delete(words_arr);
567 MEM_delete(words_linkdata_arr);
568}
569
570} // namespace blender
Generic array manipulation API.
#define BLI_array_reverse(arr, arr_len)
#define TESTFAIL(test)
Read Blender memory allocation and freeing.
#define STREQ(a, b)
#define offsetof(t, d)
#define EXPECT_TRUE(result)
BMesh Iterators.
void * BLI_findptr(const ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:710
static int testsort_listbase_str_cmp(const void *a, const void *b)
void * BLI_rfindlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:556
static int char_switch(char *string, char ch_src, char ch_dst)
char * STRNCPY(char(&dst)[N], const char *src)
static bool listbase_is_valid(const ListBase *listbase)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static int testsort_listbase_str_cmp_reverse(const void *a, const void *b)
void * BLI_rfindstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:633
static int testsort_array_str_cmp(const void *a, const void *b)
static bool testsort_listbase_array_str_cmp(ListBaseT< LinkData > *lb, char **arr, int arr_num)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
const char words10k[]
TEST(array_store, Nop)
void * BLI_findlinkfrom(Link *start, int step) ATTR_WARN_UNUSED_RESULT
Definition listbase.cc:571
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void void void void void BLI_listbase_split_after(ListBase *original_listbase, ListBase *split_listbase, void *vlink) ATTR_NONNULL(1
Definition listbase.cc:69
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
void * BLI_rfindptr(const ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:722
void void void void void void void BLI_listbase_reverse(ListBase *lb) ATTR_NONNULL(1)
Definition listbase.cc:850
void void BLI_listbase_sort(ListBase *listbase, int(*cmp)(const void *, const void *)) ATTR_NONNULL(1
Definition listbase.cc:319
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void void * BLI_listbase_string_or_index_find(const ListBase *listbase, const char *string, size_t string_offset, int index) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:768
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
static int testsort_array_str_cmp_reverse(const void *a, const void *b)
ListBase BLI_listbase_from_link(Link *some_link)
Definition listbase.cc:814
static bool testsort_listbase_sort_is_stable(ListBaseT< LinkData > *lb, bool forward)
struct LinkData * next