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

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

void t_queue_clear() //FTEST
{
	Queue* q = queue_new(int);

	queue_push(q, 0);
	queue_push(q, 0);
	queue_push(q, 0);

	queue_clear(q);
	lu_assert(queue_empty(q));

	queue_destroy(q);
}

void t_queue_size() //FTEST
{
	Queue* q = queue_new(int);

	queue_push(q, 0);
	queue_push(q, 0);
	queue_push(q, 0);
	lu_assert_int_eq(queue_size(q), 3);

	queue_push(q, 0);
	queue_push(q, 0);
	lu_assert_int_eq(queue_size(q), 5);

	queue_push(q, 0);
	queue_push(q, 0);
	queue_push(q, 0);
	lu_assert_int_eq(queue_size(q), 8);

	queue_destroy(q);
}

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

	Queue* q = queue_new(double);
	for (int i = 0; i < n; i++) queue_push(q, (double) i);
	// iterate and check values
	double ckValue = 0.0;
	while (!queue_empty(q))
	{
		double d;
		queue_peek(q, d);
		lu_assert_dbl_eq(d, ckValue);
		ckValue += 1.0;
		queue_pop(q);
	}

	lu_assert(queue_empty(q));
	queue_destroy(q);
}

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

	Queue* q = queue_new(StructTest1);
	StructTest1* st1 = (StructTest1*) safe_malloc(n * sizeof (StructTest1));
	for (int i = 0; i < n; i++)
	{
		st1[i].a = rand() % 42;
		st1[i].b = (double) rand() / RAND_MAX;
		queue_push(q, *(st1 + i));
	}
	for (int i = 0; i < n; i++)
	{
		StructTest1 st1Cell;
		queue_peek(q, st1Cell);
		lu_assert_int_eq(st1Cell.a, st1[i].a);
		lu_assert_dbl_eq(st1Cell.b, st1[i].b);
		queue_pop(q);
	}
	safe_free(st1);
	queue_destroy(q);

	q = queue_new(StructTest2*);
	StructTest2* st2 = (StructTest2*) safe_malloc(n * sizeof (StructTest2));
	for (int i = 0; i < n; i++)
	{
		st2[i].a = (float) rand() / RAND_MAX;
		st2[i].b = (StructTest1*) safe_malloc(sizeof (StructTest1));
		st2[i].b->a = rand() % 42;
		st2[i].b->b = (double) rand() / RAND_MAX;
		queue_push(q, st2 + i);
	}
	for (int i = 0; i < n; i++)
	{
		StructTest2* st2Cell;
		queue_peek(q, 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);
		queue_pop(q);
		safe_free(st2Cell->b);
	}
	safe_free(st2);
	queue_destroy(q);
}

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

	Queue* q = queue_new(int);
	for (int i = 0; i < n; i++)
		queue_push(q, rand() % 42);
	Queue* qc = queue_copy(q);

	lu_assert_int_eq(q->size, qc->size);
	int a, b;
	for (int i = 0; i < n; i++)
	{
		queue_peek(q, a);
		queue_peek(qc, b);
		lu_assert_int_eq(a, b);
		queue_pop(q);
		queue_pop(qc);
	}
	queue_destroy(q);
	queue_destroy(qc);
}
Commit	Line	Data
	1	#include <stdlib.h>
	2	#include "cgds/Queue.h"
	3	#include "test/helpers.h"
	4	#include "test/lut.h"
	5
	6	void t_queue_clear() //FTEST
	7	{
	8	Queue* q = queue_new(int);
	9
	10	queue_push(q, 0);
	11	queue_push(q, 0);
	12	queue_push(q, 0);
	13
	14	queue_clear(q);
	15	lu_assert(queue_empty(q));
	16
	17	queue_destroy(q);
	18	}
	19
	20	void t_queue_size() //FTEST
	21	{
	22	Queue* q = queue_new(int);
	23
	24	queue_push(q, 0);
	25	queue_push(q, 0);
	26	queue_push(q, 0);
	27	lu_assert_int_eq(queue_size(q), 3);
	28
	29	queue_push(q, 0);
	30	queue_push(q, 0);
	31	lu_assert_int_eq(queue_size(q), 5);
	32
	33	queue_push(q, 0);
	34	queue_push(q, 0);
	35	queue_push(q, 0);
	36	lu_assert_int_eq(queue_size(q), 8);
	37
	38	queue_destroy(q);
	39	}
	40
	41	void t_queue_push_pop_basic() //FTEST
	42	{
	43	int n = 10;
	44
	45	Queue* q = queue_new(double);
	46	for (int i = 0; i < n; i++) queue_push(q, (double) i);
	47	// iterate and check values
	48	double ckValue = 0.0;
	49	while (!queue_empty(q))
	50	{
	51	double d;
	52	queue_peek(q, d);
	53	lu_assert_dbl_eq(d, ckValue);
	54	ckValue += 1.0;
	55	queue_pop(q);
	56	}
	57
	58	lu_assert(queue_empty(q));
	59	queue_destroy(q);
	60	}
	61
	62	void t_queue_push_pop_evolved() //FTEST
	63	{
	64	int n = 10;
	65
	66	Queue* q = queue_new(StructTest1);
	67	StructTest1* st1 = (StructTest1) safe_malloc(n sizeof (StructTest1));
	68	for (int i = 0; i < n; i++)
	69	{
	70	st1[i].a = rand() % 42;
	71	st1[i].b = (double) rand() / RAND_MAX;
	72	queue_push(q, *(st1 + i));
	73	}
	74	for (int i = 0; i < n; i++)
	75	{
	76	StructTest1 st1Cell;
	77	queue_peek(q, st1Cell);
	78	lu_assert_int_eq(st1Cell.a, st1[i].a);
	79	lu_assert_dbl_eq(st1Cell.b, st1[i].b);
	80	queue_pop(q);
	81	}
	82	safe_free(st1);
	83	queue_destroy(q);
	84
	85	q = queue_new(StructTest2*);
	86	StructTest2* st2 = (StructTest2) safe_malloc(n sizeof (StructTest2));
	87	for (int i = 0; i < n; i++)
	88	{
	89	st2[i].a = (float) rand() / RAND_MAX;
	90	st2[i].b = (StructTest1*) safe_malloc(sizeof (StructTest1));
	91	st2[i].b->a = rand() % 42;
	92	st2[i].b->b = (double) rand() / RAND_MAX;
	93	queue_push(q, st2 + i);
	94	}
	95	for (int i = 0; i < n; i++)
	96	{
	97	StructTest2* st2Cell;
	98	queue_peek(q, st2Cell);
	99	lu_assert_dbl_eq(st2Cell->a, st2[i].a);
	100	lu_assert_int_eq(st2Cell->b->a, st2[i].b->a);
	101	lu_assert_dbl_eq(st2Cell->b->b, st2[i].b->b);
	102	queue_pop(q);
	103	safe_free(st2Cell->b);
	104	}
	105	safe_free(st2);
	106	queue_destroy(q);
	107	}
	108
	109	void t_queue_copy() //FTEST
	110	{
	111	int n = 10;
	112
	113	Queue* q = queue_new(int);
	114	for (int i = 0; i < n; i++)
	115	queue_push(q, rand() % 42);
	116	Queue* qc = queue_copy(q);
	117
	118	lu_assert_int_eq(q->size, qc->size);
	119	int a, b;
	120	for (int i = 0; i < n; i++)
	121	{
	122	queue_peek(q, a);
	123	queue_peek(qc, b);
	124	lu_assert_int_eq(a, b);
	125	queue_pop(q);
	126	queue_pop(qc);
	127	}
	128	queue_destroy(q);
	129	queue_destroy(qc);
	130	}