diff --git a/tests/core/CMakeLists.txt b/tests/core/CMakeLists.txt
index aa6925eb..23e71495 100644
--- a/tests/core/CMakeLists.txt
+++ b/tests/core/CMakeLists.txt
@@ -12,3 +12,4 @@ core_unit_test(Idle)
 core_unit_test(Database)
 
 add_subdirectory(tags/)
+core_unit_test(Queue)
diff --git a/tests/core/Sconscript b/tests/core/Sconscript
index c60b891d..75a5353c 100644
--- a/tests/core/Sconscript
+++ b/tests/core/Sconscript
@@ -31,7 +31,7 @@ core_objs += [ env.Object("../../core/idle.c")   ]
 core_objs += [ env.Object("../../core/database.c") ]
 
 res += SConscript("tags/Sconscript")
-res += [ CoreTest("queue")      ]
+core_objs += [ env.Object("../../core/queue.c")      ]
 
 res += SConscript("playlists/Sconscript")
 res += [ CoreTest("playlist")   ]
diff --git a/tests/core/queue.c b/tests/core/queue.c
index c7a630f2..de446728 100644
--- a/tests/core/queue.c
+++ b/tests/core/queue.c
@@ -1,6 +1,7 @@
 /*
  * Copyright 2014 (c) Anna Schumaker.
  */
+#include <core/idle.h>
 #include <core/queue.h>
 #include <core/tags/tags.h>
 #include <tests/test.h>
@@ -77,51 +78,21 @@ static const struct queue_ops test_ops = {
 };
 
 
-static void __test_init_core()
-{
-	struct library *library;
-
-	tags_init();
-
-	library = library_find("tests/Music");
-	track_add(library, "tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/02 - Kokiri Forest.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/03 - Hyrule Field.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/04 - Hyrule Castle.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/05 - Lon Lon Ranch.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/06 - Kakariko Village.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/07 - Death Mountain.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/08 - Zora's Domain.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/09 - Gerudo Valley.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/10 - Ganondorf.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/11 - Princess Zelda.ogg");
-	track_add(library, "tests/Music/Hyrule Symphony/12 - Ocarina Medley.ogg");
-	track_add(library,
-		  "tests/Music/Hyrule Symphony/13 - The Legend of Zelda Medley.ogg");
-}
-
-static void __test_deinit_core()
-{
-	tags_deinit();
-}
-
 static void test_init()
 {
 	struct queue q;
 	struct queue_iter it;
 
-	__test_init_core();
-
 	queue_init(&q, 0, NULL, NULL);
-	test_equal(count_init, 0);
-	test_equal(GPOINTER_TO_UINT(q.q_private), 0);
+	g_assert_cmpuint(count_init, ==, 0);
+	g_assert_null(q.q_private);
 
-	test_equal(q.q_cur.it_pos, (unsigned int)-1);
-	test_equal(q.q_flags,  0);
-	test_equal(q.q_length, 0);
-	test_equal((void *)q.q_sort, NULL);
-	test_equal((void *)q.q_ops,  NULL);
-	test_equal((void *)queue_next(&q), (void *)NULL);
+	g_assert_cmpuint(q.q_cur.it_pos, ==, (unsigned int)-1);
+	g_assert_cmpuint(q.q_flags,  ==, 0);
+	g_assert_cmpuint(q.q_length, ==, 0);
+	g_assert_null(q.q_sort);
+	g_assert_null(q.q_ops);
+	g_assert_null(queue_next(&q));
 
 	queue_iter_init(&q, &it);
 	g_assert_null(it.it_iter);
@@ -129,21 +100,21 @@ static void test_init()
 	g_assert_null(queue_iter_val(&it));
 
 	queue_deinit(&q);
-	test_equal(count_deinit, 0);
+	g_assert_cmpuint(count_deinit, ==, 0);
 
 	queue_init(&q, Q_ENABLED | Q_RANDOM, &test_ops, NULL);
-	test_equal(count_init, 1);
-	test_equal(GPOINTER_TO_UINT(q.q_private), 1);
+	g_assert_cmpuint(count_init, ==, 1);
+	g_assert_cmpuint(GPOINTER_TO_UINT(q.q_private), ==, 1);
 
-	test_equal(q.q_cur.it_pos, (unsigned int)-1);
-	test_equal(q.q_flags,  Q_ENABLED | Q_RANDOM);
-	test_equal(q.q_length, 0);
-	test_equal((void *)q.q_sort,   NULL);
-	test_equal((void *)q.q_ops,    (void *)&test_ops);
-	test_equal((void *)queue_next(&q), (void *)NULL);
+	g_assert_cmpuint(q.q_cur.it_pos, ==, (unsigned int)-1);
+	g_assert_cmpuint(q.q_flags,  ==, Q_ENABLED | Q_RANDOM);
+	g_assert_cmpuint(q.q_length, ==, 0);
+	g_assert_null(q.q_sort);
+	g_assert(q.q_ops == &test_ops);
+	g_assert_null(queue_next(&q));
 
 	queue_deinit(&q);
-	test_equal(count_deinit, 1);
+	g_assert_cmpuint(count_deinit, ==, 1);
 }
 
 static void test_flags()
