diff --git a/core/tags/track.c b/core/tags/track.c
index ce433097..c9458983 100644
--- a/core/tags/track.c
+++ b/core/tags/track.c
@@ -57,7 +57,7 @@ struct db_entry *track_alloc(const gchar *key)
 	fullpath = library_file(library, path);
 	file     = taglib_file_new(fullpath);
 	if (!file || !taglib_file_is_valid(file)) {
-		printf("WARNING: Could not read tags for: %s\n", fullpath);
+		g_printerr("WARNING: Could not read tags for: %s\n", fullpath);
 		goto out;
 	}
 
diff --git a/tests/core/tags/CMakeLists.txt b/tests/core/tags/CMakeLists.txt
index 2f806772..bcf499ff 100644
--- a/tests/core/tags/CMakeLists.txt
+++ b/tests/core/tags/CMakeLists.txt
@@ -8,3 +8,4 @@ tag_unit_test(Artist)
 tag_unit_test(Album)
 tag_unit_test(Genre)
 tag_unit_test(Library)
+tag_unit_test(Track)
diff --git a/tests/core/tags/Sconscript b/tests/core/tags/Sconscript
index 24cf77cc..55db7df1 100644
--- a/tests/core/tags/Sconscript
+++ b/tests/core/tags/Sconscript
@@ -15,8 +15,7 @@ core_objs += [ env.Object("../../../core/tags/artist.c")  ]
 core_objs += [ env.Object("../../../core/tags/album.c")   ]
 core_objs += [ env.Object("../../../core/tags/genre.c")   ]
 core_objs += [ env.Object("../../../core/tags/library.c") ]
-core_objs += [ env.Object("../../../core/tags/tags.c") ]
-
-res += [ TagTest("track")   ]
+core_objs += [ env.Object("../../../core/tags/tags.c")    ]
+core_objs += [ env.Object("../../../core/tags/track.c")   ]
 
 Return("res")
diff --git a/tests/core/tags/track.c b/tests/core/tags/track.c
index b9fc5bb5..143530e7 100644
--- a/tests/core/tags/track.c
+++ b/tests/core/tags/track.c
@@ -12,18 +12,20 @@
 static struct track *test_alloc(const gchar *key)
 {
 	const struct db_ops *track_ops = test_track_ops();
-	return TRACK(track_ops->dbe_alloc(key));
+	struct db_entry *dbe = track_ops->dbe_alloc(key);
+	g_assert_nonnull(dbe);
+	return TRACK(dbe);
 }
 
 static void test_verify_tags(struct track *track)
 {
-	test_equal(track->tr_album->al_name,   "Hyrule Symphony");
-	test_equal(track->tr_album->al_year,   1998);
-	test_equal(track->tr_artist->ar_name,  "Koji Kondo");
-	test_equal(track->tr_genre->ge_name,   "Game");
-	test_equal((void *)track->tr_album->al_artist, (void *)track->tr_artist);
-	test_equal((void *)track->tr_album->al_genre,  (void *)track->tr_genre);
-	test_equal(track->tr_library->li_path, "tests/Music");
+	g_assert_cmpstr(track->tr_album->al_name,  ==, "Hyrule Symphony");
+	g_assert_cmpuint(track->tr_album->al_year, ==, 1998);
+	g_assert_cmpstr(track->tr_artist->ar_name, ==, "Koji Kondo");
+	g_assert_cmpstr(track->tr_genre->ge_name,  ==,  "Game");
+	g_assert(track->tr_album->al_artist == track->tr_artist);
+	g_assert(track->tr_album->al_genre  == track->tr_genre);
+	g_assert_cmpstr(track->tr_library->li_path, ==, "tests/Music");
 }
 
 static void test_verify_track(struct track *track)
@@ -31,20 +33,20 @@ static void test_verify_track(struct track *track)
 	const struct db_ops *track_ops = test_track_ops();
 	test_verify_tags(track);
 
