aocc23

Advent of Code 2023
git clone git://www.tkruger.se/aocc23.git
Log | Files | Refs | README

test_stack_sd.c (2800B)

      1 #include "test_stack_sd.h"
      2 
      3 void test_stack_sd_init() {
      4   stack_sd s;
      5   stack_sd_init(&s);
      6 
      7   CU_ASSERT(s.nmemb == 0);
      8   CU_ASSERT(s.alloc == BASE_STACK_SD_SIZE);
      9   CU_ASSERT(s.data != NULL);
     10 
     11   stack_sd_clear(&s);
     12 
     13   stack_sd_init_size(&s, 4);
     14 
     15   CU_ASSERT(s.nmemb == 0);
     16   CU_ASSERT(s.alloc == 4);
     17   CU_ASSERT(s.data != NULL);
     18 
     19   stack_sd_clear(&s);
     20 }
     21 
     22 void test_stack_sd_push() {
     23   stack_sd s;
     24   stack_sd_init_size(&s, 4);
     25 
     26   sd topush[5];
     27   size_t i;
     28   for (i = 0; i < 5; i++) {
     29     sd_init_u64(&topush[i], i);
     30     stack_sd_push(&s, topush[i]);
     31 
     32     CU_ASSERT(s.nmemb == i + 1);
     33   }
     34   CU_ASSERT(s.nmemb == 5);
     35   CU_ASSERT(s.alloc == 8);
     36 
     37   CU_ASSERT(memcmp(s.data, topush, sizeof(*topush) * 5) == 0);
     38 
     39   for (i = 0; i < 5; i++)
     40     sd_clear(&topush[i]);
     41   stack_sd_clear(&s);
     42 }
     43 
     44 void test_stack_sd_get() {
     45   stack_sd s;
     46   stack_sd_init(&s);
     47 
     48   sd topush[20];
     49   size_t i;
     50   for (i = 0; i < 20; i++) {
     51     sd_init_u64(&topush[i], i);
     52     stack_sd_push(&s, topush[i]);
     53   }
     54 
     55   sd tmp;
     56   for (i = 0; i < 20; i++) {
     57     tmp = stack_sd_get(&s, i);
     58     CU_ASSERT(tmp.size == topush[i].size);
     59     CU_ASSERT(tmp.data == topush[i].data);
     60   }
     61 
     62   for (i = 0; i < 5; i++)
     63     sd_clear(&topush[i]);
     64   stack_sd_clear(&s);
     65 }
     66 
     67 void test_stack_sd_getlast() {
     68   stack_sd s;
     69   stack_sd_init_size(&s, 8);
     70 
     71   sd topush[20];
     72   size_t i;
     73   for (i = 0; i < 20; i++) {
     74     sd_init_u64(&topush[i], i);
     75     stack_sd_push(&s, topush[i]);
     76   }
     77 
     78   sd tmp = stack_sd_getlast(&s);
     79   CU_ASSERT(tmp.size == topush[19].size);
     80   CU_ASSERT(tmp.data == topush[19].data);
     81 
     82   for (i = 0; i < 5; i++)
     83     sd_clear(&topush[i]);
     84   stack_sd_clear(&s);
     85 }
     86 
     87 void test_stack_sd_pop() {
     88   stack_sd s;
     89   stack_sd_init_size(&s, 8);
     90 
     91   sd topush[20];
     92   size_t i;
     93   for (i = 0; i < 20; i++) {
     94     sd_init_u64(&topush[i], i);
     95     stack_sd_push(&s, topush[i]);
     96   }
     97 
     98   sd tmp;
     99   for (i = 0; i < 20; i++) {
    100     tmp = stack_sd_pop(&s);
    101     CU_ASSERT(tmp.size == topush[19 - i].size);
    102     CU_ASSERT(tmp.data == topush[19 - i].data);
    103   }
    104 
    105   tmp = stack_sd_pop(&s);
    106   CU_ASSERT(tmp.size == STACK_SD_EMPTY_POP.size);
    107   CU_ASSERT(tmp.data == STACK_SD_EMPTY_POP.data);
    108 
    109   tmp = stack_sd_pop(&s);
    110   CU_ASSERT(tmp.size == STACK_SD_EMPTY_POP.size);
    111   CU_ASSERT(tmp.data == STACK_SD_EMPTY_POP.data);
    112 
    113   for (i = 0; i < 5; i++)
    114     sd_clear(&topush[i]);
    115   stack_sd_clear(&s);
    116 }
    117 
    118 void test_stack_sd_lookup() {
    119   stack_sd s;
    120   stack_sd_init_size(&s, 8);
    121 
    122   sd topush[20];
    123   size_t i;
    124   for (i = 0; i < 20; i++) {
    125     sd_init_u64(&topush[i], i);
    126     stack_sd_push(&s, topush[i]);
    127   }
    128 
    129   sd tmp;
    130   sd_init_u64(&tmp, 13);
    131   CU_ASSERT(stack_sd_lookup(&s, tmp) == 13);
    132   sd_clear(&tmp);
    133   sd_init_u64(&tmp, 22);
    134   CU_ASSERT(stack_sd_lookup(&s, tmp) == STACK_SD_LOOKUP_NOT_FOUND);
    135   sd_clear(&tmp);
    136 
    137   for (i = 0; i < 5; i++)
    138     sd_clear(&topush[i]);
    139   stack_sd_clear(&s);
    140 }