@@ -151,22 +122,22 @@ static void test_flags()
 	struct queue q;
 
 	queue_init(&q, 0, &test_ops, NULL);
-	test_equal(q.q_flags, 0);
-	test_equal(queue_has_flag(&q, Q_ENABLED),    (bool)false);
-	test_equal(queue_has_flag(&q, Q_RANDOM),     (bool)false);
-	test_equal(queue_has_flag(&q, Q_REPEAT),     (bool)false);
-	test_equal(queue_has_flag(&q, Q_NO_SORT),    (bool)false);
-	test_equal(queue_has_flag(&q, Q_SAVE_FLAGS), (bool)false);
-	test_equal(queue_has_flag(&q, Q_SAVE_SORT),  (bool)false);
-	test_equal(queue_has_flag(&q, Q_ADD_FRONT),  (bool)false);
+	g_assert_cmpuint(q.q_flags, ==, 0);
+	g_assert_false(queue_has_flag(&q, Q_ENABLED));
+	g_assert_false(queue_has_flag(&q, Q_RANDOM));
+	g_assert_false(queue_has_flag(&q, Q_REPEAT));
+	g_assert_false(queue_has_flag(&q, Q_NO_SORT));
+	g_assert_false(queue_has_flag(&q, Q_SAVE_FLAGS));
+	g_assert_false(queue_has_flag(&q, Q_SAVE_SORT));
+	g_assert_false(queue_has_flag(&q, Q_ADD_FRONT));
 
 	queue_set_flag(&q, Q_ENABLED);
-	test_equal(q.q_flags,   Q_ENABLED);
-	test_equal(count_flags, 0);
+	g_assert_cmpuint(q.q_flags,   ==, Q_ENABLED);
+	g_assert_cmpuint(count_flags, ==, 0);
 
 	queue_unset_flag(&q, Q_ENABLED);
-	test_equal(q.q_flags,   0);
-	test_equal(count_flags, 0);
+	g_assert_cmpuint(q.q_flags,   ==, 0);
+	g_assert_cmpuint(count_flags, ==, 0);
 
 	queue_set_flag(&q, Q_SAVE_FLAGS);
 	queue_set_flag(&q, Q_ENABLED);
@@ -174,13 +145,13 @@ static void test_flags()
 	queue_set_flag(&q, Q_REPEAT);
 	queue_set_flag(&q, Q_NO_SORT);
 	queue_set_flag(&q, Q_ADD_FRONT);
-	test_equal(queue_has_flag(&q, Q_ENABLED),    (bool)true);
-	test_equal(queue_has_flag(&q, Q_RANDOM),     (bool)true);
-	test_equal(queue_has_flag(&q, Q_REPEAT),     (bool)true);
-	test_equal(queue_has_flag(&q, Q_NO_SORT),    (bool)true);
-	test_equal(queue_has_flag(&q, Q_SAVE_FLAGS), (bool)true);
-	test_equal(queue_has_flag(&q, Q_ADD_FRONT),  (bool)true);
-	test_equal(count_flags, 6);
+	g_assert_true(queue_has_flag(&q, Q_ENABLED));
+	g_assert_true(queue_has_flag(&q, Q_RANDOM));
+	g_assert_true(queue_has_flag(&q, Q_REPEAT));
+	g_assert_true(queue_has_flag(&q, Q_NO_SORT));
+	g_assert_true(queue_has_flag(&q, Q_SAVE_FLAGS));
+	g_assert_true(queue_has_flag(&q, Q_ADD_FRONT));
+	g_assert_cmpuint(count_flags, ==, 6);
 
 	queue_unset_flag(&q, Q_ENABLED);
 	queue_unset_flag(&q, Q_RANDOM);