-	test_equal(track->tr_title, "Title Theme");
-	test_equal(track->tr_tokens[0], "title");
-	test_equal(track->tr_tokens[1], "theme");
-	test_equal((void *)track->tr_tokens[2], NULL);
-	test_equal((void *)track->tr_alts[0], NULL);
-	test_equal(track_ops->dbe_key(&track->tr_dbe),
+	g_assert_cmpstr(track->tr_title, ==, "Title Theme");
+	g_assert_cmpstr(track->tr_tokens[0], ==, "title");
+	g_assert_cmpstr(track->tr_tokens[1], ==, "theme");
+	g_assert_null(track->tr_tokens[2]);
+	g_assert_null(track->tr_alts[0]);
+	g_assert_cmpstr(track_ops->dbe_key(&track->tr_dbe), ==,
 			"0/Hyrule Symphony/01 - Title Theme.ogg");
-	test_str_equal(track_path(track),
+	g_assert_cmpstr_free(track_path(track), ==,
 			"tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
-	test_str_equal(track_last_play(track), "Never");
+	g_assert_cmpstr_free(track_last_play(track), ==, "Never");
 
-	test_equal(track->tr_track,  1);
-	test_equal(track->tr_length, 243);
-	test_equal(track->tr_count,  0);
+	g_assert_cmpuint(track->tr_track,  ==, 1);
+	g_assert_cmpuint(track->tr_length, ==, 243);
+	g_assert_cmpuint(track->tr_count,  ==, 0);
 }
 
 static void test_verify_notrack(struct track *track)
@@ -52,18 +54,18 @@ static void test_verify_notrack(struct track *track)
 	const struct db_ops *track_ops = test_track_ops();
 	test_verify_tags(track);
 
-	test_equal(track->tr_title, "");
-	test_equal((void *)track->tr_tokens[0], NULL);
-	test_equal((void *)track->tr_alts[0], NULL);
-	test_equal(track_ops->dbe_key(&track->tr_dbe),
+	g_assert_cmpstr(track->tr_title, ==, "");
+	g_assert_null(track->tr_tokens[0]);
+	g_assert_null(track->tr_alts[0]);
+	g_assert_cmpstr(track_ops->dbe_key(&track->tr_dbe), ==,
 			"0/Hyrule Symphony/00 - No Track.ogg");
-	test_str_equal(track_path(track),
+	g_assert_cmpstr_free(track_path(track), ==,
 			"tests/Music/Hyrule Symphony/00 - No Track.ogg");
-	test_str_equal(track_last_play(track), "Never");
+	g_assert_cmpstr_free(track_last_play(track), ==, "Never");
 
-	test_equal(track->tr_track,  0);
-	test_equal(track->tr_length, 0);
-	test_equal(track->tr_count,  0);
+	g_assert_cmpuint(track->tr_track,  ==, 0);
+	g_assert_cmpuint(track->tr_length, ==, 0);
+	g_assert_cmpuint(track->tr_count,  ==, 0);
 }
 
 static void test_track()
@@ -76,24 +78,20 @@ static void test_track()
 	struct file f;
 	gchar *date;
 
-	setlocale(LC_TIME, "C");
-	idle_init_sync();
-	tags_init();
 	file_init(&f, "track_tag", 0, 0);
-	while (idle_run_task()) {}
-
 	date    = string_tm2str(now);
 	library = library_find("tests/Music");
 
 	track = test_alloc("0/Hyrule Symphony/01 - Title Theme.ogg");
+	g_assert_nonnull(track);
 	track->tr_dbe.dbe_index = 0;
 	track_ops->dbe_setup(&track->tr_dbe);
 	test_verify_track(track);
-	test_equal(library->li_size, 1);
+	g_assert_cmpuint(library->li_size, ==, 1);
 
-	test_equal(track_match_token(track, "title"),  (bool)true);
-	test_equal(track_match_token(track, "theme"),  (bool)true);
-	test_equal(track_match_token(track, "hyrule"), (bool)false);
+	g_assert_true( track_match_token(track, "title"));
+	g_assert_true( track_match_token(track, "theme"));
+	g_assert_false(track_match_token(track, "hyrule"));
 
 	file_open(&f, OPEN_WRITE);
 	file_writef(&f, "0 0 0 0 0 0 0 0 0 0 \n");
@@ -103,14 +101,14 @@ static void test_track()
 
 	g_free(track->tr_path);
 	track_ops->dbe_free(&track->tr_dbe);
-	test_equal(library->li_size, 0);
+	g_assert_cmpuint(library->li_size, ==, 0);
 
 	file_open(&f, OPEN_READ);
 	track = TRACK(track_ops->dbe_read(&f));
 	track->tr_dbe.dbe_index = 0;
 	track_ops->dbe_setup(&track->tr_dbe);
 	test_verify_notrack(track);
-	test_equal(library->li_size, 1);
+	g_assert_cmpuint(library->li_size, ==, 1);
 
 	g_free(track->tr_path);
 	track_ops->dbe_free(&track->tr_dbe);
@@ -119,12 +117,12 @@ static void test_track()
 	track->tr_dbe.dbe_index = 0;
 	track_ops->dbe_setup(&track->tr_dbe);
 	test_verify_track(track);
-	test_equal(library->li_size, 1);
+	g_assert_cmpuint(library->li_size, ==, 1);
 	file_close(&f);
 
 	track_played(track);
-	test_equal(track->tr_count, 1);
-	test_str_equal(track_last_play(track), date);
+	g_assert_cmpuint(track->tr_count, ==, 1);
+	g_assert_cmpstr_free(track_last_play(track), ==, date);
 
 	g_free(track->tr_path);
 	track_ops->dbe_free(&track->tr_dbe);
@@ -135,73 +133,74 @@ static void test_track_compare()
 {
 	const struct db_ops *track_ops = test_track_ops();
 	struct track  *title = test_alloc("0/Hyrule Symphony/01 - Title Theme.ogg");
-	struct track *kokiri = test_alloc("0/Hyrule Symphony/02 - Kokiri Forest.ogg");
+	struct track *kokiri = test_alloc("0/Ocarina of Time/05 - Kokiri Forest.ogg");
 
 	/* Compare artists. */
 	title->tr_artist = artist_find("Hajime Wakai");
-	test_equal(track_compare(title,  title,  COMPARE_ARTIST),  0);
-	test_equal(track_compare(kokiri, title,  COMPARE_ARTIST),  1);
-	test_equal(track_compare(title,  kokiri, COMPARE_ARTIST), -1);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_ARTIST), ==,  0);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_ARTIST), ==,  1);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_ARTIST), ==, -1);
+	title->tr_artist = artist_find("Koji Kondo");
 
 	/* Compare albums. */
