iPXE
Data Structures | Macros | Functions | Variables
list_test.c File Reference

List function tests. More...

#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <ipxe/list.h>
#include <ipxe/test.h>

Go to the source code of this file.

Data Structures

struct  list_test
 A list test structure. More...

Macros

#define list_contents_ok(list, expected)
 Report list test result.
#define list_iterate_ok(macro, expected, pos, ...)
 Report list iteration test result.
#define list_iterate_entry_ok(macro, expected, pos, ...)
 Report list entry iteration test result.

Functions

 FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static LIST_HEAD (test_list)
 Test list.
static int list_check_contents (struct list_head *list, const char *expected)
 Check list contents are as expected.
static void list_test_exec (void)
 Perform list self-test.

Variables

static struct list_test list_tests []
 List test elements.
struct self_test list_test __self_test
 List self-test.

Detailed Description

List function tests.

Definition in file list_test.c.

Macro Definition Documentation

◆ list_contents_ok

#define list_contents_ok ( list,
expected )
Value:
do { \
ok ( list_check_contents ( (list), (expected) ) ); \
} while ( 0 )
list_check_contents
static int list_check_contents(struct list_head *list, const char *expected)
Check list contents are as expected.
Definition list_test.c:73

Report list test result.

Parameters
listTest list
expectedExpected contents

Definition at line 122 of file list_test.c.

122#define list_contents_ok( list, expected ) do { \
123 ok ( list_check_contents ( (list), (expected) ) ); \
124 } while ( 0 )

Referenced by list_test_exec().

◆ list_iterate_ok

#define list_iterate_ok ( macro,
expected,
pos,
... )
Value:
do { \
const char *check = expected; \
macro ( pos, __VA_ARGS__ ) { \
struct list_test *entry = \
list_entry ( pos, struct list_test, \
list ); \
ok ( entry->label == *(check++) ); \
} \
ok ( *check == '\0' ); \
} while ( 0 )
list_test
A list test structure.
Definition list_test.c:42
list_test::label
char label
Label.
Definition list_test.c:46

Report list iteration test result.

Parameters
macroIterator macro
expectedExpected contents
posIterator
...Arguments to iterator macro

Definition at line 134 of file list_test.c.

134#define list_iterate_ok( macro, expected, pos, ... ) do { \
135 const char *check = expected; \
136 macro ( pos, __VA_ARGS__ ) { \
137 struct list_test *entry = \
138 list_entry ( pos, struct list_test, \
139 list ); \
140 ok ( entry->label == *(check++) ); \
141 } \
142 ok ( *check == '\0' ); \
143 } while ( 0 )

Referenced by list_test_exec().

◆ list_iterate_entry_ok

#define list_iterate_entry_ok ( macro,
expected,
pos,
... )
Value:
do { \
const char *check = expected; \
macro ( pos, __VA_ARGS__ ) { \
ok ( (pos)->label == *(check++) ); \
} \
ok ( *check == '\0' ); \
} while ( 0 )
label
A text label widget.
Definition label.h:16

Report list entry iteration test result.

Parameters
macroIterator macro
expectedExpected contents
posIterator
...Arguments to iterator macro

Definition at line 153 of file list_test.c.

153#define list_iterate_entry_ok( macro, expected, pos, ... ) do { \
154 const char *check = expected; \
155 macro ( pos, __VA_ARGS__ ) { \
156 ok ( (pos)->label == *(check++) ); \
157 } \
158 ok ( *check == '\0' ); \
159 } while ( 0 )

Referenced by list_test_exec().

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ LIST_HEAD()

LIST_HEAD ( test_list )
static

Test list.

◆ list_check_contents()

int list_check_contents ( struct list_head * list,
const char * expected )
static

Check list contents are as expected.

Parameters
listTest list
expectedExpected contents
okList contents are as expected

Definition at line 73 of file list_test.c.

