#include <assert.h>
#include <int/int.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <utils/utils.h>

#if defined(__has_feature)
#if __has_feature(address_sanitizer)
const char*
__asan_default_options(void)
{
	return "allocator_may_return_null=1";
}
#endif
#endif

/* =========================================================================
 * 1. BASIC LIFECYCLE & NULL GUARDS
 * ========================================================================= */

static void
test_push_back_single(void)
{
	printf("[1] Testing push_back with a single integer...\n");
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;
	_vec_int_push_back(&vec, 65, &err);

	assert(err.flags == 0);
	assert(vec._internal_size == 1);
	assert(vec._internal_arr[0] == 65);
	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

static void
test_null_guards(void)
{
	printf("[2] Testing null pointer checks in __null_check...\n");
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	size_t res1 = __null_check(&vec, nullptr);
	assert(res1 == ERR_ERR_T_NULL);

	size_t res2 = __null_check((const _VecIntInternal*)nullptr, &err);
	assert(res2 == ERR_VEC_NULL);
	assert((err.flags & ERR_VEC_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	size_t res3 = __null_check(&vec, &err);
	assert(res3 == ERR_BUF_NULL);
	assert((err.flags & ERR_BUF_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	size_t res4 = __null_check(vec._internal_arr, &err);
	assert(res4 == ERR_BUF_NULL);
	assert((err.flags & ERR_BUF_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	size_t res5 = __null_check((const int*)nullptr, nullptr);
	assert(res5 == ERR_ERR_T_NULL);

	printf("Passed\n");
}

static void
test_origin_override(void)
{
	printf("[3] Testing __origin_override...\n");
	err_t err = ERR_T_INIT;

	size_t res_null_status = __origin_override(nullptr, "TEST");
	assert(res_null_status == ERR_ERR_T_NULL);

	size_t res = __origin_override(&err, nullptr);
	assert(res == ERR_STR_NULL);
	assert((err.flags & ERR_STR_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	__origin_override(&err, "INITIAL");
	assert(strcmp(err.origin, "INITIAL") == 0);

	// Override existing origin -> ERR_ORIGIN_UNALTERABLE
	__origin_override(&err, "REPLACED");
	assert((err.flags & ERR_ORIGIN_UNALTERABLE) != 0);
	assert(strcmp(err.origin, "INITIAL") == 0);

	printf("Passed\n");
}

/* =========================================================================
 * 2. PRINT & COPY
 * ========================================================================= */

static void
test_print_vec(void)
{
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	printf("[4] Testing print_vec with null vector\n");
	_vec_int_print_vec(nullptr, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);
	printf("Passed\n");

	printf("[5] Testing print_vec with null array\n");
	err = (err_t)ERR_T_INIT;
	_vec_int_print_vec(&vec, &err);
	assert((err.flags & ERR_BUF_NULL) != 0);
	printf("Passed\n");

	printf("[6] Testing print_vec with null err\n");
	_vec_int_print_vec(&vec, nullptr);
	printf("Passed\n");

	printf("[7] Testing print_vec with valid parameters\n");
	err = (err_t)ERR_T_INIT;
	_vec_int_push_back(&vec, 1, &err);
	_vec_int_push_back(&vec, 2, &err);
	_vec_int_print_vec(&vec, &err);
	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

static void
test_cpy(void)
{
	int arr[3] = { 1, 2, 3 };
	_VecIntInternal blank = VEC_INIT;

	printf("[8] Testing _vec_int_cpy with null source arr\n");
	err_t err1 = ERR_T_INIT;
	_VecIntInternal tmp = _vec_int_cpy(nullptr, 3, &err1);
	assert(blank._internal_arr == tmp._internal_arr &&
	       blank._internal_capacity == tmp._internal_capacity &&
	       blank._internal_size == tmp._internal_size &&
	       blank._internal_max_size == tmp._internal_max_size);
	assert((err1.flags & ERR_BUF_NULL) != 0);
	printf("Passed\n");

	printf("[9] Testing _vec_int_cpy with null err\n");
	_VecIntInternal res2 = _vec_int_cpy(arr, 3, nullptr);
	assert(blank._internal_arr == res2._internal_arr &&
	       blank._internal_capacity == res2._internal_capacity &&
	       blank._internal_size == res2._internal_size &&
	       blank._internal_max_size == res2._internal_max_size);
	printf("Passed\n");

	printf("[10] Testing _vec_int_cpy with size 0\n");
	err_t err3 = ERR_T_INIT;
	_VecIntInternal res3 = _vec_int_cpy(arr, 0, &err3);
	assert(blank._internal_arr == res3._internal_arr &&
	       blank._internal_capacity == res3._internal_capacity &&
	       blank._internal_size == res3._internal_size &&
	       blank._internal_max_size == res3._internal_max_size);
	assert((err3.flags & ERR_SIZE_ZERO) != 0);
	printf("Passed\n");

	printf("[11] Testing _vec_int_cpy with size exceeding max_size\n");
	err_t err4 = ERR_T_INIT;
	_VecIntInternal res4 =
	    _vec_int_cpy(arr, res3._internal_max_size + 1, &err4);
	assert(blank._internal_arr == res4._internal_arr &&
	       blank._internal_capacity == res4._internal_capacity &&
	       blank._internal_size == res4._internal_size &&
	       blank._internal_max_size == res4._internal_max_size);
	assert((err4.flags & ERR_SIZE_OVERFLOW) != 0);
	printf("Passed\n");

	printf("[12] Testing _vec_int_cpy allocation failure\n");
	err_t err5 = ERR_T_INIT;
	size_t huge_size = ((size_t)1 << 40);
	_VecIntInternal res5 = _vec_int_cpy(arr, huge_size, &err5);
	assert(res5._internal_arr == blank._internal_arr);
	assert((err5.flags & ERR_ALLOC_FAIL) != 0);
	printf("Passed\n");

	printf("[13] Testing _vec_int_cpy with valid inputs\n");
	err_t err = ERR_T_INIT;
	int res[4] = { 10, 20, 30, 40 };
	_VecIntInternal vec = _vec_int_cpy(res, 4, &err);
	assert(err.flags == 0);
	assert(vec._internal_size == 4);
	assert(vec._internal_capacity == 4);
	assert(memcmp(vec._internal_arr, res, sizeof(int) * 4) == 0);
	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

/* =========================================================================
 * 3. PUSH, POP, CAPACITY & SIZING
 * ========================================================================= */

static void
test_push_back(void)
{
	printf("[14] Testing _vec_int_push_back null vec\n");
	err_t err = ERR_T_INIT;
	_vec_int_push_back(nullptr, 1, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);
	printf("Passed\n");

	printf("[15] Testing _vec_int_push_back null err\n");
	_VecIntInternal vec1 = VEC_INIT;
	_vec_int_push_back(&vec1, 1, nullptr);
	assert(vec1._internal_size == 1);
	_vec_int_delete(&vec1, &err);
	printf("Passed\n");

	printf("[16] Testing _vec_int_push_back size overflow\n");
	_VecIntInternal vec2 = VEC_INIT;
	err_t err2 = ERR_T_INIT;
	vec2._internal_size = vec2._internal_max_size;
	_vec_int_push_back(&vec2, 1, &err2);
	assert((err2.flags & ERR_SIZE_OVERFLOW) != 0);
	printf("Passed\n");

	printf("[17] Testing push_back capacity growth realloc\n");
	err_t err3 = ERR_T_INIT;
	_VecIntInternal vec3 = VEC_INIT;
	for (int val = 0; val < 10; val++)
	{
		_vec_int_push_back(&vec3, val, &err3);
		assert(err3.flags == 0);
	}
	assert(vec3._internal_size == 10);
	assert(vec3._internal_capacity >= 10);
	_vec_int_delete(&vec3, &err3);
	printf("Passed\n");
}

static void
test_pop_back(void)
{
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	printf("[18] Testing _vec_int_pop_back null vector\n");
	_vec_int_pop_back(nullptr, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);
	printf("Passed\n");

	printf("[19] Testing _vec_int_pop_back size 0\n");
	err = (err_t)ERR_T_INIT;
	_vec_int_push_back(&vec, 42, &err);
	_vec_int_pop_back(&vec,
			  &err);  // size is now 0, but buffer is allocated
	err = (err_t)ERR_T_INIT;
	_vec_int_pop_back(&vec, &err);
	assert((err.flags & ERR_SIZE_ZERO) != 0);
	printf("Passed\n");

	printf("[20] Testing _vec_int_pop_back valid pop\n");
	err = (err_t)ERR_T_INIT;
	_vec_int_push_back(&vec, 1, &err);
	_vec_int_push_back(&vec, 2, &err);
	assert(vec._internal_size == 2);
	_vec_int_pop_back(&vec, &err);
	assert(vec._internal_size == 1);
	assert(vec._internal_arr[0] == 1);
	assert(vec._internal_arr[1] == 0);
	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

static void
test_reserve(void)
{
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	printf("[21] Testing _vec_int_reserve null vector\n");
	_vec_int_reserve(nullptr, 1, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);
	printf("Passed\n");

	printf("[22] Testing _vec_int_reserve capacity 0\n");
	err = (err_t)ERR_T_INIT;
	_vec_int_reserve(&vec, 0, &err);
	assert((err.flags & ERR_SIZE_ZERO) != 0);
	printf("Passed\n");

	printf("[23] Testing _vec_int_reserve calloc on unallocated buffer\n");
	err = (err_t)ERR_T_INIT;
	_vec_int_reserve(&vec, 32, &err);
	assert(err.flags == 0);
	assert(vec._internal_capacity == 32);
	assert(vec._internal_arr != nullptr);
	printf("Passed\n");

	printf("[24] Testing _vec_int_reserve realloc to larger capacity\n");
	_vec_int_reserve(&vec, 64, &err);
	assert(err.flags == 0);
	assert(vec._internal_capacity == 64);
	printf("Passed\n");

	printf("[25] Testing _vec_int_reserve truncating size\n");
	vec._internal_size = 50;
	_vec_int_reserve(&vec, 20, &err);
	assert(vec._internal_size == 20);
	assert(vec._internal_capacity == 20);
	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

static void
test_shrink_to_fit(void)
{
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	printf("[26] Testing _vec_int_shrink_to_fit null vector\n");
	_vec_int_shrink_to_fit(nullptr, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);
	printf("Passed\n");

	printf(
	    "[27] Testing _vec_int_shrink_to_fit size 0 with allocated "
	    "buffer\n");
	err = (err_t)ERR_T_INIT;
	_vec_int_push_back(&vec, 1, &err);
	_vec_int_pop_back(&vec, &err);
	err = (err_t)ERR_T_INIT;
	_vec_int_shrink_to_fit(&vec, &err);
	assert((err.flags & ERR_SIZE_ZERO) != 0);
	printf("Passed\n");

	printf("[28] Testing _vec_int_shrink_to_fit normal shrinkage\n");
	_vec_int_reserve(&vec, 128, &err);
	for (int val = 0; val < 5; val++)
	{
		_vec_int_push_back(&vec, val, &err);
	}
	assert(vec._internal_capacity == 128);
	assert(vec._internal_size == 5);
	err = (err_t)ERR_T_INIT;
	_vec_int_shrink_to_fit(&vec, &err);
	assert(err.flags == 0);
	assert(vec._internal_capacity == 5);
	assert(vec._internal_size == 5);
	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

/* =========================================================================
 * 4. GETTERS, ELEMENT ACCESS & CLEAR
 * ========================================================================= */

static void
test_getters_and_access(void)
{
	printf("[29] Testing getters, clear, and boundary element access...\n");
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	// 1. Null pointer check
	assert(_vec_int_data(nullptr, &err) == nullptr);
	assert((err.flags & ERR_VEC_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	assert(_vec_int_size(nullptr, &err) == 0);
	assert((err.flags & ERR_VEC_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	assert(_vec_int_capacity(nullptr, &err) == 0);
	assert((err.flags & ERR_VEC_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	assert(_vec_int_max_size(nullptr, &err) == 0);
	assert((err.flags & ERR_VEC_NULL) != 0);

	// 2. Unallocated buffer check for empty()
	err = (err_t)ERR_T_INIT;
	size_t unalloc_empty = _vec_int_empty(&vec, &err);
	assert((err.flags & ERR_BUF_NULL) != 0);
	assert(unalloc_empty != 0);

	// 3. Allocate the buffer and pop so size is 0 with valid arr
	err = (err_t)ERR_T_INIT;
	_vec_int_push_back(&vec, 100, &err);
	_vec_int_pop_back(&vec, &err);
	err = (err_t)ERR_T_INIT;

	// Now _internal_arr is non-null and size is 0:
	assert(_vec_int_empty(&vec, &err) == 0);

	// Boundary element access on size 0
	err = (err_t)ERR_T_INIT;
	assert(_vec_int_front(&vec, &err) == 0 ||
	       (err.flags & ERR_OUT_OF_BOUNDS) != 0);

	err = (err_t)ERR_T_INIT;
	assert(_vec_int_back(&vec, &err) == 0 ||
	       (err.flags & ERR_OUT_OF_BOUNDS) != 0);

	// 4. Populate container
	err = (err_t)ERR_T_INIT;
	_vec_int_push_back(&vec, 10, &err);
	_vec_int_push_back(&vec, 20, &err);
	_vec_int_push_back(&vec, 30, &err);

	assert(_vec_int_size(&vec, &err) == 3);
	assert(_vec_int_capacity(&vec, &err) >= 3);
	assert(_vec_int_data(&vec, &err) == vec._internal_arr);
	assert(_vec_int_front(&vec, &err) == 10);
	assert(_vec_int_back(&vec, &err) == 30);
	assert(_vec_int_begin(&vec, &err) == 0);
	assert(_vec_int_end(&vec, &err) == 2);

	// Out of bounds at()
	err = (err_t)ERR_T_INIT;
	assert(_vec_int_at(&vec, 10, &err) == nullptr);
	assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);

	// Clear container
	err = (err_t)ERR_T_INIT;
	_vec_int_clear(&vec, &err);
	assert(vec._internal_size == 0);
	assert(vec._internal_arr[0] == 0);

	_vec_int_delete(&vec, &err);
	assert(vec._internal_arr == nullptr);
	assert(vec._internal_size == 0);
	assert(vec._internal_capacity == 0);

	printf("Passed\n");
}

/* =========================================================================
 * 5. SWAP, ERASE, RESIZE, ASSIGN & INSERT
 * ========================================================================= */

static void
test_swap(void)
{
	printf("[30] Testing _vec_int_swap...\n");
	_VecIntInternal a = VEC_INIT;
	_VecIntInternal b = VEC_INIT;
	err_t err = ERR_T_INIT;

	// Null vector checks
	_vec_int_swap(nullptr, &b, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);

	err = (err_t)ERR_T_INIT;
	_vec_int_swap(&a, nullptr, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);

	// Normal swap
	err = (err_t)ERR_T_INIT;
	_vec_int_push_back(&a, 100, &err);
	_vec_int_push_back(&b, 200, &err);
	_vec_int_push_back(&b, 300, &err);

	_vec_int_swap(&a, &b, &err);
	assert(a._internal_size == 2);
	assert(a._internal_arr[0] == 200);
	assert(b._internal_size == 1);
	assert(b._internal_arr[0] == 100);

	_vec_int_delete(&a, &err);
	_vec_int_delete(&b, &err);
	printf("Passed\n");
}

static void
test_erase_variants(void)
{
	printf("[31] Testing _vec_int_erase single & range overloads...\n");
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	for (int val = 0; val <= 5; val++)
	{
		_vec_int_push_back(&vec, val, &err);
	}  // {0, 1, 2, 3, 4, 5}

	// Single element erase out of bounds (noop)
	_vec_int_erase(&vec, 10, &err);
	assert(vec._internal_size == 6);

	// Erase index 2 (value 2) -> {0, 1, 3, 4, 5}
	_vec_int_erase(&vec, 2, &err);
	assert(vec._internal_size == 5);
	assert(vec._internal_arr[2] == 3);

	// Range erase invalid bounds
	err = (err_t)ERR_T_INIT;
	_vec_int_erase(&vec, 4, 2, &err);  // iter_end <= iter_start
	assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);

	err = (err_t)ERR_T_INIT;
	_vec_int_erase(&vec, 0, 10, &err);  // iter_end > size
	assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);

	// Range erase middle: index 1 through 3 ({0, [1, 3], 4, 5} -> {0, 4,
	// 5})
	err = (err_t)ERR_T_INIT;
	_vec_int_erase(&vec, 1, 3, &err);
	assert(vec._internal_size == 3);
	assert(vec._internal_arr[0] == 0);
	assert(vec._internal_arr[1] == 4);
	assert(vec._internal_arr[2] == 5);

	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

static void
test_resize(void)
{
	printf("[32] Testing _vec_int_resize (zero-fill & value-fill)...\n");
	_VecIntInternal vec = VEC_INIT;
	err_t err = ERR_T_INIT;

	// Null vector
	_vec_int_resize((_VecIntInternal*)nullptr, 10, &err);
	assert((err.flags & ERR_VEC_NULL) != 0);

	// Resize unallocated buffer to size 5
	err = (err_t)ERR_T_INIT;
	_vec_int_resize(&vec, 5, &err);
	assert(err.flags == 0);
	assert(vec._internal_size == 5);
	assert(vec._internal_arr[0] == 0);

	// Same size requested
	err = (err_t)ERR_T_INIT;
	_vec_int_resize(&vec, 5, &err);
	assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);

	// Exceeds max size
	err = (err_t)ERR_T_INIT;
	_vec_int_resize(&vec, vec._internal_max_size + 1, &err);
	assert((err.flags & ERR_SIZE_OVERFLOW) != 0);

	// Grow with value fill
	err = (err_t)ERR_T_INIT;
	_vec_int_resize(&vec, 8, 5, &err);
	assert(vec._internal_size == 8);
	assert(vec._internal_arr[5] == 5);
	assert(vec._internal_arr[7] == 5);

	// Shrink with value fill
	err = (err_t)ERR_T_INIT;
	_vec_int_resize(&vec, 3, 10, &err);
	assert(vec._internal_size == 3);

	_vec_int_delete(&vec, &err);
	printf("Passed\n");
}

static void
test_assign(void)
{
	printf("[33] Testing _vec_int_assign overloads...\n");
	_VecIntInternal dst = VEC_INIT;
	_VecIntInternal src = VEC_INIT;
	err_t err = ERR_T_INIT;

	// Populate src: 1, 2, 3, 4, 5
	for (int val = 1; val <= 5; val++)
	{
		_vec_int_push_back(&src, val, &err);
	}

	// Allocate dst buffer first so it is not unallocated
	_vec_int_push_back(&dst, 999, &err);
	err = (err_t)ERR_T_INIT;

	// 1. Fill assign: 4 42's
	_vec_int_assign(&dst, 4, 42, &err);
	assert(err.flags == 0);
	assert(dst._internal_size == 4);
	assert(dst._internal_arr[0] == 42);
	assert(dst._internal_arr[3] == 42);

	// 2. Fill assign with 0 amount
	err = (err_t)ERR_T_INIT;
	_vec_int_assign(&dst, 0, 50, &err);
	assert((err.flags & ERR_SIZE_ZERO) != 0);

	// 3. Range assign self-buffer check
	err = (err_t)ERR_T_INIT;
	_vec_int_assign(&dst, &dst, 0, 2, &err);
	assert((err.flags & ERR_DOUBLE_BUF) != 0);

	// 4. Range assign invalid sub-range (start >= end)
	err = (err_t)ERR_T_INIT;
	_vec_int_assign(&dst, &src, 3, 2, &err);
	assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);

	// 5. Range assign out of bounds end
	err = (err_t)ERR_T_INIT;
	_vec_int_assign(&dst, &src, 0, 10, &err);
	assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);

	_vec_int_delete(&dst, &err);
	_vec_int_delete(&src, &err);
	printf("Passed\n");
}

static void
test_insert(void)
{
	printf("[34] Testing _vec_int_insert overloads...\n");
	_VecIntInternal vec = VEC_INIT;
	_VecIntInternal other = VEC_INIT;
	err_t err = ERR_T_INIT;

	// Single insert on unallocated buffer
	_vec_int_insert(&vec, 0, 500, &err);
	assert(vec._internal_size == 1);
	assert(vec._internal_arr[0] == 500);

	// Single insert out of bounds
	err = (err_t)ERR_T_INIT;
	_vec_int_insert(&vec, 5, 999, &err);
	assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);

	// Single insert at middle: index 0 (100, then 500 shifts to 1)
	err = (err_t)ERR_T_INIT;
	_vec_int_insert(&vec, 0, 100, &err);
	assert(vec._internal_size == 2);
	assert(vec._internal_arr[0] == 100);
	assert(vec._internal_arr[1] == 500);

	// Repeated insert: insert 3 200s at index 1 -> {100, 200, 200, 200,
	// 500}
	_vec_int_insert(&vec, 1, 3, 200, &err);
	assert(vec._internal_size == 5);
	assert(vec._internal_arr[1] == 200);
	assert(vec._internal_arr[3] == 200);
	assert(vec._internal_arr[4] == 500);

	// Repeated insert amount 0
	err = (err_t)ERR_T_INIT;
	_vec_int_insert(&vec, 0, 0, 300, &err);
	assert((err.flags & ERR_SIZE_ZERO) != 0);

	// Vector-from-vector range insert
	_vec_int_push_back(&other, 1, &err);
	_vec_int_push_back(&other, 2, &err);

	// Double buffer check
	err = (err_t)ERR_T_INIT;
	_vec_int_insert(&vec, &vec, 0, 0, 1, &err);
	assert((err.flags & ERR_DOUBLE_BUF) != 0);

	_vec_int_delete(&vec, &err);
	_vec_int_delete(&other, &err);
	printf("Passed\n");
}

/* =========================================================================
 * MAIN TEST RUNNER
 * ========================================================================= */

int
main(void)
{
	printf("=========================================\n");
	printf(" Starting Complete libvec Unit Test Suite\n");
	printf("=========================================\n");

	test_push_back_single();
	test_null_guards();
	test_origin_override();
	test_print_vec();
	test_cpy();
	test_push_back();
	test_pop_back();
	test_reserve();
	test_shrink_to_fit();
	test_getters_and_access();
	test_swap();
	test_erase_variants();
	test_resize();
	test_assign();
	test_insert();

	printf("=========================================\n");
	printf(" All 34 Test Suites Executed Successfully!\n");
	printf("=========================================\n");
	return 0;
}