Skip to content

Commit 626027a

Browse files
jhonny-rsvictorjulien
jhonny-rs
authored and
victorjulien
committed
util/pool: Convert unittests to new FAIL/PASS api
Ticket: #6322
1 parent 8ca589b commit 626027a

File tree

1 file changed

+59
-224
lines changed

1 file changed

+59
-224
lines changed

‎src/util-pool.c‎

Lines changed: 59 additions & 224 deletions
Original file line numberDiff line numberDiff line change
@@ -394,311 +394,146 @@ static void PoolTestFree(void *ptr)
394394
static int PoolTestInit01 (void)
395395
{
396396
Pool *p = PoolInit(10,5,10,PoolTestAlloc,NULL,NULL,PoolTestFree, NULL);
397-
if (p == NULL)
398-
return 0;
397+
FAIL_IF_NOT(p != NULL);
399398

400399
PoolFree(p);
401-
return 1;
400+
PASS;
402401
}
403402

404403
static int PoolTestInit02 (void)
405404
{
406-
int retval = 0;
407-
408405
Pool *p = PoolInit(10,5,10,PoolTestAlloc,NULL,NULL,PoolTestFree, NULL);
409-
if (p == NULL)
410-
goto end;
406+
FAIL_IF_NOT(p != NULL);
411407

412-
if (p->alloc_stack == NULL || p->empty_stack == NULL) {
413-
printf("list(s) not properly initialized (a:%p e:%p): ",
414-
p->alloc_stack, p->empty_stack);
415-
retval = 0;
416-
goto end;
417-
}
408+
FAIL_IF_NOT(p->alloc_stack != NULL);
418409

419-
if (p->Alloc != PoolTestAlloc) {
420-
printf("Alloc func ptr %p != %p: ",
421-
p->Alloc, PoolTestAlloc);
422-
retval = 0;
423-
goto end;
424-
}
410+
FAIL_IF_NOT(p->empty_stack != NULL);
425411

426-
if (p->Cleanup != PoolTestFree) {
427-
printf("Free func ptr %p != %p: ",
428-
p->Cleanup, PoolTestFree);
429-
retval = 0;
430-
goto end;
431-
}
412+
FAIL_IF_NOT(p->Alloc == PoolTestAlloc);
432413

433-
retval = 1;
434-
end:
435-
if (p != NULL)
436-
PoolFree(p);
437-
return retval;
414+
FAIL_IF_NOT(p->Cleanup == PoolTestFree);
415+
416+
PoolFree(p);
417+
PASS;
438418
}
439419

440420
static int PoolTestInit03 (void)
441421
{
442-
int retval = 0;
443-
void *data = NULL;
444-
445422
Pool *p = PoolInit(10,5,10,PoolTestAlloc,NULL,NULL,PoolTestFree, NULL);
446-
if (p == NULL)
447-
goto end;
423+
FAIL_IF_NOT(p != NULL);
448424

449-
data = PoolGet(p);
450-
if (data == NULL) {
451-
printf("PoolGet returned NULL: ");
452-
retval = 0;
453-
goto end;
454-
}
425+
void *data = PoolGet(p);
426+
FAIL_IF_NOT(data != NULL);
455427

456-
if (p->alloc_stack_size != 4) {
457-
printf("p->alloc_stack_size 4 != %" PRIu32 ": ", p->alloc_stack_size);
458-
retval = 0;
459-
goto end;
460-
}
428+
FAIL_IF_NOT(p->alloc_stack_size == 4);
461429

462-
if (p->empty_stack_size != 6) {
463-
printf("p->empty_stack_size 6 != %" PRIu32 ": ", p->empty_stack_size);
464-
retval = 0;
465-
goto end;
466-
}
430+
FAIL_IF_NOT(p->empty_stack_size == 6);
467431

468-
retval = 1;
469-
end:
470-
if (p != NULL)
471-
PoolFree(p);
472-
return retval;
432+
PoolFree(p);
433+
PASS;
473434
}
474435