74 {
75 struct list_test *entry;
76 size_t num_entries = 0;
77
78 /* Determine size of list */
79 list_for_each_entry ( entry, list, list )
80 num_entries++;
81
82 {
83 char found[ num_entries + 1 ];
84 char found_rev[ num_entries + 1 ];
85 char *tmp;
86
87 /* Build up list content string */
88 tmp = found;
89 list_for_each_entry ( entry, list, list )
90 *(tmp++) = entry->label;
91 *tmp = '\0';
92
93 /* Sanity check reversed list */
94 tmp = &found_rev[ sizeof ( found_rev ) - 1 ];
95 *tmp = '\0';
96 list_for_each_entry_reverse ( entry, list, list )
97 *(--tmp) = entry->label;
98 if ( strcmp ( found, found_rev ) != 0 ) {
99 printf ( "FAILURE: list reversal mismatch (forward "
100 "\"%s\", reverse \"%s\")\n",
101 found, found_rev );
102 return 0;
103 }
104
105 /* Compare against expected content */
106 if ( strcmp ( found, expected ) == 0 ) {
107 return 1;
108 } else {
109 printf ( "FAILURE: expected \"%s\", got \"%s\"\n",
110 expected, found );
111 return 0;
112 }
113 }
114}
num_entries
__be32 num_entries
Definition CIB_PRM.h:3
tmp
unsigned long tmp
Definition linux_pci.h:65
list_for_each_entry
#define list_for_each_entry(pos, head, member)
Iterate over entries in a list.
Definition list.h:432
list_for_each_entry_reverse
#define list_for_each_entry_reverse(pos, head, member)
Iterate over entries in a list in reverse order.
Definition list.h:445
strcmp
int strcmp(const char *first, const char *second)
Compare strings.
Definition string.c:174
list_test::list
struct list_head list
List element.
Definition list_test.c:44
printf
int printf(const char *fmt,...)
Write a formatted string to the console.
Definition vsprintf.c:465

References list_test::label, list_test::list, list_for_each_entry, list_for_each_entry_reverse, num_entries, printf(), strcmp(), and tmp.

◆ list_test_exec()

void list_test_exec ( void )
static

Perform list self-test.

Definition at line 165 of file list_test.c.

