Line data    Source code

       1             : #include "passgen/container/array.h"
       2             : #include "tests.h"
       3             : #include <string.h>
       4             : 
       5           1 : test_result test_array_init(void) {
       6           1 :     size_t capacity = 15;
       7             :     passgen_array array;
       8           1 :     passgen_array_init(&array, capacity);
       9           1 :     assert_eq(array.capacity, capacity);
      10           1 :     assert_eq(array.items, 0);
      11           1 :     assert(array.data != NULL);
      12             : 
      13           1 :     passgen_array_free(&array);
      14             : 
      15           1 :     return test_ok;
      16             : }
      17             : 
      18           1 : test_result test_array_push(void) {
      19           1 :     size_t capacity = 15;
      20             :     passgen_array array;
      21           1 :     passgen_array_init(&array, capacity);
      22           1 :     assert_eq(array.capacity, capacity);
      23           1 :     assert_eq(array.items, 0);
      24           1 :     assert(array.data != NULL);
      25             : 
      26           1 :     int data1 = 7;
      27           1 :     passgen_array_push(&array, &data1);
      28           1 :     assert_eq(array.capacity, capacity);
      29           1 :     assert_eq(array.items, 1);
      30           1 :     assert_eq(array.data[0], &data1);
      31             : 
      32           1 :     int data2 = 8;
      33           1 :     passgen_array_push(&array, &data2);
      34           1 :     assert_eq(array.capacity, capacity);
      35           1 :     assert_eq(array.items, 2);
      36           1 :     assert_eq(array.data[1], &data2);
      37             : 
      38           1 :     passgen_array_free(&array);
      39             : 
      40           1 :     return test_ok;
      41             : }
      42             : 
      43           1 : test_result test_array_get(void) {
      44           1 :     size_t capacity = 15;
      45             :     passgen_array array;
      46           1 :     passgen_array_init(&array, capacity);
      47           1 :     assert_eq(array.capacity, capacity);
      48           1 :     assert_eq(array.items, 0);
      49           1 :     assert(array.data != NULL);
      50             : 
      51           1 :     int data1 = 7;
      52           1 :     int data2 = 7;
      53           1 :     int data3 = 7;
      54           1 :     passgen_array_push(&array, &data1);
      55           1 :     passgen_array_push(&array, &data2);
      56           1 :     passgen_array_push(&array, &data3);
      57             : 
      58           1 :     assert_eq(passgen_array_get(&array, 0), &data1);
      59           1 :     assert_eq(passgen_array_get(&array, 1), &data2);
      60           1 :     assert_eq(passgen_array_get(&array, 2), &data3);
      61             : 
      62           1 :     passgen_array_free(&array);
      63             : 
      64           1 :     return test_ok;
      65             : }
      66             : 
      67           1 : test_result test_array_pop(void) {
      68           1 :     size_t capacity = 15;
      69             :     passgen_array array;
      70           1 :     passgen_array_init(&array, capacity);
      71           1 :     assert_eq(array.capacity, capacity);
      72           1 :     assert_eq(array.items, 0);
      73           1 :     assert(array.data != NULL);
      74             : 
      75           1 :     int data1 = 7;
      76           1 :     int data2 = 7;
      77           1 :     int data3 = 7;
      78           1 :     passgen_array_push(&array, &data1);
      79           1 :     passgen_array_push(&array, &data2);
      80           1 :     passgen_array_push(&array, &data3);
      81             : 
      82           1 :     assert_eq(passgen_array_pop(&array), &data3);
      83           1 :     assert_eq(array.items, 2);
      84             : 
      85           1 :     assert_eq(passgen_array_pop(&array), &data2);
      86           1 :     assert_eq(array.items, 1);
      87             : 
      88           1 :     assert_eq(passgen_array_pop(&array), &data1);
      89           1 :     assert_eq(array.items, 0);
      90             : 
      91           1 :     assert_eq(passgen_array_pop(&array), NULL);
      92             : 
      93           1 :     passgen_array_free(&array);
      94             : 
      95           1 :     return test_ok;
      96             : }
      97             : 
      98           1 : test_result test_array_realloc(void) {
      99           1 :     size_t capacity = 15;
     100             :     passgen_array array;
     101           1 :     passgen_array_init(&array, capacity);
     102           1 :     assert_eq(array.capacity, capacity);
     103           1 :     assert_eq(array.items, 0);
     104           1 :     assert(array.data != NULL);
     105             : 
     106           1 :     int data = 7;
     107           1 :     passgen_array_push(&array, &data);
     108           1 :     assert_eq(array.capacity, capacity);
     109           1 :     assert_eq(array.items, 1);
     110           1 :     assert_eq(array.data[0], &data);
     111             : 
     112           1 :     size_t new_capacity = 1500;
     113           1 :     passgen_array_realloc(&array, new_capacity);
     114           1 :     assert_eq(array.capacity, new_capacity);
     115           1 :     assert_eq(array.items, 1);
     116           1 :     assert_eq(array.data[0], &data);
     117             : 
     118           1 :     passgen_array_free(&array);
     119             : 
     120           1 :     return test_ok;
     121             : }