Line data    Source code

       1             : #include "passgen/container/stack.h"
       2             : #include "tests.h"
       3             : #include <stdlib.h>
       4             : 
       5           1 : test_result test_stack_init(void) {
       6             :     passgen_stack stack;
       7           1 :     passgen_stack_init(&stack, sizeof(size_t));
       8           1 :     passgen_stack_free(&stack);
       9           1 :     return test_ok;
      10             : }
      11             : 
      12           1 : test_result test_stack_push_one(void) {
      13             :     passgen_stack stack;
      14           1 :     passgen_stack_init(&stack, sizeof(size_t));
      15           1 :     assert_eq(stack.len, 0);
      16             : 
      17           1 :     size_t value = 2;
      18           1 :     size_t *value_ptr = passgen_stack_push(&stack, &value);
      19           1 :     assert(value_ptr);
      20           1 :     assert_eq(value, *value_ptr);
      21           1 :     assert_eq(stack.len, 1);
      22             : 
      23           1 :     passgen_stack_free(&stack);
      24           1 :     return test_ok;
      25             : }
      26             : 
      27           1 : test_result test_stack_push_multiple(void) {
      28             :     passgen_stack stack;
      29           1 :     passgen_stack_init(&stack, sizeof(size_t));
      30             : 
      31             :     size_t value;
      32             :     size_t *value_ptr;
      33             : 
      34           1 :     value = 1;
      35           1 :     value_ptr = passgen_stack_push(&stack, &value);
      36           1 :     assert(value_ptr);
      37           1 :     assert_eq(value, *value_ptr);
      38           1 :     assert_eq(stack.len, 1);
      39             : 
      40           1 :     value = 2;
      41           1 :     value_ptr = passgen_stack_push(&stack, NULL);
      42           1 :     assert(value_ptr);
      43           1 :     *value_ptr = value;
      44           1 :     assert_eq(value, *value_ptr);
      45           1 :     assert_eq(stack.len, 2);
      46             : 
      47           1 :     value = 3;
      48           1 :     value_ptr = passgen_stack_push(&stack, &value);
      49           1 :     assert(value_ptr);
      50           1 :     assert_eq(value, *value_ptr);
      51           1 :     assert_eq(stack.len, 3);
      52             : 
      53           1 :     passgen_stack_free(&stack);
      54           1 :     return test_ok;
      55             : }
      56             : 
      57           1 : test_result test_stack_push_bin_size(void) {
      58             :     passgen_stack stack;
      59           1 :     passgen_stack_init(&stack, sizeof(size_t));
      60             : 
      61          33 :     for(size_t i = 0; i < stack.bin_size; i++) {
      62          32 :         assert_eq(stack.len, i);
      63          32 :         size_t *value_ptr = passgen_stack_push(&stack, &i);
      64          32 :         assert(value_ptr);
      65          32 :         assert_eq(i, *value_ptr);
      66             :     }
      67             : 
      68           1 :     passgen_stack_free(&stack);
      69           1 :     return test_ok;
      70             : }
      71             : 
      72           1 : test_result test_stack_push_many(void) {
      73             :     passgen_stack stack;
      74           1 :     passgen_stack_init(&stack, sizeof(size_t));
      75           1 :     size_t len_max = 7 * stack.bin_size - 3;
      76             : 
      77         222 :     for(size_t i = 0; i < len_max; i++) {
      78         221 :         assert_eq(stack.len, i);
      79         221 :         size_t *value_ptr = passgen_stack_push(&stack, &i);
      80         221 :         assert(value_ptr);
      81         221 :         assert_eq(i, *value_ptr);
      82             :     }
      83             : 
      84           1 :     assert_eq(stack.len, len_max);
      85           1 :     passgen_stack_free(&stack);
      86           1 :     return test_ok;
      87             : }
      88             : 
      89           1 : test_result test_stack_get_one(void) {
      90             :     passgen_stack stack;
      91           1 :     passgen_stack_init(&stack, sizeof(size_t));
      92             :     size_t *value_ptr;
      93           1 :     size_t value = 1;
      94             : 
      95           1 :     value_ptr = passgen_stack_push(&stack, &value);
      96           1 :     assert(value_ptr);
      97           1 :     assert_eq(value, *value_ptr);
      98             : 
      99           1 :     value_ptr = passgen_stack_get(&stack, 0);
     100           1 :     assert(value_ptr);
     101           1 :     assert_eq(value, *value_ptr);
     102             : 
     103           1 :     passgen_stack_free(&stack);
     104           1 :     return test_ok;
     105             : }
     106             : 
     107           1 : test_result test_stack_get_two(void) {
     108             :     passgen_stack stack;
     109           1 :     passgen_stack_init(&stack, sizeof(size_t));
     110             :     size_t *value_ptr;
     111           1 :     size_t value = 1;
     112             : 
     113           1 :     value_ptr = passgen_stack_push(&stack, &value);
     114           1 :     assert(value_ptr);
     115           1 :     assert_eq(value, *value_ptr);
     116             : 
     117           1 :     value = 2;
     118           1 :     value_ptr = passgen_stack_push(&stack, &value);
     119           1 :     assert(value_ptr);
     120           1 :     assert_eq(value, *value_ptr);
     121             : 
     122           1 :     value_ptr = passgen_stack_get(&stack, 0);
     123           1 :     assert(value_ptr);
     124           1 :     assert_eq(1, *value_ptr);
     125             : 
     126           1 :     value_ptr = passgen_stack_get(&stack, 1);
     127           1 :     assert(value_ptr);
     128           1 :     assert_eq(2, *value_ptr);
     129             : 
     130           1 :     passgen_stack_free(&stack);
     131           1 :     return test_ok;
     132             : }
     133             : 
     134           1 : test_result test_stack_get_many(void) {
     135             :     passgen_stack stack;
     136           1 :     passgen_stack_init(&stack, sizeof(size_t));
     137           1 :     size_t max_len = 7 * stack.bin_size - 3;
     138             : 
     139         222 :     for(size_t i = 0; i < max_len; i++) {
     140         221 :         size_t *value_ptr = passgen_stack_push(&stack, &i);
     141         221 :         assert(value_ptr);
     142         221 :         assert_eq(i, *value_ptr);
     143             :     }
     144             : 
     145         222 :     for(size_t i = 0; i < stack.len; i++) {
     146         221 :         size_t *value_ptr = passgen_stack_get(&stack, i);
     147         221 :         assert(value_ptr);
     148         221 :         assert_eq(i, *value_ptr);
     149             :     }
     150             : 
     151           1 :     passgen_stack_free(&stack);
     152           1 :     return test_ok;
     153             : }
     154             : 
     155           1 : test_result test_stack_top_empty(void) {
     156             :     passgen_stack stack;
     157           1 :     passgen_stack_init(&stack, sizeof(size_t));
     158             : 
     159           1 :     assert(!passgen_stack_top(&stack));
     160             : 
     161           1 :     passgen_stack_free(&stack);
     162           1 :     return test_ok;
     163             : }
     164             : 
     165           1 : test_result test_stack_top_one(void) {
     166             :     passgen_stack stack;
     167           1 :     passgen_stack_init(&stack, sizeof(size_t));
     168             : 
     169           1 :     size_t value = 1;
     170             :     size_t *value_ptr;
     171             : 
     172           1 :     value_ptr = passgen_stack_push(&stack, &value);
     173           1 :     assert(value_ptr);
     174           1 :     assert_eq(value, *value_ptr);
     175             : 
     176             :     // should return the exact same pointer as push did
     177           1 :     assert_eq(value_ptr, passgen_stack_top(&stack));
     178             : 
     179           1 :     passgen_stack_free(&stack);
     180           1 :     return test_ok;
     181             : }
     182             : 
     183           1 : test_result test_stack_top_many(void) {
     184             :     passgen_stack stack;
     185           1 :     passgen_stack_init(&stack, sizeof(size_t));
     186           1 :     size_t len_max = 8 * stack.bin_size;
     187             : 
     188         257 :     for(size_t i = 0; i < len_max; i++) {
     189         256 :         size_t *value_ptr = passgen_stack_push(&stack, &i);
     190         256 :         assert(value_ptr);
     191         256 :         assert_eq(i, *value_ptr);
     192         256 :         assert_eq(value_ptr, passgen_stack_top(&stack));
     193             :     }
     194             : 
     195           1 :     passgen_stack_free(&stack);
     196           1 :     return test_ok;
     197             : }
     198             : 
     199         254 : void element_free(void *data) {
     200         254 :     void **real_data = data;
     201         254 :     free(*real_data);
     202         254 : }
     203             : 
     204           1 : test_result test_stack_foreach_empty(void) {
     205             :     passgen_stack stack;
     206           1 :     passgen_stack_init(&stack, sizeof(size_t));
     207           1 :     passgen_stack_foreach(&stack, element_free);
     208           1 :     passgen_stack_free(&stack);
     209           1 :     return test_ok;
     210             : }
     211             : 
     212           1 : test_result test_stack_foreach_one(void) {
     213             :     passgen_stack stack;
     214           1 :     passgen_stack_init(&stack, sizeof(void *));
     215           1 :     void *data = malloc(255);
     216           1 :     passgen_stack_push(&stack, &data);
     217           1 :     passgen_stack_foreach(&stack, element_free);
     218           1 :     passgen_stack_free(&stack);
     219           1 :     return test_ok;
     220             : }
     221             : 
     222           1 : test_result test_stack_foreach_many(void) {
     223             :     passgen_stack stack;
     224           1 :     passgen_stack_init(&stack, sizeof(void *));
     225           1 :     size_t max_len = 8 * stack.bin_size - 3;
     226             : 
     227         254 :     for(size_t i = 0; i < max_len; i++) {
     228         253 :         void *data = malloc(255);
     229         253 :         passgen_stack_push(&stack, &data);
     230             :     }
     231             : 
     232           1 :     passgen_stack_foreach(&stack, element_free);
     233           1 :     passgen_stack_free(&stack);
     234           1 :     return test_ok;
     235             : }
     236             : 
     237           1 : test_result test_stack_pop_empty(void) {
     238             :     passgen_stack stack;
     239           1 :     passgen_stack_init(&stack, sizeof(size_t));
     240             : 
     241             :     size_t value;
     242           1 :     assert_eq(passgen_stack_pop(&stack, &value), NULL);
     243             : 
     244           1 :     passgen_stack_free(&stack);
     245           1 :     return test_ok;
     246             : }
     247             : 
     248           1 : test_result test_stack_pop_one(void) {
     249             :     passgen_stack stack;
     250           1 :     passgen_stack_init(&stack, sizeof(size_t));
     251             : 
     252           1 :     size_t value = 1;
     253           1 :     passgen_stack_push(&stack, &value);
     254             : 
     255           1 :     size_t top = 0;
     256           1 :     assert_eq(passgen_stack_pop(&stack, &top), &top);
     257           1 :     assert_eq(top, value);
     258             : 
     259           1 :     passgen_stack_free(&stack);
     260           1 :     return test_ok;
     261             : }
     262             : 
     263           1 : test_result test_stack_pop_some(void) {
     264             :     passgen_stack stack;
     265           1 :     passgen_stack_init(&stack, sizeof(size_t));
     266             : 
     267          33 :     for(size_t i = 0; i < stack.bin_size; i++) {
     268          32 :         size_t *value = passgen_stack_push(&stack, &i);
     269          32 :         assert(value);
     270          32 :         assert_eq(*value, i);
     271             :     }
     272             : 
     273          33 :     for(size_t i = 0; i < stack.bin_size; i++) {
     274             :         size_t value;
     275          32 :         size_t *ret = passgen_stack_pop(&stack, &value);
     276          32 :         assert_eq(ret, &value);
     277          32 :         assert_eq(value, stack.len);
     278             :     }
     279             : 
     280           1 :     assert_eq(stack.len, 0);
     281             : 
     282           1 :     passgen_stack_free(&stack);
     283           1 :     return test_ok;
     284             : }
     285             : 
     286           1 : test_result test_stack_pop_many(void) {
     287             :     passgen_stack stack;
     288           1 :     passgen_stack_init(&stack, sizeof(size_t));
     289           1 :     size_t max_len = 7 * stack.bin_size - 3;
     290             : 
     291         222 :     for(size_t i = 0; i < max_len; i++) {
     292         221 :         size_t *value = passgen_stack_push(&stack, &i);
     293         221 :         assert(value);
     294         221 :         assert_eq(*value, i);
     295             :     }
     296             : 
     297         222 :     for(size_t i = 0; i < max_len; i++) {
     298             :         size_t value;
     299         221 :         size_t *ret = passgen_stack_pop(&stack, &value);
     300         221 :         assert_eq(ret, &value);
     301         221 :         assert_eq(value, stack.len);
     302             :     }
     303             : 
     304           1 :     assert_eq(stack.len, 0);
     305             : 
     306           1 :     passgen_stack_free(&stack);
     307           1 :     return test_ok;
     308             : }