165 {
166 struct list_head *list = &test_list;
167 struct list_head target_list;
168 struct list_head *target = &target_list;
169 struct list_head *raw_pos;
170 struct list_test *pos;
171 struct list_test *tmp;
172
173 /* Test initialiser and list_empty() */
174 ok ( list_empty ( list ) );
175 list_contents_ok ( list, "" );
176
177 /* Test list_add(), list_add_tail() and list_del() */
178 INIT_LIST_HEAD ( list );
179 list_contents_ok ( list, "" );
180 list_add ( &list_tests[4].list, list ); /* prepend */
181 list_contents_ok ( list, "4" );
182 list_add ( &list_tests[2].list, list ); /* prepend */
183 list_contents_ok ( list, "24" );
184 list_add_tail ( &list_tests[7].list, list ); /* append */
185 list_contents_ok ( list, "247" );
186 list_add ( &list_tests[1].list, &list_tests[4].list ); /* after */
187 list_contents_ok ( list, "2417" );
188 list_add_tail ( &list_tests[8].list, &list_tests[7].list ); /* before */
189 list_contents_ok ( list, "24187" );
190 list_del ( &list_tests[4].list ); /* delete middle */
191 list_contents_ok ( list, "2187" );
192 list_del ( &list_tests[2].list ); /* delete first */
193 list_contents_ok ( list, "187" );
194 list_del ( &list_tests[7].list ); /* delete last */
195 list_contents_ok ( list, "18" );
196 list_del ( &list_tests[1].list ); /* delete all */
197 list_del ( &list_tests[8].list ); /* delete all */
198 list_contents_ok ( list, "" );
199 ok ( list_empty ( list ) );
200
201 /* Test list_is_singular() */
202 INIT_LIST_HEAD ( list );
203 ok ( ! list_is_singular ( list ) );
204 list_add ( &list_tests[1].list, list );
205 ok ( list_is_singular ( list ) );
206 list_add ( &list_tests[3].list, list );
207 ok ( ! list_is_singular ( list ) );
208 list_del ( &list_tests[1].list );
209 ok ( list_is_singular ( list ) );
210
211 /* Test list_is_last() */
212 INIT_LIST_HEAD ( list );
213 list_add_tail ( &list_tests[6].list, list );
214 ok ( list_is_last ( &list_tests[6].list, list ) );
215 list_add_tail ( &list_tests[4].list, list );
216 ok ( list_is_last ( &list_tests[4].list, list ) );
217 ok ( ! list_is_last ( &list_tests[6].list, list ) );
218
219 /* Test list_cut_position() - empty list */
220 INIT_LIST_HEAD ( list );
221 INIT_LIST_HEAD ( target );
222 list_cut_position ( target, list, list );
223 list_contents_ok ( list, "" );
224 list_contents_ok ( target, "" );
225
226 /* Test list_cut_position() - singular list, move nothing */
227 INIT_LIST_HEAD ( list );
228 INIT_LIST_HEAD ( target );
229 list_add_tail ( &list_tests[4].list, list );
230 list_cut_position ( target, list, list );
231 list_contents_ok ( list, "4" );
232 list_contents_ok ( target, "" );
233
234 /* Test list_cut_position() - singular list, move singular entry */
235 INIT_LIST_HEAD ( list );
236 INIT_LIST_HEAD ( target );
237 list_add_tail ( &list_tests[9].list, list );
238 list_cut_position ( target, list, &list_tests[9].list );
239 list_contents_ok ( list, "" );
240 list_contents_ok ( target, "9" );
241
242 /* Test list_cut_position() - multi-entry list, move nothing */
243 INIT_LIST_HEAD ( list );
244 list_add_tail ( &list_tests[3].list, list );
245 list_add_tail ( &list_tests[2].list, list );
246 list_add_tail ( &list_tests[7].list, list );
247 INIT_LIST_HEAD ( target );
248 list_cut_position ( target, list, list );
249 list_contents_ok ( list, "327" );
250 list_contents_ok ( target, "" );
251
252 /* Test list_cut_position() - multi-entry list, move some */
253 INIT_LIST_HEAD ( list );
254 INIT_LIST_HEAD ( target );
255 list_add_tail ( &list_tests[8].list, list );
256 list_add_tail ( &list_tests[0].list, list );
257 list_add_tail ( &list_tests[9].list, list );
258 list_add_tail ( &list_tests[3].list, list );
259 list_add_tail ( &list_tests[2].list, list );
260 list_cut_position ( target, list, &list_tests[0].list );
261 list_contents_ok ( list, "932" );
262 list_contents_ok ( target, "80" );
263
264 /* Test list_cut_position() - multi-entry list, move everything */
265 INIT_LIST_HEAD ( list );
266 INIT_LIST_HEAD ( target );
267 list_add_tail ( &list_tests[3].list, list );
268 list_add_tail ( &list_tests[5].list, list );
269 list_add_tail ( &list_tests[4].list, list );
270 list_add_tail ( &list_tests[7].list, list );
271 list_add_tail ( &list_tests[1].list, list );
272 list_cut_position ( target, list, &list_tests[1].list );
273 list_contents_ok ( list, "" );
274 list_contents_ok ( target, "35471" );
275
276 /* Test list_splice() - empty list */
277 INIT_LIST_HEAD ( list );
278 INIT_LIST_HEAD ( target );
279 list_splice ( list, target );
280 list_contents_ok ( list, "" );
281 list_contents_ok ( target, "" );
282
283 /* Test list_splice() - both lists empty */
284 INIT_LIST_HEAD ( list );
285 INIT_LIST_HEAD ( target );
286 list_splice ( list, target );
287 list_contents_ok ( target, "" );
288
289 /* Test list_splice() - source list empty */
290 INIT_LIST_HEAD ( list );
291 INIT_LIST_HEAD ( target );
292 list_add_tail ( &list_tests[1].list, target );
293 list_add_tail ( &list_tests[3].list, target );
294 list_splice ( list, &list_tests[1].list );
295 list_contents_ok ( target, "13" );
296
297 /* Test list_splice() - destination list empty */
298 INIT_LIST_HEAD ( list );
299 INIT_LIST_HEAD ( target );
300 list_add_tail ( &list_tests[6].list, list );
301 list_add_tail ( &list_tests[5].list, list );
302 list_add_tail ( &list_tests[2].list, list );
303 list_splice ( list, target );
304 list_contents_ok ( target, "652" );
305
306 /* Test list_splice() - both lists non-empty */
307 INIT_LIST_HEAD ( list );
308 INIT_LIST_HEAD ( target );
309 list_add_tail ( &list_tests[8].list, list );
310 list_add_tail ( &list_tests[4].list, list );
311 list_add_tail ( &list_tests[5].list, list );
312 list_add_tail ( &list_tests[1].list, target );
313 list_add_tail ( &list_tests[9].list, target );
314 list_splice ( list, &list_tests[1].list );
315 list_contents_ok ( target, "18459" );
316
317 /* Test list_splice_tail() - both lists empty */
318 INIT_LIST_HEAD ( list );
319 INIT_LIST_HEAD ( target );
320 list_splice_tail ( list, target );
321 list_contents_ok ( target, "" );
322
323 /* Test list_splice_tail() - source list empty */
324 INIT_LIST_HEAD ( list );
325 INIT_LIST_HEAD ( target );
326 list_add_tail ( &list_tests[5].list, target );
327 list_splice_tail ( list, &list_tests[5].list );
328 list_contents_ok ( target, "5" );
329
330 /* Test list_splice_tail() - destination list empty */
331 INIT_LIST_HEAD ( list );
332 INIT_LIST_HEAD ( target );
333 list_add_tail ( &list_tests[2].list, list );
334 list_add_tail ( &list_tests[1].list, list );
335 list_add_tail ( &list_tests[0].list, list );
336 list_splice_tail ( list, target );
337 list_contents_ok ( target, "210" );
338
339 /* Test list_splice_tail() - both lists non-empty */
340 INIT_LIST_HEAD ( list );
341 INIT_LIST_HEAD ( target );
342 list_add_tail ( &list_tests[9].list, list );
343 list_add_tail ( &list_tests[5].list, list );
344 list_add_tail ( &list_tests[7].list, list );
345 list_add_tail ( &list_tests[2].list, target );
346 list_add_tail ( &list_tests[4].list, target );
347 list_splice_tail ( list, &list_tests[2].list );
348 list_contents_ok ( target, "95724" );
349
350 /* Test list_splice_init() */
351 INIT_LIST_HEAD ( list );
352 INIT_LIST_HEAD ( target );
353 list_add_tail ( &list_tests[4].list, list );
354 list_add_tail ( &list_tests[1].list, target );
355 list_splice_init ( list, target );
356 ok ( list_empty ( list ) );
357 list_contents_ok ( list, "" );
358 list_contents_ok ( target, "41" );
359
360 /* Test list_splice_tail_init() */
361 INIT_LIST_HEAD ( list );
362 INIT_LIST_HEAD ( target );
363 list_add_tail ( &list_tests[3].list, list );
364 list_add_tail ( &list_tests[2].list, list );
365 list_add_tail ( &list_tests[5].list, target );
366 list_splice_tail_init ( list, &list_tests[5].list );
367 ok ( list_empty ( list ) );
368 list_contents_ok ( list, "" );
369 list_contents_ok ( target, "325" );
370
371 /* Test list_entry() */
372 INIT_LIST_HEAD ( &list_tests[3].list ); // for list_check()
373 ok ( list_entry ( &list_tests[3].list, struct list_test, list )
374 == &list_tests[3] );
375
376 /* Test list_first_entry() and list_last_entry() */
377 INIT_LIST_HEAD ( list );
378 list_add_tail ( &list_tests[9].list, list );
379 list_add_tail ( &list_tests[5].list, list );
380 list_add_tail ( &list_tests[6].list, list );
381 ok ( list_first_entry ( list, struct list_test, list )
382 == &list_tests[9] );
383 ok ( list_last_entry ( list, struct list_test, list )
384 == &list_tests[6] );
385 list_del ( &list_tests[9].list );
386 ok ( list_first_entry ( list, struct list_test, list )
387 == &list_tests[5] );
388 ok ( list_last_entry ( list, struct list_test, list )
389 == &list_tests[6] );
390 list_del ( &list_tests[6].list );
391 ok ( list_first_entry ( list, struct list_test, list )
392 == &list_tests[5] );
393 ok ( list_last_entry ( list, struct list_test, list )
394 == &list_tests[5] );
395 list_del ( &list_tests[5].list );
396 ok ( list_first_entry ( list, struct list_test, list ) == NULL );
397 ok ( list_last_entry ( list, struct list_test, list ) == NULL );
398
399 /* Test list_next_entry() and list_prev_entry() */
400 INIT_LIST_HEAD ( list );
401 list_add_tail ( &list_tests[5].list, list );
402 list_add_tail ( &list_tests[3].list, list );
403 list_add_tail ( &list_tests[1].list, list );
404 list_add_tail ( &list_tests[7].list, list );
405 ok ( list_prev_entry ( &list_tests[5], list, list ) == NULL );
406 ok ( list_next_entry ( &list_tests[5], list, list ) == &list_tests[3] );
407 ok ( list_prev_entry ( &list_tests[3], list, list ) == &list_tests[5] );
408 ok ( list_next_entry ( &list_tests[3], list, list ) == &list_tests[1] );
409 ok ( list_prev_entry ( &list_tests[1], list, list ) == &list_tests[3] );
410 ok ( list_next_entry ( &list_tests[1], list, list ) == &list_tests[7] );
411 ok ( list_prev_entry ( &list_tests[7], list, list ) == &list_tests[1] );
412 ok ( list_next_entry ( &list_tests[7], list, list ) == NULL );
413 list_del ( &list_tests[7].list );
414 ok ( list_prev_entry ( &list_tests[1], list, list ) == &list_tests[3] );
415 ok ( list_next_entry ( &list_tests[1], list, list ) == NULL );
416 list_del ( &list_tests[3].list );
417 ok ( list_prev_entry ( &list_tests[5], list, list ) == NULL );
418 ok ( list_next_entry ( &list_tests[5], list, list ) == &list_tests[1] );
419 ok ( list_prev_entry ( &list_tests[1], list, list ) == &list_tests[5] );
420 ok ( list_next_entry ( &list_tests[1], list, list ) == NULL );
421
422 /* Test list_is_first_entry() and list_is_last_entry() */
423 INIT_LIST_HEAD ( list );
424 list_add_tail ( &list_tests[4].list, list );
425 list_add_tail ( &list_tests[8].list, list );
426 list_add_tail ( &list_tests[3].list, list );
427 list_add_tail ( &list_tests[6].list, list );
428 ok ( list_is_first_entry ( &list_tests[4], list, list ) );
429 ok ( ! list_is_first_entry ( &list_tests[8], list, list ) );
430 ok ( ! list_is_first_entry ( &list_tests[3], list, list ) );
431 ok ( ! list_is_first_entry ( &list_tests[6], list, list ) );
432 ok ( ! list_is_last_entry ( &list_tests[4], list, list ) );
433 ok ( ! list_is_last_entry ( &list_tests[8], list, list ) );
434 ok ( ! list_is_last_entry ( &list_tests[3], list, list ) );
435 ok ( list_is_last_entry ( &list_tests[6], list, list ) );
436 list_del ( &list_tests[4].list );
437 ok ( list_is_first_entry ( &list_tests[8], list, list ) );
438 list_del ( &list_tests[8].list );
439 list_del ( &list_tests[6].list );
440 ok ( list_is_first_entry ( &list_tests[3], list, list ) );
441 ok ( list_is_last_entry ( &list_tests[3], list, list ) );
442
443 /* Test list_is_head_entry() */
444 INIT_LIST_HEAD ( list );
445 list_add_tail ( &list_tests[1].list, list );
446 list_add_tail ( &list_tests[6].list, list );
447 list_add_tail ( &list_tests[8].list, list );
448 ok ( list_is_head_entry ( list_entry ( list, typeof ( *pos ), list ),
449 list, list ) );
450 ok ( ! list_is_head_entry ( &list_tests[1], list, list ) );
451 ok ( ! list_is_head_entry ( &list_tests[6], list, list ) );
452 ok ( ! list_is_head_entry ( &list_tests[8], list, list ) );
453 list_for_each_entry ( pos, list, list ) {
454 ok ( list_contains_entry ( pos, list, list ) );
455 ok ( ! list_is_head_entry ( pos, list, list ) );
456 }
457 ok ( list_is_head_entry ( pos, list, list ) );
458
459 /* Test list_for_each() */
460 INIT_LIST_HEAD ( list );
461 list_add_tail ( &list_tests[6].list, list );
462 list_add_tail ( &list_tests[7].list, list );
463 list_add_tail ( &list_tests[3].list, list );
464 list_iterate_ok ( list_for_each, "673", raw_pos, list );
465
466 /* Test list_for_each_entry() and list_for_each_entry_reverse() */
467 INIT_LIST_HEAD ( list );
468 list_add_tail ( &list_tests[3].list, list );
469 list_add_tail ( &list_tests[2].list, list );
470 list_add_tail ( &list_tests[6].list, list );
471 list_add_tail ( &list_tests[9].list, list );
472 list_iterate_entry_ok ( list_for_each_entry, "3269",
473 pos, list, list );
474 list_iterate_entry_ok ( list_for_each_entry_reverse, "9623",
475 pos, list, list );
476
477 /* Test list_for_each_entry_safe() */
478 INIT_LIST_HEAD ( list );
479 list_add_tail ( &list_tests[2].list, list );
480 list_add_tail ( &list_tests[4].list, list );
481 list_add_tail ( &list_tests[1].list, list );
482 {
483 char *expected = "241";
484 list_for_each_entry_safe ( pos, tmp, list, list ) {
485 list_contents_ok ( list, expected );
486 list_del ( &pos->list );
487 expected++;
488 list_contents_ok ( list, expected );
489 }
490 }
491 ok ( list_empty ( list ) );
492
493 /* Test list_for_each_entry_continue() and
494 * list_for_each_entry_continue_reverse()
495 */
496 INIT_LIST_HEAD ( list );
497 list_add_tail ( &list_tests[4].list, list );
498 list_add_tail ( &list_tests[7].list, list );
499 list_add_tail ( &list_tests[2].list, list );
500 list_add_tail ( &list_tests[9].list, list );
501 list_add_tail ( &list_tests[3].list, list );
502 pos = &list_tests[7];
503 list_iterate_entry_ok ( list_for_each_entry_continue, "293",
504 pos, list, list );
505 ok ( pos == list_entry ( list, struct list_test, list ) );
506 list_iterate_entry_ok ( list_for_each_entry_continue, "47293",
507 pos, list, list );
508 pos = &list_tests[3];
509 list_iterate_entry_ok ( list_for_each_entry_continue, "",
510 pos, list, list );
511 pos = &list_tests[2];
512 list_iterate_entry_ok ( list_for_each_entry_continue_reverse, "74",
513 pos, list, list );
514 ok ( pos == list_entry ( list, struct list_test, list ) );
515 list_iterate_entry_ok ( list_for_each_entry_continue_reverse, "39274",
516 pos, list, list );
517 pos = &list_tests[4];
518 list_iterate_entry_ok ( list_for_each_entry_continue_reverse, "",
519 pos, list, list );
520
521 /* Test list_for_each_entry_safe_continue() */
522 INIT_LIST_HEAD ( list );
523 list_add_tail ( &list_tests[9].list, list );
524 list_add_tail ( &list_tests[4].list, list );
525 list_add_tail ( &list_tests[2].list, list );
526 list_add_tail ( &list_tests[5].list, list );
527 list_add_tail ( &list_tests[7].list, list );
528 {
529 char *expecteds[] = { "94257", "9457", "947", "94" };
530 char **expected = expecteds;
531 pos = &list_tests[4];
532 list_for_each_entry_safe_continue ( pos, tmp, list, list ) {
533 list_contents_ok ( list, *expected );
534 list_del ( &pos->list );
535 expected++;
536 list_contents_ok ( list, *expected );
537 }
538 }
539 list_contents_ok ( list, "94" );
540 {
541 char *expecteds[] = { "94", "4", "" };
542 char **expected = expecteds;
543 ok ( pos == list_entry ( list, struct list_test, list ) );
544 list_for_each_entry_safe_continue ( pos, tmp, list, list ) {
545 list_contents_ok ( list, *expected );
546 list_del ( &pos->list );
547 expected++;
548 list_contents_ok ( list, *expected );
549 }
550 }
551 ok ( list_empty ( list ) );
552
553 /* Test list_contains() and list_contains_entry() */
554 INIT_LIST_HEAD ( list );
555 INIT_LIST_HEAD ( &list_tests[3].list );
556 list_add ( &list_tests[8].list, list );
557 list_add ( &list_tests[5].list, list );
558 ok ( list_contains ( &list_tests[8].list, list ) );
559 ok ( list_contains_entry ( &list_tests[8], list, list ) );
560 ok ( list_contains ( &list_tests[5].list, list ) );
561 ok ( list_contains_entry ( &list_tests[5], list, list ) );
562 ok ( ! list_contains ( &list_tests[3].list, list ) );
563 ok ( ! list_contains_entry ( &list_tests[3], list, list ) );
564
565 /* Test list_check_contains_entry() */
566 INIT_LIST_HEAD ( list );
567 list_add ( &list_tests[4].list, list );
568 list_add ( &list_tests[0].list, list );
569 list_add ( &list_tests[3].list, list );
570 list_check_contains_entry ( &list_tests[4], list, list );
571 list_check_contains_entry ( &list_tests[0], list, list );
572 list_check_contains_entry ( &list_tests[3], list, list );
573}
NULL
#define NULL
NULL pointer (VOID *)
Definition Base.h:322
typeof
typeof(acpi_finder=acpi_find)
ACPI table finder.
Definition acpi.c:48
list_is_last_entry
#define list_is_last_entry(entry, head, member)
Test if entry is last in a list.
Definition list.h:399
list_cut_position
#define list_cut_position(new, list, entry)
Cut a list into two.
Definition list.h:186
list_contains_entry
#define list_contains_entry(entry, head, member)
Test if list contains a specified entry.
Definition list.h:540
list_for_each_entry_continue_reverse
#define list_for_each_entry_continue_reverse(pos, head, member)
Iterate over entries in a list in reverse, starting after current position.
Definition list.h:487
list_first_entry
#define list_first_entry(list, type, member)
Get the container of the first entry in a list.
Definition list.h:334
list_for_each_entry_safe_continue
#define list_for_each_entry_safe_continue(pos, tmp, head, member)
Iterate over subsequent entries in a list, safe against deletion.
Definition list.h:501
list_last_entry
#define list_last_entry(list, type, member)
Get the container of the last entry in a list.
Definition list.h:347
list_contains
#define list_contains(entry, head)
Test if list contains a specified entry.
Definition list.h:516
list_entry
#define list_entry(list, type, member)
Get the container of a list entry.
Definition list.h:322
list_splice
#define list_splice(list, entry)
Move all entries from one list into another list.
Definition list.h:221
list_splice_tail
#define list_splice_tail(list, entry)
Move all entries from one list into another list.
Definition list.h:251
list_is_head_entry
#define list_is_head_entry(entry, head, member)
Test if entry is the list head.
Definition list.h:410
list_for_each_entry_safe
#define list_for_each_entry_safe(pos, tmp, head, member)
Iterate over entries in a list, safe against deletion of the current entry.
Definition list.h:459
list_prev_entry
#define list_prev_entry(pos, head, member)
Get the container of the previous entry in a list.
Definition list.h:374
list_next_entry
#define list_next_entry(pos, head, member)
Get the container of the next entry in a list.
Definition list.h:360
list_add_tail
#define list_add_tail(new, head)
Add a new entry to the tail of a list.
Definition list.h:94
list_for_each_entry_continue
#define list_for_each_entry_continue(pos, head, member)
Iterate over entries in a list, starting after current position.
Definition list.h:474
list_splice_init
#define list_splice_init(list, entry)
Move all entries from one list into another list and reinitialise empty list.
Definition list.h:279
list_del
#define list_del(list)
Delete an entry from a list.
Definition list.h:120
INIT_LIST_HEAD
#define INIT_LIST_HEAD(list)
Initialise a list head.
Definition list.h:46
list_for_each
#define list_for_each(pos, head)
Iterate over a list.
Definition list.h:419
list_is_first_entry
#define list_is_first_entry(entry, head, member)
Test if entry is first in a list.
Definition list.h:388
list_empty
#define list_empty(list)
Test whether a list is empty.
Definition list.h:137
list_is_singular
#define list_is_singular(list)
Test whether a list has just one entry.
Definition list.h:150
list_check_contains_entry
#define list_check_contains_entry(entry, head, member)
Check list contains a specified entry.
Definition list.h:550
list_is_last
#define list_is_last(list, head)
Test whether an entry is the last entry in list.
Definition list.h:164
list_add
#define list_add(new, head)
Add a new entry to the head of a list.
Definition list.h:70
list_splice_tail_init
#define list_splice_tail_init(list, entry)
Move all entries from one list into another list and reinitialise empty list.
Definition list.h:300
list_tests
static struct list_test list_tests[]
List test elements.
Definition list_test.c:50
list_contents_ok
#define list_contents_ok(list, expected)
Report list test result.
Definition list_test.c:122
list_iterate_ok
#define list_iterate_ok(macro, expected, pos,...)
Report list iteration test result.
Definition list_test.c:134
list_iterate_entry_ok
#define list_iterate_entry_ok(macro, expected, pos,...)
Report list entry iteration test result.
Definition list_test.c:153
list_head
A doubly-linked list entry (or list head)
Definition list.h:19
ok
#define ok(success)
Definition test.h:46