@@ -188,12 +159,13 @@ static void test_flags()
 	queue_unset_flag(&q, Q_NO_SORT);
 	queue_unset_flag(&q, Q_ADD_FRONT);
 	queue_unset_flag(&q, Q_SAVE_FLAGS);
-	test_equal(q.q_flags,   0);
-	test_equal(count_flags, 11);
+	g_assert_cmpuint(q.q_flags,   ==, 0);
+	g_assert_cmpuint(count_flags, ==, 11);
 }
 
-static void test_stress(unsigned int N)
+static void test_queue(gconstpointer arg)
 {
+	unsigned int N = GPOINTER_TO_UINT(arg);
 	unsigned int ex_length = 0;
 	unsigned int ex_size   = N;
 	struct queue_iter it;
@@ -212,11 +184,11 @@ static void test_stress(unsigned int N)
 	for (i = 0; i < N; i++) {
 		track = track_get(i % 13);
 		ex_length += track->tr_length;
-		test_loop_equal(queue_add(&q, track), i, i);
-		test_loop_equal(count_added,  i + 1, i);
-	} test_loop_passed();
-	test_equal(q.q_length,     ex_length);
-	test_equal(queue_size(&q), ex_size);
+		g_assert_cmpuint(queue_add(&q, track), ==, i);
+		g_assert_cmpuint(count_added, ==, i + 1);
+	}
+	g_assert_cmpuint(q.q_length,     ==, ex_length);
+	g_assert_cmpuint(queue_size(&q), ==, ex_size);
 
 	/* queue_iter_init() */
 	if (N > 0) {
@@ -240,21 +212,21 @@ static void test_stress(unsigned int N)
 	ex_length -= track->tr_length * (N / 13);
 	ex_size   -= (N / 13);
 	if (N > 0)
-		test_equal(queue_has(&q, track), (bool)true);
+		g_assert_true(queue_has(&q, track));
 	else
-		test_equal(queue_has(&q, track), (bool)false);
-	test_equal(queue_remove_all(&q, track), N / 13);
-	test_equal(q.q_length,     ex_length);
-	test_equal(queue_size(&q), ex_size);
-	test_equal(queue_has(&q, track), (bool)false);
+		g_assert_false(queue_has(&q, track));
+	g_assert_cmpuint(queue_remove_all(&q, track), ==, N / 13);
+	g_assert_cmpuint(q.q_length,     ==, ex_length);
+	g_assert_cmpuint(queue_size(&q), ==, ex_size);
+	g_assert_false(queue_has(&q, track));
 
 	/* queue_erase() = false */
 	can_erase = false;
 	for (i = 0; i < ex_size; i += 11) {
 		queue_erase(&q, i);
-		test_loop_equal(q.q_length, ex_length, i);
-		test_loop_equal(queue_size(&q), ex_size, i);
-	} test_loop_passed();
+		g_assert_cmpuint(q.q_length, ==, ex_length);
+		g_assert_cmpuint(queue_size(&q), ==, ex_size);
+	}
 
 	/* queue_remove() and queue_erase() == true */
 	can_erase = true;
@@ -262,34 +234,33 @@ static void test_stress(unsigned int N)
 	ex_length -= track->tr_length * (N / 13);
 	ex_size   -= (N / 13);
 	for (i = 0; i < ex_size; i += 11) {
-		test_loop_equal((void *)queue_at(&q, i), (void *)track, i);
+		g_assert(queue_at(&q, i) == track);
 		if (i % 2 == 0)
 			queue_remove(&q, i);
 		else
 			queue_erase(&q, i);
-	} test_loop_passed();
-	test_equal(q.q_length,     ex_length);
-	test_equal(queue_size(&q), ex_size);
+	}
+	g_assert_cmpuint(q.q_length,     ==, ex_length);
+	g_assert_cmpuint(queue_size(&q), ==, ex_size);
 
 	/* queue_updated() */
 	track = track_get(2);
 	queue_updated(&q, track);