475436
static int PoolTestInit04 (void)
476437
{
477-
int retval = 0;
478-
char *str = NULL;
479-
480438
Pool *p = PoolInit(10,5,strlen("test") + 1,NULL, PoolTestInitArg,(void *)"test",PoolTestFree, NULL);
481-
if (p == NULL)
482-
goto end;
439+
FAIL_IF_NOT(p != NULL);
483440

484-
str = PoolGet(p);
485-
if (str == NULL) {
486-
printf("PoolGet returned NULL: ");
487-
retval = 0;
488-
goto end;
489-
}
441+
char *str = PoolGet(p);
442+
FAIL_IF_NOT(str != NULL);
490443

491-
if (strcmp(str, "test") != 0) {
492-
printf("Memory not properly initialized: ");
493-
retval = 0;
494-
goto end;
495-
}
444+
FAIL_IF_NOT(strcmp(str, "test") == 0);
496445

497-
if (p->alloc_stack_size != 4) {
498-
printf("p->alloc_stack_size 4 != %" PRIu32 ": ", p->alloc_stack_size);
499-
retval = 0;
500-
goto end;
501-
}
446+
FAIL_IF_NOT(p->alloc_stack_size == 4);
502447

503-
if (p->empty_stack_size != 6) {
504-
printf("p->empty_stack_size 6 != %" PRIu32 ": ", p->empty_stack_size);
505-
retval = 0;
506-
goto end;
507-
}
448+
FAIL_IF_NOT(p->empty_stack_size == 6);
508449

509-
retval = 1;
510-
end:
511-
if (p != NULL)
512-
PoolFree(p);
513-
return retval;
450+
PoolFree(p);
451+
PASS;
514452
}
515453

516454
static int PoolTestInit05 (void)
517455
{
518-
int retval = 0;
519-
void *data = NULL;
520-
521456
Pool *p = PoolInit(10,5,10,PoolTestAlloc,NULL, NULL,PoolTestFree, NULL);
522-
if (p == NULL)
523-
goto end;
457+
FAIL_IF_NOT(p != NULL);
524458

525-
data = PoolGet(p);
526-
if (data == NULL) {
527-
printf("PoolGet returned NULL: ");
528-
retval = 0;
529-
goto end;
530-
}
459+
void *data = PoolGet(p);
460+
FAIL_IF_NOT(data != NULL);
531461

532-
if (p->alloc_stack_size != 4) {
533-
printf("p->alloc_stack_size 4 != %" PRIu32 ": ", p->alloc_stack_size);
534-
retval = 0;
535-
goto end;
536-
}
462+
FAIL_IF_NOT(p->alloc_stack_size == 4);
537463

538-
if (p->empty_stack_size != 6) {
539-
printf("p->empty_stack_size 6 != %" PRIu32 ": ", p->empty_stack_size);
540-
retval = 0;
541-
goto end;
542-
}
464+
FAIL_IF_NOT(p->empty_stack_size == 6);
543465

544466
PoolReturn(p, data);
545467
data = NULL;
546468

547-
if (p->alloc_stack_size != 5) {
548-
printf("p->alloc_stack_size 5 != %" PRIu32 ": ", p->alloc_stack_size);
549-
retval = 0;
550-
goto end;
551-
}
469+
FAIL_IF_NOT(p->alloc_stack_size == 5);
552470

553-
if (p->empty_stack_size != 5) {
554-
printf("p->empty_stack_size 5 != %" PRIu32 ": ", p->empty_stack_size);
555-
retval = 0;
556-
goto end;
557-
}
471+
FAIL_IF_NOT(p->empty_stack_size == 5);
558472

559-
retval = 1;
560-
end:
561-
if (p != NULL)
562-
PoolFree(p);
563-
return retval;
473+
PoolFree(p);
474+
PASS;
564475
}
565476

566477
static int PoolTestInit06 (void)
567478
{
568-
int retval = 0;
569-
void *data = NULL;
570-
void *data2 = NULL;
571-
572479
Pool *p = PoolInit(1,0,10,PoolTestAlloc,NULL,NULL,PoolTestFree, NULL);
573-
if (p == NULL)
574-
goto end;
480+
FAIL_IF_NOT(p != NULL);
575481

576-
if (p->allocated != 0) {
577-
printf("p->allocated 0 != %" PRIu32 ": ", p->allocated);
578-
retval = 0;
579-
goto end;
580-
}
482+
FAIL_IF_NOT(p->allocated == 0);
581483

582-
data = PoolGet(p);
583-
if (data == NULL) {
584-
printf("PoolGet returned NULL: ");
585-
retval = 0;
586-
goto end;
587-
}
484+
void *data = PoolGet(p);
485+
FAIL_IF_NOT(data != NULL);
588486

589-
if (p->allocated != 1) {
590-
printf("p->allocated 1 != %" PRIu32 ": ", p->allocated);
591-
retval = 0;
592-
goto end;
593-
}
487+
FAIL_IF_NOT(p->allocated == 1);
594488

595-
data2 = PoolGet(p);
596-
if (data2 != NULL) {
597-
printf("PoolGet returned %p, expected NULL: ", data2);
598-
retval = 0;
599-
goto end;
600-
}
489+
void *data2 = PoolGet(p);
490+
FAIL_IF_NOT(data2 == NULL);
601491

602492
PoolReturn(p,data);
603493
data = NULL;
604494

605-
if (p->allocated != 1) {
606-
printf("p->allocated 1 != %" PRIu32 ": ", p->allocated);
607-
retval = 0;
608-
goto end;
609-
}
495+
FAIL_IF_NOT(p->allocated == 1);
610496

611-
if (p->alloc_stack_size != 1) {
612-
printf("p->alloc_stack_size 1 != %" PRIu32 ": ", p->alloc_stack_size);
613-
retval = 0;
614-
goto end;
615-
}
497+
FAIL_IF_NOT(p->alloc_stack_size == 1);
616498

617-
retval = 1;
618-
end:
619-
if (p != NULL)
620-
PoolFree(p);
621-
return retval;
499+
PoolFree(p);
500+
PASS;
622501
}
623502

