[cgds.git] / test / t.Vector.c

#include <stdlib.h>
#include "cgds/Vector.h"
#include "test/helpers.h"
#include "test/lut.h"

void t_vector_clear() //FTEST
{
	Vector* v = vector_new(int);
	lu_assert(vector_empty(v));

	vector_push(v, 0);
	vector_push(v, 0);
	vector_push(v, 0);

	vector_destroy(v);
	v = vector_new(int);

	vector_push(v, 0);
	vector_push(v, 0);
	vector_push(v, 0);

	vector_clear(v);
	lu_assert(vector_empty(v));

	vector_destroy(v);
}

void t_vector_size() //FTEST
{
	Vector* v = vector_new(int);
	lu_assert(vector_empty(v));

	vector_push(v, 0);
	vector_push(v, 0);
	vector_push(v, 0);
	lu_assert_int_eq(vector_size(v), 3);

	vector_push(v, 0);
	vector_push(v, 0);
	lu_assert_int_eq(vector_size(v), 5);

	vector_push(v, 0);
	vector_push(v, 0);
	vector_push(v, 0);
	lu_assert_int_eq(vector_size(v), 8);

	vector_destroy(v);
}

void t_vector_push_pop_basic() //FTEST
{
	int n = 10;

	Vector* v = vector_new(double);
	for (int i = 0; i < n; i++) vector_push(v, (double) i);
	// iterate and check values
	VectorIterator* vi = vector_get_iterator(v);
	double ckValue = 0.0;
	while (vectorI_has_data(vi))
	{
		double d;
		vectorI_get(vi, d);
		lu_assert_dbl_eq(d, ckValue);
		ckValue += 1.0;
		vectorI_move_next(vi);
	}

	// same, from end to beginning
	ckValue = n - 1;
	vectorI_reset_end(vi);
	while (vectorI_has_data(vi))
	{
		double d;
		vectorI_get(vi, d);
		lu_assert_dbl_eq(d, ckValue);
		ckValue -= 1.0;
		vectorI_move_prev(vi);
	}
	vector_destroy(v);
	vectorI_destroy(vi);
}

void t_vector_push_pop_evolved() //FTEST
{
	int n = 10;

	Vector* v = vector_new(StructTest1);
	StructTest1* st1 = (StructTest1*) malloc(n * sizeof (StructTest1));
	for (int i = 0; i < n; i++)
	{
		st1[i].a = rand() % 42;
		st1[i].b = (double) rand() / RAND_MAX;
		vector_push(v, *(st1 + i));
	}
	for (int i = 0; i < n; i++)
	{
		//another way to access elements
		StructTest1 st1Cell;
		vector_get(v, i, st1Cell);
		lu_assert_int_eq(st1Cell.a, st1[i].a);
		lu_assert_dbl_eq(st1Cell.b, st1[i].b);
	}
	safe_free(st1);
	vector_destroy(v);

	v = vector_new(StructTest2*);
	StructTest2* st2 = (StructTest2*) malloc(n * sizeof (StructTest2));
	for (int i = 0; i < n; i++)
	{
		st2[i].a = (float) rand() / RAND_MAX;
		st2[i].b = (StructTest1*) malloc(sizeof (StructTest1));
		st2[i].b->a = rand() % 42;
		st2[i].b->b = (double) rand() / RAND_MAX;
		vector_push(v, st2 + i);
	}
	for (int i = 0; i < n; i++)
	{
		StructTest2* st2Cell;
		vector_get(v, i, st2Cell);
		lu_assert_dbl_eq(st2Cell->a, st2[i].a);
		lu_assert_int_eq(st2Cell->b->a, st2[i].b->a);
		lu_assert_dbl_eq(st2Cell->b->b, st2[i].b->b);
		safe_free(st2Cell->b);
	}
	safe_free(st2);
	vector_destroy(v);
}

