wizapp-stdlib/tests/array/test_i32_array.c

#include "test_i32_array.h"
#include "wapp.h"

TestFuncResult test_i32_array(void) {
  b8 result;

  i32 *array = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7);
  result = wapp_array_count(i32, array) == 7 && wapp_array_capacity(i32, array) == 16;

  i32 item;
  u64 count   = wapp_array_count(i32, array);
  u64 index   = 0;
  b8 running  = true;
  while (running) {
      item   = wapp_array_get(i32, array, index);
      result = result && item && item == (i32)(index + 1);

      ++index;
      running = index < count;
  }

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_with_capacity(void) {
  b8 result;

  i32 *array = wapp_array_with_capacity(i32, 64);
  result = wapp_array_count(i32, array) == 0 && wapp_array_capacity(i32, array) == 64;

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_get(void) {
  b8 result = true;

  i32 *array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);

  i32 item;
  u64 count   = wapp_array_count(i32, array);
  u64 index   = 0;
  b8 running  = true;
  while (running) {
    item   = wapp_array_get(i32, array, index);
    result = result && item == (i32)index;

    ++index;
    running = index < count;
  }

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_set(void) {
  b8 result = true;

  i32 *array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);

  i32 item;
  u64 count   = wapp_array_count(i32, array);
  u64 index   = 0;
  b8 running  = true;
  while (running) {
    i32 num = (i32)(index * 2);
    wapp_array_set(i32, array, index, &num);
    item   = wapp_array_get(i32, array, index);
    result = result && item == (i32)(index * 2);

    ++index;
    running = index < count;
  }

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_append_capped(void) {
  b8 result;

  i32 *array = wapp_array_with_capacity(i32, 64);
  wapp_array_append_capped(i32, array, &((i32){10}));

  result = wapp_array_count(i32, array) == 1;
  i32 item = wapp_array_get(i32, array, 0);
  result = result && item == 10;

  array = wapp_array(i32, 1);
  wapp_array_append_capped(i32, array, &((i32){10}));

  result = result && wapp_array_count(i32, array) == 2;

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_extend_capped(void) {
  b8 result;

  i32 *array1 = wapp_array(i32, 1, 2, 3, 4);
  i32 *array2 = wapp_array(i32, 10, 20);

  result = wapp_array_count(i32, array1) == 4 && wapp_array_count(i32, array2) == 2;

  wapp_array_extend_capped(i32, array1, array2);

  result = result && wapp_array_count(i32, array1) == 6;

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_copy_capped(void) {
  b8 result;

  i32 *src  = wapp_array(i32, 1, 2, 3, 4, 5);
  i32 *dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6);
  i32 *dst2 = wapp_array(i32, 1, 2);

  u64 expected_count = 5;
  wapp_array_copy_capped(i32, dst1, src);
  result = wapp_array_count(i32, dst1) == expected_count;

  u64 index    = 0;
  b8 running  = true;
  while (running) {
    result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, dst1, index);

    ++index;
    running = index < expected_count;
  }

  expected_count = 4;
  wapp_array_copy_capped(i32, dst2, src);
  result = result && wapp_array_count(i32, dst2) == expected_count;

  index   = 0;
  running = true;
  while (running) {
    result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, dst2, index);

    ++index;
    running = index < expected_count;
  }

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_alloc_capacity(void) {
  b8 result;

  Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
  u64 capacity        = 32;
  i32 *array          = wapp_array_alloc_capacity(i32, &allocator, capacity);

  result = array && wapp_array_capacity(i32, array) == capacity;

  wapp_mem_arena_allocator_destroy(&allocator);

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_append_alloc(void) {
  b8 result;

  Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
  i32 *array1         = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8);
  i32 *array2         = wapp_array(i32, 1, 2);

  i32 *arr_ptr = wapp_array_append_alloc(i32, &allocator, array1, &((i32){10}));
  result = arr_ptr == array1;

  u64 count    = 4;
  u64 index    = 0;
  b8 running  = true;
  while (running) {
    i32 num = (i32)index;
    arr_ptr = wapp_array_append_alloc(i32, &allocator, array2, &num);

    ++index;
    running = index < count;
  }
  result = result && arr_ptr != array2;

  wapp_mem_arena_allocator_destroy(&allocator);

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_extend_alloc(void) {
  b8 result;

  Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
  i32 *array1         = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8);
  i32 *array2         = wapp_array(i32, 1, 2);
  i32 *array3         = wapp_array(i32, 1, 2, 3, 4);

  i32 *arr_ptr = wapp_array_extend_alloc(i32, &allocator, array1, array3);
  result = arr_ptr == array1;

  arr_ptr = wapp_array_extend_alloc(i32, &allocator, array2, array3);
  result  = result && arr_ptr != array2;

  wapp_mem_arena_allocator_destroy(&allocator);

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_copy_alloc(void) {
  b8 result;

  Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
  i32 *src        = wapp_array(i32, 1, 2, 3, 4, 5);
  i32 *dst1       = wapp_array(i32, 1, 2, 3, 4, 5, 6);
  i32 *dst2       = wapp_array(i32, 1, 2);
  i32 *array_ptr  = NULL;

  u64 expected_count = 5;
  array_ptr = wapp_array_copy_alloc(i32, &allocator, dst1, src);
  result = wapp_array_count(i32, array_ptr) == expected_count && array_ptr == dst1;

  u64 index    = 0;
  b8 running  = true;
  while (running) {
    result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, array_ptr, index);

    ++index;
    running = index < expected_count;
  }

  expected_count = 5;
  array_ptr = wapp_array_copy_alloc(i32, &allocator, dst2, src);
  result = result && wapp_array_count(i32, array_ptr) == expected_count && array_ptr != dst2;

  index   = 0;
  running = true;
  while (running) {
    result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, array_ptr, index);

    ++index;
    running = index < expected_count;
  }

  wapp_mem_arena_allocator_destroy(&allocator);

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_pop(void) {
  b8 result;

  i32 *array1 = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
  i32 *array2 = wapp_array_with_capacity(i32, 32);

  i32 item1 = wapp_array_pop(i32, array1);
  i32 item2 = wapp_array_pop(i32, array2);

  result = item1 == 8 && item2 == 0;

  return wapp_tester_result(result);
}

TestFuncResult test_i32_array_clear(void) {
  b8 result;

  i32 *array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
  result = wapp_array_count(i32, array) == 9;

  wapp_array_clear(i32, array);

  result = result && wapp_array_count(i32, array) == 0;

  return wapp_tester_result(result);
}