624503
/** \test pool with unlimited size */
625504
static int PoolTestInit07 (void)
626505
{
627-
int retval = 0;
628-
void *data = NULL;
629-
void *data2 = NULL;
630-
631506
Pool *p = PoolInit(0,1,10,PoolTestAlloc,NULL,NULL,PoolTestFree, NULL);
632-
if (p == NULL)
633-
goto end;
507+
FAIL_IF_NOT(p != NULL);
634508

635-
if (p->max_buckets != 0) {
636-
printf("p->max_buckets 0 != %" PRIu32 ": ", p->max_buckets);
637-
retval = 0;
638-
goto end;
639-
}
509+
FAIL_IF_NOT(p->max_buckets == 0);
640510

641-
if (p->allocated != 1) {
642-
printf("p->allocated 1 != %" PRIu32 ": ", p->allocated);
643-
retval = 0;
644-
goto end;
645-
}
511+
FAIL_IF_NOT(p->allocated == 1);
646512

647-
data = PoolGet(p);
648-
if (data == NULL) {
649-
printf("PoolGet returned NULL: ");
650-
retval = 0;
651-
goto end;
652-
}
513+
void *data = PoolGet(p);
514+
FAIL_IF_NOT(data != NULL);
653515

654-
if (p->allocated != 1) {
655-
printf("(2) p->allocated 1 != %" PRIu32 ": ", p->allocated);
656-
retval = 0;
657-
goto end;
658-
}
516+
FAIL_IF_NOT(p->allocated == 1);
659517

660-
data2 = PoolGet(p);
661-
if (data2 == NULL) {
662-
printf("PoolGet returned NULL: ");
663-
retval = 0;
664-
goto end;
665-
}
518+
void *data2 = PoolGet(p);
519+
FAIL_IF_NOT(data2 != NULL);
666520

667-
if (p->allocated != 2) {
668-
printf("(3) p->allocated 2 != %" PRIu32 ": ", p->allocated);
669-
retval = 0;
670-
goto end;
671-
}
521+
FAIL_IF_NOT(p->allocated == 2);
672522

673523
PoolReturn(p,data);
674524
data = NULL;
675525

676-
if (p->allocated != 2) {
677-
printf("(4) p->allocated 2 != %" PRIu32 ": ", p->allocated);
678-
retval = 0;
679-
goto end;
680-
}
526+
FAIL_IF_NOT(p->allocated == 2);
681527

682-
if (p->alloc_stack_size != 1) {
683-
printf("p->alloc_stack_size 1 != %" PRIu32 ": ", p->alloc_stack_size);
684-
retval = 0;
685-
goto end;
686-
}
528+
FAIL_IF_NOT(p->alloc_stack_size == 1);
687529

688530
PoolReturn(p,data2);
689531
data2 = NULL;
690532

691-
if (p->allocated != 1) {
692-
printf("(5) p->allocated 1 != %" PRIu32 ": ", p->allocated);
693-
retval = 0;
694-
goto end;
695-
}
533+
FAIL_IF_NOT(p->allocated == 1);
696534

697-
retval = 1;
698-
end:
699-
if (p != NULL)
700-
PoolFree(p);
701-
return retval;
535+
PoolFree(p);
536+
PASS;
702537
}
703538
#endif /* UNITTESTS */
704539

0 commit comments

Comments
 (0)