410 lines
9.2 KiB
C++
410 lines
9.2 KiB
C++
/*
|
|
* Copyright 2014 (c) Anna Schumaker.
|
|
*/
|
|
#include <core/callback.h>
|
|
#include <core/queue.h>
|
|
#include <core/random.h>
|
|
#include <core/tags/tags.h>
|
|
#include <tests/test.h>
|
|
|
|
|
|
unsigned int count_add = 0;
|
|
unsigned int count_del = 0;
|
|
unsigned int count_updated = 0;
|
|
unsigned int last_update = 0;
|
|
unsigned int expected = 0;
|
|
Track *TRACK_NULL = NULL;
|
|
|
|
|
|
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::vector <sort_info> get_sorder() { return _sort_order; };
|
|
};
|
|
|
|
TestQueue *Q = NULL, *R = NULL;
|
|
void test_add_cb_noop(Queue *q, unsigned int id) { }
|
|
void test_del_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 = Q_ENABLED | Q_RANDOM;
|
|
TestQueue q(flags);
|
|
|
|
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)
|
|
{
|
|
count_add++;
|
|
}
|
|
|
|
void test_del_cb(Queue *q, unsigned int id)
|
|
{
|
|
count_del++;
|
|
}
|
|
|
|
|
|
unsigned int _test_add_loop(unsigned int i)
|
|
{
|
|
Track *track = tags :: get_track(i % 24);
|
|
unsigned int index = Q->add(track);
|
|
expected += track->length();
|
|
if (index != i)
|
|
return LOOP_FAILED;
|
|
if ((index + 1) != count_add)
|
|
return LOOP_FAILED;
|
|
return LOOP_PASSED;
|
|
}
|
|
|
|
unsigned int _test_del_loop(unsigned int i)
|
|
{
|
|
Track *track = tags :: get_track(i);
|
|
unsigned int j = (i + 1) * 2;
|
|
|
|
Q->del(track);
|
|
expected -= track->length() * 2;
|
|
if (count_del != j)
|
|
return LOOP_FAILED;
|
|
return LOOP_PASSED;
|
|
}
|
|
|
|
unsigned int _test_del_middle_loop(unsigned int i)
|
|
{
|
|
unsigned int j = 23 - i;
|
|
expected -= (*Q)[j]->length();
|
|
Q->del(j);
|
|
return (count_del == (i + 1)) ? LOOP_PASSED : LOOP_FAILED;
|
|
}
|
|
|
|
unsigned int _test_del_front_loop(unsigned int i)
|
|
{
|
|
expected -= (*Q)[0]->length();
|
|
Q->del((unsigned int)0);
|
|
return (count_del == (i + 1)) ? LOOP_PASSED : LOOP_FAILED;
|
|
}
|
|
|
|
void test_add_remove()
|
|
{
|
|
TestQueue q(0);
|
|
Q = &q;
|
|
|
|
get_callbacks()->on_queue_track_add = test_add_cb;
|
|
get_callbacks()->on_queue_track_del = test_del_cb;
|
|
|
|
test_equal(q.get_length(), expected);
|
|
test_equal(q.length_str(), (std::string)"");
|
|
test_equal(q.size(), (unsigned)0);
|
|
test_equal(q.size_str(), (std::string)"0");
|
|
|
|
|
|
/* Add tracks */
|
|
test_for_each(0, 24, 1, _test_add_loop);
|
|
test_equal(q.get_length(), expected);
|
|
test_equal(q.length_str(), (std::string)"1 hour, 26 minutes");
|
|
test_equal(q.size(), (unsigned)24);
|
|
test_equal(q.size_str(), (std::string)"24");
|
|
|
|
|
|
/* Add everything again */
|
|
test_for_each(24, 48, 1, _test_add_loop);
|
|
test_equal(q.get_length(), expected);
|
|
test_equal(q.length_str(), (std::string)"2 hours, 52 minutes");
|
|
test_equal(q.size(), (unsigned)48);
|
|
test_equal(q.size_str(), (std::string)"48");
|
|
|
|
|
|
/* Test removing multiple tracks at once */
|
|
count_del = 0;
|
|
test_for_each(0, 12, 1, _test_del_loop);
|
|
test_equal(q.get_length(), expected);
|
|
test_equal(q.length_str(), (std::string)"1 hour, 50 minutes");
|
|
test_equal(q.size(), (unsigned)24);
|
|
test_equal(q.size_str(), (std::string)"24");
|
|
|
|
|
|
/* Test removing tracks one at a time */
|
|
count_del = 0;
|
|
test_for_each(0, 12, 1, _test_del_middle_loop);
|
|
test_equal(q.get_length(), expected);
|
|
test_equal(q.length_str(), (std::string)"55 minutes");
|
|
test_equal(q.size(), (unsigned)12);
|
|
test_equal(q.size_str(), (std::string)"12");
|
|
|
|
|
|
/* Remove remaining tracks */
|
|
count_del = 0;
|
|
test_for_each(0, 12, 1, _test_del_front_loop);
|
|
test_equal(q.get_length(), (unsigned)0);
|
|
test_equal(q.length_str(), (std::string)"");
|
|
test_equal(q.size(), (unsigned)0);
|
|
test_equal(q.size_str(), (std::string)"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;
|
|
}
|
|
}
|
|
|
|
static void test_fill_q()
|
|
{
|
|
for (unsigned int i = 0; i < 24; i++)
|
|
Q->add(tags :: get_track(i));
|
|
}
|
|
|
|
unsigned int _test_update_loop(unsigned int i)
|
|
{
|
|
Q->updated(tags :: get_track(i));
|
|
return (last_update == i) ? LOOP_PASSED : LOOP_FAILED;
|
|
}
|
|
|
|
void test_updated()
|
|
{
|
|
Track *track;
|
|
TestQueue q(0);
|
|
|
|
Q = &q;
|
|
get_callbacks()->on_queue_track_add = test_add_cb_noop;
|
|
get_callbacks()->on_queue_track_changed = test_updated_cb;
|
|
|
|
test_fill_q();
|
|
test_for_each(0, 24, 1, _test_update_loop);
|
|
|
|
get_callbacks()->on_queue_track_changed = test_updated_cb2;
|
|
track = tags :: get_track(0);
|
|
q.add(track);
|
|
q.add(track);
|
|
q.updated(track);
|
|
test_equal(count_updated, (unsigned)3);
|
|
}
|
|
|
|
unsigned int expected_rand[] = { 1, 4, 8, 13, 19, 3, 14, 16, 20, 2, 11, 17,
|
|
23, 6, 12, 18, 0, 5, 9, 10, 15, 21, 22, 7 };
|
|
|
|
|
|
unsigned int _test_next_loop(unsigned int i)
|
|
{
|
|
Track *track = Q->next();
|
|
if (track == TRACK_NULL)
|
|
return LOOP_FAILED;
|
|
return (track->index() == (i % 24)) ? LOOP_PASSED : LOOP_FAILED;
|
|
}
|
|
|
|
unsigned int _test_next_rand_loop(unsigned int i)
|
|
{
|
|
Track *track = Q->next();
|
|
if (track == TRACK_NULL)
|
|
return LOOP_FAILED;
|
|
return (track->index() == expected_rand[i]) ? LOOP_PASSED : LOOP_FAILED;
|
|
}
|
|
|
|
void test_next()
|
|
{
|
|
TestQueue q(0);
|
|
|
|
Q = &q;
|
|
get_callbacks()->on_queue_track_del = test_del_cb_noop;
|
|
test_fill_q();
|
|
|
|
test_for_each(0, 24, 1, _test_next_loop);
|
|
test_equal(q.size(), (unsigned)0);
|
|
test_equal(q.length_str(), (std::string)"");
|
|
test_equal(q.next(), TRACK_NULL);
|
|
|
|
|
|
q.set_flag(Q_RANDOM);
|
|
random_seed(0);
|
|
test_fill_q();
|
|
|
|
test_for_each(0, 24, 1, _test_next_rand_loop);
|
|
test_equal(q.size(), (unsigned)0);
|
|
test_equal(q.length_str(), (std::string)"");
|
|
test_equal(q.next(), TRACK_NULL);
|
|
|
|
|
|
q.set_flag(Q_REPEAT);
|
|
q.unset_flag(Q_RANDOM);
|
|
test_fill_q();
|
|
|
|
test_for_each(0, 48, 1, _test_next_loop);
|
|
test_equal(q.size(), (unsigned)24);
|
|
}
|
|
|
|
void test_select()
|
|
{
|
|
TestQueue q(0);
|
|
|
|
Q = &q;
|
|
test_fill_q();
|
|
|
|
test_equal(q.size(), (unsigned)24);
|
|
q.track_selected(10);
|
|
test_equal(q.size(), (unsigned)23);
|
|
test_equal(q.next()->index(), (unsigned)11);
|
|
|
|
q.set_flag(Q_REPEAT);
|
|
q.track_selected(0);
|
|
test_equal(q.size(), (unsigned)22);
|
|
test_equal(q.next()->index(), (unsigned)1);
|
|
}
|
|
|
|
|
|
unsigned int exp_sort_title[] = { 1, 18, 19, 16, 20, 8, 2, 9, 23, 10, 17, 11,
|
|
3, 21, 4, 0, 5, 22, 6, 12, 7, 13, 14, 15 };
|
|
unsigned int exp_sort_ye_ti[] = { 0, 3, 2, 1, 7, 6, 5, 4, 11, 10, 9, 8,
|
|
17, 16, 19, 18, 22, 21, 23, 20, 15, 14, 13, 12 };
|
|
|
|
unsigned int _test_sort_title(unsigned int i)
|
|
{
|
|
if ((*Q)[i]->index() == exp_sort_title[i])
|
|
return LOOP_PASSED;
|
|
return LOOP_FAILED;
|
|
}
|
|
|
|
unsigned int _test_sort_title_reverse(unsigned int i)
|
|
{
|
|
if ((*Q)[i]->index() == exp_sort_title[23 - i])
|
|
return LOOP_PASSED;
|
|
return LOOP_FAILED;
|
|
}
|
|
|
|
unsigned int _test_sort_index(unsigned int i)
|
|
{
|
|
if ((*Q)[i]->index() == i)
|
|
return LOOP_PASSED;
|
|
return LOOP_FAILED;
|
|
}
|
|
|
|
unsigned int _test_sort_ye_ti(unsigned int i)
|
|
{
|
|
if ((*Q)[i]->index() != exp_sort_ye_ti[i])
|
|
return LOOP_FAILED;
|
|
return LOOP_PASSED;
|
|
}
|
|
|
|
void test_sorting()
|
|
{
|
|
TestQueue q(0);
|
|
|
|
Q = &q;
|
|
q.sort(SORT_TITLE, true);
|
|
test_equal(q.get_sorder().size(), (size_t)1);
|
|
test_fill_q();
|
|
test_for_each(0, 24, 1, _test_sort_title);
|
|
|
|
q.sort(SORT_TITLE, false);
|
|
test_equal(q.get_sorder().size(), (size_t)1);
|
|
test_for_each(0, 24, 1, _test_sort_title_reverse);
|
|
|
|
q.sort(SORT_LENGTH, true);
|
|
test_for_each(0, 1, 24, _test_sort_index);
|
|
|
|
q.sort(SORT_YEAR, true);
|
|
q.sort(SORT_TITLE, false);
|
|
q.sort(SORT_TITLE, false);
|
|
test_equal(q.get_sorder().size(), (size_t)2);
|
|
test_for_each(0, 24, 1, _test_sort_ye_ti);
|
|
}
|
|
|
|
|
|
unsigned int _test_saving_loop(unsigned int i)
|
|
{
|
|
if ((*Q)[i]->index() == (*R)[i]->index())
|
|
return LOOP_PASSED;
|
|
return LOOP_FAILED;
|
|
}
|
|
|
|
void test_saving()
|
|
{
|
|
TestQueue q(Q_RANDOM);
|
|
TestQueue r(0);
|
|
File f("test.q", 0);
|
|
|
|
Q = &q;
|
|
R = &r;
|
|
test_fill_q();
|
|
|
|
f.open(OPEN_WRITE);
|
|
q.write(f);
|
|
f.close();
|
|
|
|
f.open(OPEN_READ);
|
|
r.read(f);
|
|
f.close();
|
|
|
|
test_equal(r.has_flag(Q_RANDOM), q.has_flag(Q_RANDOM));
|
|
test_equal(r.size(), q.size());
|
|
test_equal(r.size_str(), q.size_str());
|
|
test_equal(r.length_str(), q.length_str());
|
|
test_for_each(0, 24, 1, _test_saving_loop);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
test :: cp_data_dir();
|
|
tags :: init();
|
|
|
|
test :: run("Queue Default Constructor Test", test_default);
|
|
test :: run("Queue Constructor Test", test_constructor);
|
|
test :: run("Queue Flag Test", test_flags);
|
|
test :: run("Queue Add and Remove Test", test_add_remove);
|
|
test :: run("Queue Track Updated Test", test_updated);
|
|
test :: run("Queue Pick Next Test", test_next);
|
|
test :: run("Queue Select Track Test", test_select);
|
|
test :: run("Queue Sorting Test", test_sorting);
|
|
test :: run("Queue Save and Load Test", test_saving);
|
|
return 0;
|
|
}
|