-	kokiri->tr_album = album_find("Ocarina of Time", 1996);
-	test_equal(track_compare(title,  title,  COMPARE_ALBUM),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_ALBUM), -1);
-	test_equal(track_compare(kokiri, title,  COMPARE_ALBUM),  1);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_ALBUM), ==,  0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_ALBUM), ==, -1);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_ALBUM), ==,  1);
 
 	/* Compare play counts. */
 	title->tr_count = 42;
-	test_equal(track_compare(title,  title,  COMPARE_COUNT),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_COUNT),  42);
-	test_equal(track_compare(kokiri, title,  COMPARE_COUNT), -42);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_COUNT), ==,   0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_COUNT), ==,  42);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_COUNT), ==, -42);
 	title->tr_count = 0;
 
 	/* Compare genres. */
 	kokiri->tr_genre = genre_find("Video Game");
-	test_equal(track_compare(title,  title,  COMPARE_GENRE),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_GENRE), -1);
-	test_equal(track_compare(kokiri, title,  COMPARE_GENRE),  1);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_GENRE), ==,  0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_GENRE), ==, -1);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_GENRE), ==,  1);
 
 	/* Compare lenghts (title = 243, kokiri = 130). */
-	test_equal(track_compare(title,  title,  COMPARE_LENGTH),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_LENGTH),  113);
-	test_equal(track_compare(kokiri, title,  COMPARE_LENGTH), -113);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_LENGTH), ==,    0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_LENGTH), ==,  131);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_LENGTH), ==, -131);
 
 	/* Compare last played dates. */
 	date_set(&kokiri->tr_date, 0, 0, 17);
-	test_equal(track_compare(title,  title,  COMPARE_PLAYED),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_PLAYED), -17);
-	test_equal(track_compare(kokiri, title,  COMPARE_PLAYED),  17);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_PLAYED), ==,   0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_PLAYED), ==, -17);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_PLAYED), ==,  17);
 
 	date_set(&kokiri->tr_date, 0, 6, 17);
-	test_equal(track_compare(title,  title,  COMPARE_PLAYED),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_PLAYED), -6);
-	test_equal(track_compare(kokiri, title,  COMPARE_PLAYED),  6);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_PLAYED), ==,  0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_PLAYED), ==, -6);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_PLAYED), ==,  6);
 
 	date_set(&kokiri->tr_date, 1988, 6, 17);