-	test_equal(count_updated, N / 13);
+	g_assert_cmpuint(count_updated, ==, N / 13);
 
-	test_equal((void *)queue_next(&q), NULL);
-	test_equal(queue_size(&q), ex_size);
+	g_assert_null(queue_next(&q));
+	g_assert_cmpint(queue_size(&q), ==, ex_size);
 
 	/* Tracks should not be removed. */
 	queue_set_flag(&q, Q_ENABLED);
 	queue_set_flag(&q, Q_REPEAT);
 	for (i = 0; i < ex_size; i++) {
-		test_loop_equal((void *)queue_next(&q),
-				(void *)track_get((i % 11) + 2), i);
-		test_loop_equal(count_updated, (N / 13) + (2 * i) + 1, i);
+		g_assert(queue_next(&q) == track_get((i % 11) + 2));
+		g_assert_cmpuint(count_updated, ==, (N / 13) + (2 * i) + 1);
 		queue_selected(&q, i);
-		test_loop_equal(count_updated, (N / 13) + (2 * i) + 2, i);
-		test_loop_equal(queue_size(&q), ex_size, i);
-	} test_loop_passed();
+		g_assert_cmpuint(count_updated, ==, (N / 13) + (2 * i) + 2);
+		g_assert_cmpuint(queue_size(&q), ==, ex_size);
+	}
 
 	/* Tracks should be removed. */
 	queue_unset_flag(&q, Q_REPEAT);
@@ -298,26 +269,21 @@ static void test_stress(unsigned int N)
 		ex_length -= track->tr_length;
 		ex_size--;
 
-		test_loop_equal((void *)track,
-				(void *)track_get((i % 11) + 2), i);
-		test_loop_equal(queue_size(&q), ex_size, i);
-		test_loop_equal(q.q_length, ex_length, i);
-	} test_loop_passed();
+		g_assert(track == track_get((i % 11) + 2));
+		g_assert_cmpuint(queue_size(&q), ==, ex_size);
+		g_assert_cmpuint(q.q_length, ==, ex_length);
+	}
 
 	queue_clear(&q);
-	test_equal(count_cleared,  1);
-	test_equal(queue_size(&q), 0);
-	test_equal(q.q_length, 0);
+	g_assert_cmpuint(count_cleared,  ==, 1);
+	g_assert_cmpuint(queue_size(&q), ==, 0);
+	g_assert_cmpuint(q.q_length, ==, 0);
 
 	queue_deinit(&q);
-	test_equal(count_cleared,  2);
-	test_equal((void *)q.q_sort, NULL);
+	g_assert_cmpuint(count_cleared, ==, 2);
+	g_assert_null(q.q_sort);
 }
 
-static void test_basics()      { test_stress(13);     }
-static void test_stress_0()    { test_stress(0);      }
-static void test_stress_100K() { test_stress(100009); }
-
 static void test_rand_select()
 {
 	unsigned int i;
@@ -328,9 +294,9 @@ static void test_rand_select()
 
 	/* Call next() on an empty queue. */
 	for (i = 0; i < 13; i++) {
-		test_loop_equal((void *)queue_next(&q), NULL, i);
-		test_loop_equal(queue_size(&q), 0, i);
-	} test_loop_passed();
+		g_assert_null(queue_next(&q));
+		g_assert_cmpuint(queue_size(&q), ==, 0);
+	}
 
 	for (i = 0; i < 13; i++)
 		queue_add(&q, track_get(i));
@@ -344,60 +310,60 @@ static void test_rand_select()
 	 */
 
 	/* rand() = 9, q = { <>, 1, 2, 3, 4, 5, 6, 7, 8, [9], 10, 11, 12, 13 } */
-	test_equal(queue_next(&q)->tr_track, 9);
-	test_equal(queue_size(&q), 12);
+	g_assert_cmpuint(queue_next(&q)->tr_track, ==, 9);
+	g_assert_cmpuint(queue_size(&q), ==, 12);
 
 	/* select = 6, q = { 1, 2, 3, 4, 5, 6, (7), <8>, 10, 11, 12, 13 } */
