lab5_ivec/vector_test.c

#include <stdio.h>

#include "vector.h"
#include "util.h"
#include "macro.h"
#include "munit/munit.h"

static MunitResult
test_vector_len(const MunitParameter params[], void * data)
{
	ivector v;
	vector_init(&v);

	munit_assert_size(vector_len(&v), ==, 0);

	// Lame method, that checks vector_len getter
	v.n = 1337;
	munit_assert_size(vector_len(&v), ==, 1337);

	vector_free(&v);
	munit_assert_size(vector_len(&v), ==, 0);

	return MUNIT_OK;
}

static MunitResult
test_vector_data(const MunitParameter params[], void * data)
{
	// (Really stupid) test for vector_data
	ivector v;
	vector_init(&v);

	munit_assert_not_null(vector_data(&v));
	vector_free(&v);
	munit_assert_null(vector_data(&v));

	return MUNIT_OK;
}

static MunitResult
test_vector_initdata(const MunitParameter params[], void * data)
{
	int *p;
	int i;
	ivector v;
	int arr[] = {
		1, 2, 3, 4, 5
	};

	vector_initdata(&v, arr, ARRSZ(arr));
	p = vector_data(&v);
	munit_assert_not_null(p);
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr));

	for (i = 0; i < ARRSZ(arr); i++) {
		munit_assert_int(arr[i], ==, p[i]);
	}
	vector_free(&v);

	return MUNIT_OK;
}

static MunitResult
test_vector_resize(const MunitParameter params[], void * data)
{
	int i;
	int arr[] = {
		1, 2, 3, 4, 5
	};
	int *p;

	ivector v;

	vector_initdata(&v, arr, ARRSZ(arr));
	vector_resize(&v, 16);
	munit_assert_size(vector_len(&v), ==, 16);

	munit_assert_size(v.n, <=, v.maxsz);

	i = ARRSZ(arr);
	p = vector_data(&v);
	for (; i < 16; i++) {
		munit_assert_int(0, ==, p[i]);
	}

	vector_free(&v);
	return MUNIT_OK;
}

static MunitResult
test_vector_set_get(const MunitParameter params[], void * data)
{
	int arr[] = {
		1, 2, 3, 4, 5
	};
	ivector v;
	int *p;
	int i;

	vector_initdata(&v, arr, ARRSZ(arr));
	for (i = 0; i < vector_len(&v); i++) {
		vector_set(&v, i, i);
	}

	p = vector_data(&v);
	for (i = 0; i < vector_len(&v); i++) {
		int item = vector_get(&v, i);
		munit_assert_int(item, ==, i);
		munit_assert_int(p[i], ==, i);
	}

	vector_free(&v);
	return MUNIT_OK;
}

static MunitResult
test_vector_push_pop(const MunitParameter params[], void * data)
{
	int arr[] = {
		1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
		11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
	int i, tmp;

	ivector v;

	vector_init(&v);

	for (i = 0; i < ARRSZ(arr); i++) {
		vector_push(&v, arr[i]);
	}
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr));

	for (i = 0; i < ARRSZ(arr); i++) {
		tmp = vector_get(&v, i);
		munit_assert_int(tmp, ==, arr[i]);
	}
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr));


	vector_pop(&v);
	vector_pop(&v);

	for (i = 0; i < ARRSZ(arr) - 2; i++) {
		tmp = vector_get(&v, i);
		munit_assert_int(tmp, ==, arr[i]);
	}
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr) - 2);

	for (i = 0; i < ARRSZ(arr); i++) {
		vector_pop(&v);
	}
	munit_assert_size(vector_len(&v), ==, 0);


	vector_free(&v);

	return MUNIT_OK;
}

static MunitResult
test_vector_insert(const MunitParameter params[], void * data)
{
	ivector v;
	vector_init(&v);

	vector_insert(&v, 0, 100);
	munit_assert_size(vector_len(&v), ==, 1);
	munit_assert_int(vector_get(&v, 0), ==, 100);

	vector_insert(&v, 0, 200);
	munit_assert_size(vector_len(&v), ==, 2);
	munit_assert_int(vector_get(&v, 0), ==, 200);
	munit_assert_int(vector_get(&v, 1), ==, 100);

	vector_insert(&v, 2, 300);
	munit_assert_size(vector_len(&v), ==, 3);
	munit_assert_int(vector_get(&v, 2), ==, 300);

	vector_insert(&v, 1, 400);
	munit_assert_size(vector_len(&v), ==, 4);
	munit_assert_int(vector_get(&v, 0), ==, 200);
	munit_assert_int(vector_get(&v, 1), ==, 400);
	munit_assert_int(vector_get(&v, 2), ==, 100);
	munit_assert_int(vector_get(&v, 3), ==, 300);

	vector_free(&v);
	return MUNIT_OK;
}

static MunitResult
test_vector_del(const MunitParameter params[], void * data)
{
	ivector v;
	vector_init(&v);
	int i;

	for (i = 0; i < 5; i++) {
		vector_push(&v, i * 10);
	}
	munit_assert_size(vector_len(&v), ==, 5);

	vector_del(&v, 0);
	munit_assert_size(vector_len(&v), ==, 4);
	munit_assert_int(vector_get(&v, 0), ==, 10);

	vector_del(&v, 3);
	munit_assert_size(vector_len(&v), ==, 3);
	munit_assert_int(vector_get(&v, 0), ==, 10);
	munit_assert_int(vector_get(&v, 1), ==, 20);
	munit_assert_int(vector_get(&v, 2), ==, 30);

	vector_del(&v, 1);
	munit_assert_size(vector_len(&v), ==, 2);
	munit_assert_int(vector_get(&v, 0), ==, 10);
	munit_assert_int(vector_get(&v, 1), ==, 30);

	vector_del(&v, 0);
	vector_del(&v, 0);
	munit_assert_size(vector_len(&v), ==, 0);

	vector_free(&v);
	return MUNIT_OK;
}

#define TEST_ITEM(func) {#func, func, NULL, NULL, MUNIT_TEST_OPTION_NONE }

static MunitTest test_suite_tests[] = {
	TEST_ITEM(test_vector_len),
	TEST_ITEM(test_vector_data),
	TEST_ITEM(test_vector_initdata),

	TEST_ITEM(test_vector_resize),
	TEST_ITEM(test_vector_set_get),
	TEST_ITEM(test_vector_push_pop),

	TEST_ITEM(test_vector_insert),
	TEST_ITEM(test_vector_del),

	{ NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
};

static const MunitSuite test_suite = {
	(char *) "",
	test_suite_tests,
	NULL,
	1,
	MUNIT_SUITE_OPTION_NONE
};


int
main(int argc, const char *argv[])
{
	munit_suite_main(&test_suite, (void *) "vector_test", argc, (char * const*) argv);
	return 0;
}