void t_vector_copy() //FTEST
{
	int n = 10;

	Vector* v = vector_new(int);
	for (int i = 0; i < n; i++)
		vector_push(v, rand() % 42);
	Vector* vc = vector_copy(v);

	lu_assert_int_eq(v->size, vc->size);
	int a, b;
	for (int i = 0; i < n; i++)
	{
		vector_get(v, i, a);
		vector_get(vc, i, b);
		lu_assert_int_eq(a, b);
	}
	vector_destroy(v);
	vector_destroy(vc);
}
Commit	Line	Data
a7868768 BA	1	#include <stdlib.h>
	2	#include "cgds/Vector.h"
	3	#include "test/helpers.h"
	4	#include "test/lut.h"
	5
	6	void t_vector_clear() //FTEST
	7	{
	8	Vector* v = vector_new(int);
	9	lu_assert(vector_empty(v));
	10
	11	vector_push(v, 0);
	12	vector_push(v, 0);
	13	vector_push(v, 0);
	14
	15	vector_destroy(v);
	16	v = vector_new(int);
	17
	18	vector_push(v, 0);
	19	vector_push(v, 0);
	20	vector_push(v, 0);
	21
	22	vector_clear(v);
	23	lu_assert(vector_empty(v));
	24
	25	vector_destroy(v);
	26	}
	27
	28	void t_vector_size() //FTEST
	29	{
	30	Vector* v = vector_new(int);
	31	lu_assert(vector_empty(v));
	32
	33	vector_push(v, 0);
	34	vector_push(v, 0);
	35	vector_push(v, 0);
	36	lu_assert_int_eq(vector_size(v), 3);
	37
	38	vector_push(v, 0);
	39	vector_push(v, 0);
	40	lu_assert_int_eq(vector_size(v), 5);
	41
	42	vector_push(v, 0);
	43	vector_push(v, 0);
	44	vector_push(v, 0);
	45	lu_assert_int_eq(vector_size(v), 8);
	46
	47	vector_destroy(v);
	48	}
	49
	50	void t_vector_push_pop_basic() //FTEST
	51	{
	52	int n = 10;
	53
	54	Vector* v = vector_new(double);
	55	for (int i = 0; i < n; i++) vector_push(v, (double) i);
	56	// iterate and check values
	57	VectorIterator* vi = vector_get_iterator(v);
	58	double ckValue = 0.0;
	59	while (vectorI_has_data(vi))
	60	{
	61	double d;
	62	vectorI_get(vi, d);
	63	lu_assert_dbl_eq(d, ckValue);
	64	ckValue += 1.0;
65	vectorI_move_next(vi);
66	}
67
68	// same, from end to beginning
69	ckValue = n - 1;
70	vectorI_reset_end(vi);
71	while (vectorI_has_data(vi))
72	{
73	double d;
74	vectorI_get(vi, d);
75	lu_assert_dbl_eq(d, ckValue);
76	ckValue -= 1.0;
77	vectorI_move_prev(vi);
78	}
79	vector_destroy(v);
80	vectorI_destroy(vi);
81	}
82
83	void t_vector_push_pop_evolved() //FTEST
84	{
85	int n = 10;
86
87	Vector* v = vector_new(StructTest1);
88	StructTest1* st1 = (StructTest1) malloc(n sizeof (StructTest1));
89	for (int i = 0; i < n; i++)
90	{
91	st1[i].a = rand() % 42;
92	st1[i].b = (double) rand() / RAND_MAX;
93	vector_push(v, *(st1 + i));
94	}
95	for (int i = 0; i < n; i++)
96	{
97	//another way to access elements
98	StructTest1 st1Cell;
99	vector_get(v, i, st1Cell);
100	lu_assert_int_eq(st1Cell.a, st1[i].a);
101	lu_assert_dbl_eq(st1Cell.b, st1[i].b);
102	}
103	safe_free(st1);
104	vector_destroy(v);
105
106	v = vector_new(StructTest2*);
107	StructTest2* st2 = (StructTest2) malloc(n sizeof (StructTest2));
108	for (int i = 0; i < n; i++)
109	{
110	st2[i].a = (float) rand() / RAND_MAX;
111	st2[i].b = (StructTest1*) malloc(sizeof (StructTest1));
112	st2[i].b->a = rand() % 42;
113	st2[i].b->b = (double) rand() / RAND_MAX;
114	vector_push(v, st2 + i);
115	}
116	for (int i = 0; i < n; i++)
117	{
118	StructTest2* st2Cell;
119	vector_get(v, i, st2Cell);
120	lu_assert_dbl_eq(st2Cell->a, st2[i].a);
121	lu_assert_int_eq(st2Cell->b->a, st2[i].b->a);
122	lu_assert_dbl_eq(st2Cell->b->b, st2[i].b->b);
123	safe_free(st2Cell->b);
124	}
125	safe_free(st2);
126	vector_destroy(v);
127	}
128
129	void t_vector_copy() //FTEST
130	{
131	int n = 10;
132
133	Vector* v = vector_new(int);
134	for (int i = 0; i < n; i++)
135	vector_push(v, rand() % 42);
136	Vector* vc = vector_copy(v);
137
138	lu_assert_int_eq(v->size, vc->size);
139	int a, b;
140	for (int i = 0; i < n; i++)
141	{
142	vector_get(v, i, a);
143	vector_get(vc, i, b);
144	lu_assert_int_eq(a, b);
145	}
146	vector_destroy(v);
147	vector_destroy(vc);
148	}