-	test_equal(queue_selected(&q, 6)->tr_track, 7);
-	test_equal(queue_size(&q), 11);
+	g_assert_cmpuint(queue_selected(&q, 6)->tr_track, ==, 7);
+	g_assert_cmpuint(queue_size(&q), ==, 11);
 
 	/* rand() = 10, q = { 1, 2, 3, 4, [5], <6>, 8, 10, 11, 12, 13 } */
-	test_equal(queue_next(&q)->tr_track, 5);
-	test_equal(queue_size(&q), 10);
+	g_assert_cmpuint(queue_next(&q)->tr_track, ==, 5);
+	g_assert_cmpuint(queue_size(&q), ==, 10);
 
 	/* select = 7, q = { 1, 2, 3, <4>, 6, 8, 10, (11), 12, 13 } */
-	test_equal(queue_selected(&q, 7)->tr_track, 11);
-	test_equal(queue_size(&q), 9);
+	g_assert_cmpuint(queue_selected(&q, 7)->tr_track, ==, 11);
+	g_assert_cmpuint(queue_size(&q), ==, 9);
 
 	/* rand() = 6, q = { 1, 2, 3, [4], 6, 8, <10>, 12, 13 } */
-	test_equal(queue_next(&q)->tr_track, 4);
-	test_equal(queue_size(&q), 8);
+	g_assert_cmpuint(queue_next(&q)->tr_track, ==, 4);
+	g_assert_cmpuint(queue_size(&q), ==, 8);
 
 	/* select = 2, q = { 1, 2, (<3>), 6, 8, 10, 12, 13 } */
-	test_equal(queue_selected(&q, 2)->tr_track, 3);
-	test_equal(queue_size(&q), 7);
+	g_assert_cmpuint(queue_selected(&q, 2)->tr_track, ==, 3);
+	g_assert_cmpuint(queue_size(&q), ==, 7);
 
 	/* rand() = 1, q = { 1, <2>, [6], 8, 10, 12, 13 } */
-	test_equal(queue_next(&q)->tr_track, 6);
-	test_equal(queue_size(&q), 6);
+	g_assert_cmpuint(queue_next(&q)->tr_track, ==, 6);
+	g_assert_cmpuint(queue_size(&q), ==, 6);
 
 	/* select = 1, q = { 1, (<2>), 8, 10, 12, 13 } */
-	test_equal(queue_selected(&q, 1)->tr_track, 2);
-	test_equal(queue_size(&q), 5);
+	g_assert_cmpuint(queue_selected(&q, 1)->tr_track, ==, 2);
+	g_assert_cmpuint(queue_size(&q), ==, 5);
 
 	/* rand() = 4, q = { <1>, 8, 10, 12, [13] } */
-	test_equal(queue_next(&q)->tr_track, 13);
-	test_equal(queue_size(&q), 4);
+	g_assert_cmpuint(queue_next(&q)->tr_track, ==, 13);
+	g_assert_cmpuint(queue_size(&q), ==, 4);
 
 	/* rand() = 1, q = { [1], 8, 10, <12> } */
-	test_equal(queue_next(&q)->tr_track, 1);
-	test_equal(queue_size(&q), 3);
+	g_assert_cmpuint(queue_next(&q)->tr_track, ==, 1);
+	g_assert_cmpuint(queue_size(&q), ==, 3);
 
 	/* select = 1, q = { <>, 8, (10), 12 } */
-	test_equal(queue_selected(&q, 1)->tr_track, 10);
-	test_equal(queue_size(&q), 2);
+	g_assert_cmpuint(queue_selected(&q, 1)->tr_track, ==, 10);
+	g_assert_cmpuint(queue_size(&q), ==, 2);
 
 	/* rand() = 1, q = { <8>, [12] } */
-	test_equal(queue_next(&q)->tr_track, 12);
-	test_equal(queue_size(&q), 1);
+	g_assert_cmpuint(queue_next(&q)->tr_track, ==, 12);
+	g_assert_cmpuint(queue_size(&q), ==, 1);
 
 	/* select = 0, q = { (<8>) } */