-	test_equal(track_compare(title,  title,  COMPARE_PLAYED),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_PLAYED), -1988);
-	test_equal(track_compare(kokiri, title,  COMPARE_PLAYED),  1988);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_PLAYED), ==,     0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_PLAYED), ==, -1988);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_PLAYED), ==,  1988);
 
 	/* Compare titles. */
-	test_equal(track_compare(title,  title,  COMPARE_TITLE),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_TITLE),  1);
-	test_equal(track_compare(kokiri, title,  COMPARE_TITLE), -1);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_TITLE), ==,  0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_TITLE), ==,  1);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_TITLE), ==, -1);
 
 	/* Compare track numbers. */
-	test_equal(track_compare(title,  title,  COMPARE_TRACK),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_TRACK), -1);
-	test_equal(track_compare(kokiri, title,  COMPARE_TRACK),  1);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_TRACK), ==,  0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_TRACK), ==, -4);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_TRACK), ==,  4);
 
 	/* Compare years. */
-	test_equal(track_compare(title,  title,  COMPARE_YEAR),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_YEAR),  2);
-	test_equal(track_compare(kokiri, title,  COMPARE_YEAR), -2);
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_YEAR), ==,  0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_YEAR), ==, -1);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_YEAR), ==,  1);
 
-	kokiri->tr_album->al_year = title->tr_album->al_year;
-	test_equal(track_compare(title,  title,  COMPARE_YEAR),  0);
-	test_equal(track_compare(title,  kokiri, COMPARE_YEAR), -1);
-	test_equal(track_compare(kokiri, title,  COMPARE_YEAR),  1);
+	title->tr_album->al_year += 2;
+	g_assert_cmpint(track_compare(title,  title,  COMPARE_YEAR), ==,  0);
+	g_assert_cmpint(track_compare(title,  kokiri, COMPARE_YEAR), ==,  2);
+	g_assert_cmpint(track_compare(kokiri, title,  COMPARE_YEAR), ==, -2);
+	title->tr_album->al_year -= 2;
 
 	g_free(title->tr_path);
 	g_free(kokiri->tr_path);
@@ -209,7 +208,7 @@ static void test_track_compare()
 	track_ops->dbe_free(&kokiri->tr_dbe);
 }
 
-static void test_track_db()
+static void __test_track_db_subprocess()
 {
 	const gchar *path = "tests/Music/Hyrule Symphony/01 - Title Theme.ogg";
 	struct library *library = library_find("tests/Music");
@@ -217,84 +216,107 @@ static void test_track_db()
 	struct database track_db;
 	struct track *track;
 
-	test_equal(track_db_count_unplayed(), 0);
-	test_equal(track_db_count_plays(), 0);
-	test_equal(track_db_average_plays(), 0);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 0);
+	g_assert_cmpuint(track_db_count_plays(), ==, 0);
+	g_assert_cmpuint(track_db_average_plays(), ==, 0);
 	track = track_add(library, path);
 	test_verify_track(track);
-	test_equal(track_db_count_unplayed(), 1);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
 
-	test_equal((void *)track_add(library, path), NULL);
-	test_equal((void *)track_get(0), (void *)track);
-	test_equal((void *)track_get(1), NULL);
-	test_equal(track_db_get()->db_size, 1);
-	test_equal(track_db_count_unplayed(), 1);
+	g_assert_null(track_add(library, path));
+	g_assert(track_get(0) == track);
+	g_assert_null(track_get(1));
+	g_assert_cmpuint(track_db_get()->db_size, ==, 1);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
 
 	db_init(&track_db, "track.db", false, track_ops);
 	db_load(&track_db);
-	test_equal(track_db.db_size, 0);
+	g_assert_cmpuint(track_db.db_size, ==, 0);
 
 	track_db_commit();
 	db_load(&track_db);
-	test_equal(track_db.db_size, 1);
+	g_assert_cmpuint(track_db.db_size, ==, 1);
 	test_verify_track(TRACK(db_first(&track_db)));
 	/* Make sure our unplayed count isn't skewed */
 	db_deinit(&track_db);
 
 	track_remove(track);
-	test_equal(track_db_get()->db_size, 0);
-	test_equal(track_db_count_unplayed(), 0);
+	g_assert_cmpuint(track_db_get()->db_size, ==, 0);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 0);
 
 	track = track_add(library, path);
