ocarina/tests/core/containers/queue.c

/*
 * Copyright 2015 (c) Anna Schumaker.
 */
#include <core/containers/queue.h>
#include <tests/test.h>

static unsigned int data_val = 0;

static inline unsigned int test_q_first(struct _queue *queue)
{
	return GPOINTER_TO_INT(g_queue_peek_head(&queue->_queue));
}

static inline unsigned int test_q_last(struct _queue *queue)
{
	return GPOINTER_TO_INT(g_queue_peek_tail(&queue->_queue));
}

static inline unsigned int test_q_iter_val(struct _q_iter *it)
{
	return GPOINTER_TO_INT(_q_iter_val(it));
}

static int test_sort_int(gconstpointer a, gconstpointer b, gpointer data)
{
	data_val = GPOINTER_TO_INT(data);
	return GPOINTER_TO_INT(a) - GPOINTER_TO_INT(b);
}

static void test_stress(unsigned int N)
{
	struct _queue queue = _Q_INIT();
	struct _q_iter it;
	unsigned int i;

	/* _q_init() */
	test_equal((void *)queue._queue.head, NULL);
	test_equal((void *)queue._queue.tail, NULL);
	test_equal(_q_size(&queue), 0);

	/* _q_add_head() */
	for (i = 0; i < N; i++) {
		test_loop_equal(_q_add_head(&queue, GINT_TO_POINTER(i)), 0, i);
		test_loop_equal(_q_size(&queue), i + 1, i);
		test_loop_equal(test_q_first(&queue), i, i);
	} test_loop_passed();
	test_equal(_q_size(&queue), N);

	/* _q_add_tail() */
	for (i = 0; i < N; i++) {
		test_loop_equal(_q_add_tail(&queue, GINT_TO_POINTER(i)), N + i, i);
		test_loop_equal(_q_size(&queue), N + i + 1, i);
		test_loop_equal(test_q_last(&queue), i, i);
	} test_loop_passed();
	test_equal(_q_size(&queue), 2 * N);

	/* _q_iter_set() */
	for (i = 0; i < (2 * N); i += N) {
		_q_iter_set(&queue, &it, i);
		test_loop_not_equal((void *)it.it_iter, NULL, i);
		test_loop_equal(it.it_pos, i, i);
		if (i == N) {
			test_loop_equal(test_q_iter_val(&it), 0, i);
		} else {
			test_loop_equal(test_q_iter_val(&it), N - 1, i);
		}
	} test_loop_passed();

	/* _q_for_each() */
	i = 0;
	_q_for_each(&queue, &it) {
		test_loop_not_equal((void *)it.it_iter, NULL, i);
		test_loop_equal(it.it_pos, i, i);
		if (i < N) {
			test_loop_equal(test_q_iter_val(&it), N - (i + 1), i);
		} else {
			test_loop_equal(test_q_iter_val(&it), i - N, i);
		}
		i++;
	} test_loop_passed();

	/* _q_remove_it() (last N items) */
	_q_iter_set(&queue, &it, 2 * N - 1);
	for (i = 0; i < N; i++) {
		test_loop_not_equal((void *)it.it_iter, NULL, i);
		test_loop_equal(it.it_pos, (2 * N) - (i + 1), i);
		test_loop_equal(GPOINTER_TO_INT(_q_remove_it(&queue, &it)), N - (i + 1), i);
	} test_loop_passed();
	test_equal(_q_size(&queue), N);

	/* _q_remove_it() (half of remaining items) */
	for (i = 0; i < (N / 2); i++) {
		_q_iter_set(&queue, &it, 0);
		test_loop_not_equal((void *)it.it_iter, NULL, i);
		test_loop_equal(it.it_pos, 0, i);
		test_loop_equal(GPOINTER_TO_INT(_q_remove_it(&queue, &it)), N - (i + 1), i);
	} test_loop_passed();
	test_equal(_q_size(&queue), N / 2);

	/* _q_clear() (remaining items) */
	_q_clear(&queue);
	test_equal(_q_size(&queue), 0);
	test_equal((void *)queue._queue.head, NULL);
	test_equal((void *)queue._queue.tail, NULL);
	test_equal(queue._queue.length, 0);
}

static void test_basics()      { test_stress(10);     }
static void test_stress_0()    { test_stress(0);      }
static void test_stress_100K() { test_stress(100000); }

void test_sort()
{
	struct _queue queue = _Q_INIT();
	unsigned int i, N = 10;
	struct _q_iter it;

	/* _q_add_sorted() (10 .. 19) */
	for (i = 0; i < N; i++) {
		test_loop_equal(_q_add_sorted(&queue, GINT_TO_POINTER(i + 10),
					      test_sort_int,
					      GINT_TO_POINTER(42)), i, i);
	} test_loop_passed();
	test_equal(_q_size(&queue), N);
	test_equal(data_val, 42);

	/* _q_add_sorted() (0 .. 9) */
	for (i = 0; i < N; i++) {
		test_loop_equal(_q_add_sorted(&queue, GINT_TO_POINTER(i),
					      test_sort_int,
					      GINT_TO_POINTER(43)), i, i);
	} test_loop_passed();
	test_equal(_q_size(&queue), 2 * N);
	test_equal(data_val, 43);

	/* _q_sort(), after reversing the queue. */
	g_queue_reverse(&queue._queue);
	_q_sort(&queue, test_sort_int, GINT_TO_POINTER(44));

	i = 0;
	_q_for_each(&queue, &it) {
		test_loop_equal(test_q_iter_val(&it), i, i);
		i++;
	} test_loop_passed();
	test_equal(data_val, 44);

	g_queue_clear(&queue._queue);
}

DECLARE_UNIT_TESTS(
	UNIT_TEST("Queue Basics", test_basics),
	UNIT_TEST("Queue Stress (N = 0)", test_stress_0),
	UNIT_TEST("Queue Stress (N = 100,000)", test_stress_100K),
	UNIT_TEST("Queue Sorting", test_sort),
);