-	test_equal(queue_selected(&q, 0)->tr_track, 8);
-	test_equal(queue_size(&q), 0);
+	g_assert_cmpuint(queue_selected(&q, 0)->tr_track, ==, 8);
+	g_assert_cmpuint(queue_size(&q), ==, 0);
 
 	/* q = { } */
-	test_equal((void *)queue_next(&q), NULL);
-	test_equal((void *)queue_selected(&q, 3), NULL);
+	g_assert_null(queue_next(&q));
+	g_assert_null(queue_selected(&q, 3));
 
 	queue_deinit(&q);
 }
@@ -420,54 +386,54 @@ static void test_sorting()
 
 	for (i = 0; i < 13; i++) {
 		track = queue_at(&q, i);
-		test_loop_not_equal((void *)track, NULL, i);
-		test_loop_equal(track->tr_dbe.dbe_index, 12 - i, i);
-	} test_loop_passed();
-	test_equal(count_sort, 0);
+		g_assert_nonnull(track);
+		g_assert_cmpuint(track->tr_dbe.dbe_index, ==, 12 - i);
+	}
+	g_assert_cmpuint(count_sort, ==, 0);
 
 	queue_sort(&q, COMPARE_TRACK, true);
 	for (i = 0; i < 13; i++) {
 		track = queue_at(&q, i);
-		test_loop_not_equal((void *)track, NULL, i);
-		test_loop_equal(track->tr_track, i + 1, i);
-	} test_loop_passed();
-	test_equal(count_sort, 1);
+		g_assert_nonnull(track);
+		g_assert_cmpuint(track->tr_track, ==, i + 1);
+	}
+	g_assert_cmpuint(count_sort, ==, 1);
 
 	queue_sort(&q, COMPARE_COUNT, true);
 	for (i = 0; i < 13; i++) {
 		track = queue_at(&q, i);
-		test_loop_not_equal((void *)track, NULL, i);
-		test_loop_equal(track->tr_track, ex_count[i], i);
-	} test_loop_passed();
-	test_equal(count_sort, 2);
+		g_assert_nonnull(track);
+		g_assert_cmpuint(track->tr_track, ==, ex_count[i]);
+	}
+	g_assert_cmpuint(count_sort, ==, 2);
 
 	queue_set_flag(&q, Q_NO_SORT);
 	queue_sort(&q, COMPARE_TITLE, true);
 	for (i = 0; i < 13; i++) {
 		track = queue_at(&q, i);
-		test_loop_not_equal((void *)track, NULL, i);
-		test_loop_equal(track->tr_track, ex_count[i], i);
-	} test_loop_passed();
-	test_equal(count_sort, 2);
+		g_assert_nonnull(track);
+		g_assert_cmpuint(track->tr_track, ==, ex_count[i]);
+	}
+	g_assert_cmpuint(count_sort, ==, 2);
 
 	queue_unset_flag(&q, Q_NO_SORT);
 	queue_sort(&q, COMPARE_TITLE, true);
 	for (i = 0; i < 13; i++) {
 		track = queue_at(&q, i);
-		test_loop_not_equal((void *)track, NULL, i);
-		test_loop_equal(track->tr_track, ex_title[i], i);
-	} test_loop_passed();
-	test_equal(count_sort, 3);
+		g_assert_nonnull(track);
+		g_assert_cmpuint(track->tr_track, ==, ex_title[i]);
+	}
+	g_assert_cmpuint(count_sort, ==, 3);
 
 	queue_sort(&q, COMPARE_COUNT, true);
 	queue_sort(&q, COMPARE_TITLE, false);
 	queue_sort(&q, COMPARE_COUNT, false);
 	for (i = 0; i < 13; i++) {
 		track = queue_at(&q, i);
-		test_loop_not_equal((void *)track, NULL, i);
-		test_loop_equal(track->tr_track, ex_co_ti[i], i);
-	} test_loop_passed();
-	test_equal(count_sort, 6);
+		g_assert_nonnull(track);
+		g_assert_cmpuint(track->tr_track, ==, ex_co_ti[i]);
+	}
+	g_assert_cmpuint(count_sort, ==, 6);
 
 	queue_unset_flag(&q, Q_SAVE_SORT);
 	queue_sort(&q, COMPARE_ARTIST, true);