-	test_not_equal((void *)track, NULL);
+	g_assert_nonnull(track);
 
 	track = track_add(library,
 			  "tests/Music/Hyrule Symphony/02 - Kokiri Forest.ogg");
-	test_not_equal((void *)track, NULL);
-	test_equal(track_db_get()->db_size, 2);
-	test_equal(track_db_count_unplayed(), 2);
+	g_assert_nonnull(track);
+	g_assert_cmpuint(track_db_get()->db_size, ==, 2);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 2);
 
-	test_equal(track_db_count_plays(), 0);
-	test_equal(track_db_average_plays(), 0);
+	g_assert_cmpuint(track_db_count_plays(), ==, 0);
+	g_assert_cmpuint(track_db_average_plays(), ==, 0);
 	track_played(track);
-	test_equal(track_db_count_unplayed(), 1);
-	test_equal(track_db_count_plays(), 1);
-	test_equal(track_db_average_plays(), 1);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
+	g_assert_cmpuint(track_db_count_plays(), ==, 1);
+	g_assert_cmpuint(track_db_average_plays(), ==, 1);
 	track_played(track);
-	test_equal(track_db_count_unplayed(), 1);
-	test_equal(track_db_count_plays(), 2);
-	test_equal(track_db_average_plays(), 2);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
+	g_assert_cmpuint(track_db_count_plays(), ==, 2);
+	g_assert_cmpuint(track_db_average_plays(), ==, 2);
 
 	track = track_add(library, "tests/Music/invalid_track");
-	test_equal((void *)track, NULL);
-	test_equal(track_db_get()->db_size, 2);
-	test_equal(track_db_count_unplayed(), 1);
+	g_assert_null(track);
+	g_assert_cmpuint(track_db_get()->db_size, ==, 2);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
 
 	/* Reload the database */
 	track_db_deinit();
-	test_equal(track_db_count_unplayed(), 0);
-	test_equal(track_db_count_plays(), 0);
-	test_equal(track_db_get()->db_size, 0);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 0);
+	g_assert_cmpuint(track_db_count_plays(), ==, 0);
+	g_assert_cmpuint(track_db_get()->db_size, ==, 0);
 	track_db_init();
 	while (idle_run_task()) {};
-	test_equal(track_db_get()->db_size, 2);
-	test_equal(track_db_count_unplayed(), 1);
-	test_equal(track_db_count_plays(), 2);
-	test_equal(track_db_average_plays(), 2);
+	g_assert_cmpuint(track_db_get()->db_size, ==, 2);
+	g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
+	g_assert_cmpuint(track_db_count_plays(), ==, 2);
+	g_assert_cmpuint(track_db_average_plays(), ==, 2);
 
 	track_remove(track_get(2));
-	test_equal(track_db_count_plays(), 0);
-	test_equal(track_db_average_plays(), 0);
+	g_assert_cmpuint(track_db_count_plays(), ==, 0);
+	g_assert_cmpuint(track_db_average_plays(), ==, 0);
 
 	track_remove_all(library);
-	test_equal(track_db_get()->db_size, 0);
+	g_assert_cmpuint(track_db_get()->db_size, ==, 0);
+}
+
+static void test_track_db()
+{
+	if (g_test_subprocess()) {
+		__test_track_db_subprocess();
+		return;
+	}
+
+	g_test_trap_subprocess(NULL, 0, 0);
+	g_test_trap_assert_passed();
+	g_test_trap_assert_stderr("*WARNING: Could not read tags for:*");
+}
+
+int main(int argc, char **argv)
+{
+	int ret;
+
+	setlocale(LC_TIME, "C");
+	idle_init_sync();
+	tags_init();
+	while (idle_run_task()) {}
+
+	g_test_init(&argc, &argv, NULL);
+	g_test_add_func("/Core/Tags/Track", test_track);
+	g_test_add_func("/Core/Tags/Track/Comparison", test_track_compare);
+	g_test_add_func("/Core/Tags/Track/Database", test_track_db);
+	ret = g_test_run();
 
 	tags_deinit();
 	idle_deinit();
+	return ret;
 }
-
-DECLARE_UNIT_TESTS(
-	UNIT_TEST("Track Tag", test_track),
-	UNIT_TEST("Track Comparison", test_track_compare),
-	UNIT_TEST("Track Database", test_track_db),
-);