ocarina/tests/queue.cpp

/*
 * Copyright 2014 (c) Anna Schumaker.
 */
#include <callback.h>
#include <queue.h>
#include <tags.h>
#include "test.h"


unsigned int count_add = 0;
unsigned int count_del = 0;
unsigned int count_updated = 0;
unsigned int last_update = 0;


class TestQueue : public Queue
{
public:
	TestQueue() : Queue() {}
	TestQueue(unsigned int f) : Queue(f) {}
	unsigned int get_cur()    { return _cur;    }
	unsigned int get_flags()  { return _flags;  }
	unsigned int get_length() { return _length; }
	std::list <sort_info> get_sorder() { return _sort_order; };
};

void test_add_cb_noop(Queue *q, unsigned int id) { }


void test_default()
{
	TestQueue q;

	test :: equal(q.get_cur(),    (unsigned)-1);
	test :: equal(q.get_flags(),  (unsigned)0);
	test :: equal(q.get_length(), (unsigned)0);
	test :: equal(q.get_sorder().size(), (size_t)0);
	test :: equal(q.next(), (Track *)NULL);
}

void test_constructor(unsigned int flags)
{
	TestQueue q(flags | (1 << 30));

	test :: equal(q.get_cur(),    (unsigned)-1);
	test :: equal(q.get_flags(),  flags);
	test :: equal(q.get_length(), (unsigned)0);
	test :: equal(q.get_sorder().size(), (size_t)0);
	test :: equal(q.next(), (Track *)NULL);
}

void test_flags()
{
	TestQueue q(0);

	test :: equal(q.get_flags(), (unsigned)0);

	q.set_flag(Q_ENABLED);
	test :: equal(q.get_flags(), (unsigned)Q_ENABLED);

	q.unset_flag(Q_ENABLED);
	test :: equal(q.get_flags(), (unsigned)0);

	q.set_flag(Q_REPEAT);
	q.set_flag(Q_RANDOM);
	test :: equal(q.has_flag(Q_ENABLED), false);
	test :: equal(q.has_flag(Q_RANDOM), true);
	test :: equal(q.has_flag(Q_REPEAT), true);
	test :: equal(q.has_flag(Q_NO_SORT), false);
}

void test_add_cb(Queue *q, unsigned int id)
{
	check_equal(id, count_add);
	count_add++;
}

void test_del_cb(Queue *q, unsigned int id)
{
	if (count_del % 2 == 0)
		check_equal(id, (unsigned)0);
	else
		check_equal(id, 24 - ((count_del + 1) / 2));
	count_del++;
}

void test_del_cb2(Queue *q, unsigned int id)
{
	check_equal(id, 23 - count_del);
	count_del++;
}

void test_del_cb3(Queue *q, unsigned int id)
{
	check_equal(id, (unsigned)0);
}

void test_add_remove()
{
	Track *track;
	TestQueue q(0);
	unsigned int expected = 0;

	get_callbacks()->on_queue_track_add = test_add_cb;
	get_callbacks()->on_queue_track_del = test_del_cb;


	/* Add tracks */
	test :: begin();
	for (unsigned int i = 0; i < 24; i++) {
		check_equal(q.add(tagdb :: lookup(i)), i);
		expected += 100 + (i * 10);
	}
	test :: success();
	test_equal(q.get_length(), expected);


	/* Add everything again */
	test :: begin();
	for (unsigned int i = 0; i < 24; i++) {
		check_equal(q.add(tagdb :: lookup(i)), i + 24);
		expected += 100 + (i * 10);
	}
	test :: success();
	test_equal(q.get_length(), expected);
	test_equal(q.size(), (unsigned)48);


	/* Test removing multiple tracks at once */
	test :: begin();
	for (unsigned int i = 0; i < 12; i++) {
		track = tagdb :: lookup(i);
		q.del(track);
		expected -= 2 * (100 + (i * 10));
	}
	test :: success();
	test_equal(q.get_length(), expected);
	test_equal(q.size(), (unsigned)24);


	/* Test removing tracks one at a time */
	count_del = 0;
	get_callbacks()->on_queue_track_del = test_del_cb2;

	test :: begin();
	for (unsigned int i = 23; i >= 12; i--) {
		expected -= q[i]->length;
		q.del(i);
	}
	test :: success();
	test_equal(q.get_length(), expected);
	test_equal(q.size(), (unsigned)12);


	/* Remove remaining tracks */
	get_callbacks()->on_queue_track_del = test_del_cb3;

	test :: begin();
	while (q.size() > 0)
		q.del((unsigned)0);
	test :: success();
	test_equal(q.get_length(), (unsigned)0);
	test_equal(q.size(), (unsigned)0);
}

void test_updated_cb(Queue *q, unsigned int row)
{
	last_update = row;
}

void test_updated_cb2(Queue *q, unsigned int row)
{
	switch (row) {
	case 0:
	case 24:
	case 25:
		count_updated++;
	default:
		break;
	}
}

void test_updated()
{
	Track *track;
	TestQueue q(0);

	get_callbacks()->on_queue_track_add = test_add_cb_noop;
	get_callbacks()->on_queue_track_changed = test_updated_cb;

	/* Add tracks */
	test :: begin();
	for (unsigned int i = 0; i < 24; i++)
		check_equal(q.add(tagdb :: lookup(i)), i);
	test :: success();

	test :: begin();
	for (unsigned int i = 0; i < 24; i++)
		q.updated(tagdb :: lookup(i));
	test :: success();

	get_callbacks()->on_queue_track_changed = test_updated_cb2;
	track = tagdb :: lookup(0);
	q.add(track);
	q.add(track);
	q.updated(track);
	test_equal(count_updated, (unsigned)3);
}

int main(int argc, char **argv)
{
	test :: cp_library();
	tagdb :: init();

	run_test("Queue Default Constructor Test", test_default);
	run_test("Queue Constructor Test", test_constructor, Q_ENABLED | Q_RANDOM);
	run_test("Queue Flag Test", test_flags);
	run_test("Queue Add and Remove Test", test_add_remove);
	run_test("Queue Track Updated Test", test_updated);
	return 0;
}