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. More...
 
#define list_iterate_ok(macro, expected, pos, ...)
 Report list iteration test result. More...
 
#define list_iterate_entry_ok(macro, expected, pos, ...)
 Report list entry iteration test result. More...
 

Functions

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

Variables

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

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.

◆ 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

Report list iteration test result.

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

Definition at line 134 of file list_test.c.

◆ 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.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL  )

◆ LIST_HEAD()

static LIST_HEAD ( test_list  )
static

Test list.

◆ list_check_contents()

static 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 }
printf
int printf(const char *fmt,...)
Write a formatted string to the console.
Definition: vsprintf.c:464
list_test
A list test structure.
Definition: list_test.c:42
list_test::label
char label
Label.
Definition: list_test.c:46
tmp
unsigned long tmp
Definition: linux_pci.h:64
list_for_each_entry
#define list_for_each_entry(pos, head, member)
Iterate over entries in a list.
Definition: list.h:431
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:444
list_test::list
struct list_head list
List element.
Definition: list_test.c:44
strcmp
int strcmp(const char *first, const char *second)
Compare strings.
Definition: string.c:173
num_entries
__be32 num_entries
Definition: CIB_PRM.h:31
if
if(natsemi->flags &NATSEMI_64BIT) return 1

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

◆ list_test_exec()

static 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 }
list_tests
static struct list_test list_tests[]
List test elements.
Definition: list_test.c:50
list_add
#define list_add(new, head)
Add a new entry to the head of a list.
Definition: list.h:69
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:473
list_iterate_entry_ok
#define list_iterate_entry_ok(macro, expected, pos,...)
Report list entry iteration test result.
Definition: list_test.c:153
list_test
A list test structure.
Definition: list_test.c:42
list_contents_ok
#define list_contents_ok(list, expected)
Report list test result.
Definition: list_test.c:122
list_next_entry
#define list_next_entry(pos, head, member)
Get the container of the next entry in a list.
Definition: list.h:359
list_for_each
#define list_for_each(pos, head)
Iterate over a list.
Definition: list.h:418
list_last_entry
#define list_last_entry(list, type, member)
Get the container of the last entry in a list.
Definition: list.h:346
list_head
A doubly-linked list entry (or list head)
Definition: list.h:18
list_empty
#define list_empty(list)
Test whether a list is empty.
Definition: list.h:136
tmp
unsigned long tmp
Definition: linux_pci.h:64
list_first_entry
#define list_first_entry(list, type, member)
Get the container of the first entry in a list.
Definition: list.h:333
list_del
#define list_del(list)
Delete an entry from a list.
Definition: list.h:119
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:500
list_for_each_entry
#define list_for_each_entry(pos, head, member)
Iterate over entries in a list.
Definition: list.h:431
list_add_tail
#define list_add_tail(new, head)
Add a new entry to the tail of a list.
Definition: list.h:93
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:444
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:278
list_contains_entry
#define list_contains_entry(entry, head, member)
Test if list contains a specified entry.
Definition: list.h:539
list_iterate_ok
#define list_iterate_ok(macro, expected, pos,...)
Report list iteration test result.
Definition: list_test.c:134
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:458
list_is_last_entry
#define list_is_last_entry(entry, head, member)
Test if entry is last in a list.
Definition: list.h:398
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:299
list_prev_entry
#define list_prev_entry(pos, head, member)
Get the container of the previous entry in a list.
Definition: list.h:373
list_splice_tail
#define list_splice_tail(list, entry)
Move all entries from one list into another list.
Definition: list.h:250
list_is_first_entry
#define list_is_first_entry(entry, head, member)
Test if entry is first in a list.
Definition: list.h:387
list_cut_position
#define list_cut_position(new, list, entry)
Cut a list into two.
Definition: list.h:185
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:486
INIT_LIST_HEAD
#define INIT_LIST_HEAD(list)
Initialise a list head.
Definition: list.h:45
list_is_singular
#define list_is_singular(list)
Test whether a list has just one entry.
Definition: list.h:149
list_test::list
struct list_head list
List element.
Definition: list_test.c:44
list_splice
#define list_splice(list, entry)
Move all entries from one list into another list.
Definition: list.h:220
list_contains
#define list_contains(entry, head)
Test if list contains a specified entry.
Definition: list.h:515
typeof
typeof(acpi_finder=acpi_find)
ACPI table finder.
Definition: acpi.c:47
list_check_contains_entry
#define list_check_contains_entry(entry, head, member)
Check list contains a specified entry.
Definition: list.h:549
ok
#define ok(success)
Definition: test.h:46
list_entry
#define list_entry(list, type, member)
Get the container of a list entry.
Definition: list.h:321
list_is_last
#define list_is_last(list, head)
Test whether an entry is the last entry in list.
Definition: list.h:163
NULL
#define NULL
NULL pointer (VOID *)
Definition: Base.h:321
list_is_head_entry
#define list_is_head_entry(entry, head, member)
Test if entry is the list head.
Definition: list.h:409

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.

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.

Generated by   doxygen 1.8.15