References INIT_LIST_HEAD, list_test::list, list_add, list_add_tail, list_check_contains_entry, list_contains, list_contains_entry, list_contents_ok, list_cut_position, list_del, list_empty, list_entry, list_first_entry, list_for_each, list_for_each_entry, list_for_each_entry_continue, list_for_each_entry_continue_reverse, list_for_each_entry_reverse, list_for_each_entry_safe, list_for_each_entry_safe_continue, list_is_first_entry, list_is_head_entry, list_is_last, list_is_last_entry, list_is_singular, list_iterate_entry_ok, list_iterate_ok, list_last_entry, list_next_entry, list_prev_entry, list_splice, list_splice_init, list_splice_tail, list_splice_tail_init, list_tests, NULL, ok, tmp, and typeof().

Variable Documentation

◆ list_tests

struct list_test list_tests[]
static
Initial value:
= {
{ .label = '0' },
{ .label = '1' },
{ .label = '2' },
{ .label = '3' },
{ .label = '4' },
{ .label = '5' },
{ .label = '6' },
{ .label = '7' },
{ .label = '8' },
{ .label = '9' },
}

List test elements.

Definition at line 50 of file list_test.c.

50 {
51 { .label = '0' },
52 { .label = '1' },
53 { .label = '2' },
54 { .label = '3' },
55 { .label = '4' },
56 { .label = '5' },
57 { .label = '6' },
58 { .label = '7' },
59 { .label = '8' },
60 { .label = '9' },
61};

Referenced by list_test_exec().

◆ __self_test

struct self_test list_test __self_test
Initial value:
= {
.name = "list",
.exec = list_test_exec,
}
list_test_exec
static void list_test_exec(void)
Perform list self-test.
Definition list_test.c:165

List self-test.

Definition at line 576 of file list_test.c.

576 {
577 .name = "list",
578 .exec = list_test_exec,
579};
Generated by doxygen 1.14.0