@@ -476,15 +442,15 @@ static void test_sorting()
 	queue_sort(&q, COMPARE_TRACK,  false);
 	for (i = 0; i < 13; i++) {
 		track = queue_at(&q, i);
-		test_loop_not_equal((void *)track, NULL, i);
-		test_loop_equal(track->tr_track, 13 - i, i);
-	} test_loop_passed();
-	test_equal(count_sort, 6);
+		g_assert_nonnull(track);
+		g_assert_cmpuint(track->tr_track, ==, 13 - i);
+	}
+	g_assert_cmpuint(count_sort, ==, 6);
 
 	queue_deinit(&q);
-	test_equal(q.q_length,       0);
-	test_equal(queue_size(&q),   0);
-	test_equal((void *)q.q_sort, NULL);
+	g_assert_cmpuint(q.q_length,    ==, 0);
+	g_assert_cmpuint(queue_size(&q),==, 0);
+	g_assert_null(q.q_sort);
 }
 
 static void test_save_load()
@@ -499,31 +465,58 @@ static void test_save_load()
 	for (i = 0; i < 13; i++)
 		queue_add(&q, track_get(i));
 
-	test_equal(file_exists(&f), (bool)false);
-	test_equal(file_open(&f, OPEN_WRITE), (bool)true);
+	g_assert_false(file_exists(&f));
+	g_assert_true(file_open(&f, OPEN_WRITE));
 	queue_save_tracks(&q, &f);
 	file_close(&f);
-	test_equal(file_exists(&f), (bool)true);
+	g_assert_true(file_exists(&f));
 
-	test_equal(file_open(&f, OPEN_READ), (bool)true);
+	g_assert_true(file_open(&f, OPEN_READ));
 	queue_load_tracks(&r, &f);
 	file_close(&f);
 
-	test_equal(queue_size(&r), 13);
-	for (i = 0; i < 13; i++) {
-		test_loop_equal(queue_has(&r, track_get(i)), (bool)true, i);
-	} test_loop_passed();
-
-	__test_deinit_core();
+	g_assert_cmpuint(queue_size(&r), ==, 13);
+	for (i = 0; i < 13; i++)
+		g_assert_true(queue_has(&r, track_get(i)));
 }
 
-DECLARE_UNIT_TESTS(
-	UNIT_TEST("Queue Initialization", test_init),
-	UNIT_TEST("Queue Flags", test_flags),
-	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 Random Next and Selection", test_rand_select),
-	UNIT_TEST("Queue Sorting", test_sorting),
-	UNIT_TEST("Queue Save and Load", test_save_load),
-);
+int main(int argc, char **argv)
+{
+	struct library *library;
+	int ret;
+
+	idle_init_sync();
+	tags_init();
+	while (idle_run_task()) {}
+
+	library = library_find("tests/Music");
+	track_add(library, "tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/02 - Kokiri Forest.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/03 - Hyrule Field.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/04 - Hyrule Castle.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/05 - Lon Lon Ranch.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/06 - Kakariko Village.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/07 - Death Mountain.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/08 - Zora's Domain.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/09 - Gerudo Valley.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/10 - Ganondorf.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/11 - Princess Zelda.ogg");
+	track_add(library, "tests/Music/Hyrule Symphony/12 - Ocarina Medley.ogg");
+	track_add(library,
+		  "tests/Music/Hyrule Symphony/13 - The Legend of Zelda Medley.ogg");
+
+	g_test_init(&argc, &argv, NULL);
+	g_test_add_func("/Core/Queue/Initialization", test_init);
+	g_test_add_func("/Core/Queue/Flags", test_flags);
+	g_test_add_data_func("/Core/Queue/n = 0",        GUINT_TO_POINTER(     0), test_queue);
+	g_test_add_data_func("/Core/Queue/n = 13",       GUINT_TO_POINTER(    13), test_queue);
+	g_test_add_data_func("/Core/Queue/n = 100,009)", GUINT_TO_POINTER(100009), test_queue);
+	g_test_add_func("/Core/Queue/Random Next and Selection", test_rand_select);
+	g_test_add_func("/Core/Queue/Sorting", test_sorting);
+	g_test_add_func("/Core/Queue/Save and Load", test_save_load);
+	ret = g_test_run();
+
+	tags_deinit();
+	idle_deinit();
+	return ret;
+}