From c67d09740cafc203f498c40e9a8eca7917e3d477 Mon Sep 17 00:00:00 2001 From: Anna Schumaker Date: Fri, 13 May 2016 11:25:43 -0400 Subject: [PATCH] tests: Build core/playlists/system test with ctest I initially tried making several helper functions to reuse code and make it easier to add new playlists. This didn't work all that well, mostly because glib wasn't able to expand variable values or find the line number that errors occured on. Macros don't have this problem, since they are expanded at compile time. Signed-off-by: Anna Schumaker --- core/playlist.c | 3 +- tests/core/CMakeLists.txt | 2 + tests/core/playlists/CMakeLists.txt | 7 + tests/core/playlists/Sconscript | 2 +- tests/core/playlists/system.c | 366 +++++++++++++++------------- 5 files changed, 207 insertions(+), 173 deletions(-) create mode 100644 tests/core/playlists/CMakeLists.txt diff --git a/core/playlist.c b/core/playlist.c index c7a0692d..0fc92589 100644 --- a/core/playlist.c +++ b/core/playlist.c @@ -81,7 +81,8 @@ void playlist_set_random(enum playlist_type_t type, const gchar *name, bool playlist_get_random(enum playlist_type_t type, const gchar *name) { - return queue_has_flag(playlist_get_queue(type, name), Q_RANDOM); + struct queue *queue = playlist_get_queue(type, name); + return queue ? queue_has_flag(queue, Q_RANDOM) : false; } void playlist_sort(enum playlist_type_t type, const gchar *name, diff --git a/tests/core/CMakeLists.txt b/tests/core/CMakeLists.txt index 23e71495..29587cff 100644 --- a/tests/core/CMakeLists.txt +++ b/tests/core/CMakeLists.txt @@ -13,3 +13,5 @@ core_unit_test(Database) add_subdirectory(tags/) core_unit_test(Queue) + +add_subdirectory(playlists/) diff --git a/tests/core/playlists/CMakeLists.txt b/tests/core/playlists/CMakeLists.txt new file mode 100644 index 00000000..a9a3364f --- /dev/null +++ b/tests/core/playlists/CMakeLists.txt @@ -0,0 +1,7 @@ +Include(../../UnitTest.cmake) + +function(playlist_unit_test name) + unit_test(Core/Playlists ${name} corelib ${corefiles}) +endfunction() + +playlist_unit_test(System) diff --git a/tests/core/playlists/Sconscript b/tests/core/playlists/Sconscript index 844d7c19..20266806 100644 --- a/tests/core/playlists/Sconscript +++ b/tests/core/playlists/Sconscript @@ -11,7 +11,7 @@ def PlaylistTest(name): return run core_objs += [ env.Object("../../../core/playlists/generic.c") ] -res += [ PlaylistTest("system") ] +core_objs += [ env.Object("../../../core/playlists/system.c") ] res += [ PlaylistTest("artist") ] res += [ PlaylistTest("library") ] diff --git a/tests/core/playlists/system.c b/tests/core/playlists/system.c index ffd6ecac..22d3ea6a 100644 --- a/tests/core/playlists/system.c +++ b/tests/core/playlists/system.c @@ -2,204 +2,207 @@ * Copyright 2016 (c) Anna Schumaker. */ #include -#include +#include #include #include -#define __test_playlist_state(queue, ex_size, ex_track0, ex_track1) \ - test_equal(queue_size(queue), ex_size); \ - test_equal(queue_has(queue, track_get(0)), (bool)ex_track0); \ - test_equal(queue_has(queue, track_get(1)), (bool)ex_track1) -#define __test_playlist_random(name, queue) \ - test_equal(queue_has_flag(queue, Q_RANDOM), (bool)false); \ - pl_system.pl_set_flag(name, Q_RANDOM, true); \ - test_equal(queue_has_flag(queue, Q_RANDOM), (bool)true); \ - pl_system.pl_set_flag(name, Q_RANDOM, false); \ - test_equal(queue_has_flag(queue, Q_RANDOM), (bool)false); \ +#define __test_playlist_has(name, track, expected) \ + if (expected) \ + g_assert_true(playlist_has(PL_SYSTEM, name, track)); \ + else \ + g_assert_false(playlist_has(PL_SYSTEM, name, track)) -#define __test_playlist_add(name, queue) \ - __test_playlist_state(queue, 0, false, false); \ - test_equal(pl_system.pl_add_track(name, track_get(0)), (bool)true); \ - test_equal(pl_system.pl_add_track(name, track_get(0)), (bool)false); \ - test_equal(pl_system.pl_add_track(name, track_get(1)), (bool)true); \ - test_equal(pl_system.pl_add_track(name, track_get(1)), (bool)false); \ - __test_playlist_state(queue, 2, true, true) +#define __test_playlist_state(name, ex_size, ex_track0, ex_track1) \ + g_assert_cmpuint(playlist_size(PL_SYSTEM, name), ==, ex_size); \ + __test_playlist_has(name, track_get(0), ex_track0); \ + __test_playlist_has(name, track_get(1), ex_track1) -#define __test_playlist_remove(name, queue) \ - test_equal(pl_system.pl_remove_track(name, track_get(0)), (bool)true); \ - test_equal(pl_system.pl_remove_track(name, track_get(0)), (bool)false); \ - test_equal(pl_system.pl_remove_track(name, track_get(1)), (bool)true); \ - test_equal(pl_system.pl_remove_track(name, track_get(1)), (bool)false); \ - __test_playlist_state(queue, 0, false, false) +#define __test_playlist_random(name) \ + g_assert_false(playlist_get_random(PL_SYSTEM, name)); \ + playlist_set_random(PL_SYSTEM, name, true); \ + g_assert_true(playlist_get_random(PL_SYSTEM, name)); \ + playlist_set_random(PL_SYSTEM, name, false); \ + g_assert_false(playlist_get_random(PL_SYSTEM, name)) -#define __test_playlist_update(name, queue, ex_size, ex_track0, ex_track1) \ - pl_system.pl_update(name); \ - while (idle_run_task()) {}; \ - __test_playlist_state(queue, ex_size, ex_track0, ex_track1) +#define __test_playlist_add(name) \ + __test_playlist_state(name, 0, false, false); \ + g_assert_true( playlist_add(PL_SYSTEM, name, track_get(0))); \ + g_assert_false(playlist_add(PL_SYSTEM, name, track_get(0))); \ + g_assert_true( playlist_add(PL_SYSTEM, name, track_get(1))); \ + g_assert_false(playlist_add(PL_SYSTEM, name, track_get(1))); \ + __test_playlist_state(name, 2, true, true) -#define __test_playlist_hide_track(name, queue, ex_size, ex_track0, ex_track1) \ - test_equal(pl_system.pl_add_track("Hidden", track_get(0)), (bool)true); \ - __test_playlist_state(queue, ex_size, ex_track0, ex_track1); \ - test_equal(pl_system.pl_add_track(name, track_get(0)), (bool)false) +#define __test_playlist_remove(name) \ + g_assert_true( playlist_remove(PL_SYSTEM, name, track_get(0))); \ + g_assert_false(playlist_remove(PL_SYSTEM, name, track_get(0))); \ + g_assert_true( playlist_remove(PL_SYSTEM, name, track_get(1))); \ + g_assert_false(playlist_remove(PL_SYSTEM, name, track_get(1))); \ + __test_playlist_state(name, 0, false, false) -#define __test_playlist_unhide_track(name, queue, ex_size, ex_track0, ex_track1) \ - test_equal(pl_system.pl_remove_track("Hidden", track_get(0)), (bool)true); \ - __test_playlist_state(queue, ex_size, ex_track0, ex_track1) +#define __test_playlist_update(name, ex_size, ex_track0, ex_track1) \ + playlist_update(PL_SYSTEM, name); \ + while (idle_run_task()) {}; \ + __test_playlist_state(name, ex_size, ex_track0, ex_track1) -#define __test_playlist_reinit(queue, ex_size, ex_track0, ex_track1) \ - pl_system_deinit(); \ - pl_system_init(NULL); \ - __test_playlist_state(queue, 0, false, false); \ - while (idle_run_task()) {}; \ - __test_playlist_state(queue, ex_size, ex_track0, ex_track1) +#define __test_playlist_hide_track(name, ex_size, ex_track0, ex_track1) \ + g_assert_true(playlist_add(PL_SYSTEM, "Hidden", track_get(0))); \ + __test_playlist_state(name, ex_size, ex_track0, ex_track1); \ + g_assert_false(playlist_add(PL_SYSTEM, name, track_get(0))) +#define __test_playlist_unhide_track(name, ex_size, ex_track0, ex_track1) \ + g_assert_true(playlist_remove(PL_SYSTEM, "Hidden", track_get(0))); \ + __test_playlist_state(name, ex_size, ex_track0, ex_track1) -static void test_init() -{ - struct library *library; +#define __test_playlist_reinit(name, ex_size, ex_track0, ex_track1) \ +do { \ + struct queue *queue; \ + pl_system_deinit(); \ + pl_system_init(NULL); \ + queue = playlist_get_queue(PL_SYSTEM, name); \ + g_assert_nonnull(queue); \ + __test_playlist_state(name, 0, false, false); \ + while (idle_run_task()) {}; \ + g_assert_false(queue_has_flag(queue, Q_ADD_FRONT)); \ + __test_playlist_state(name, ex_size, ex_track0, ex_track1); \ +} while (0) - idle_init_sync(); - tags_init(); - pl_system_init(NULL); - while (idle_run_task()) {}; - - /* Add tracks to the collection. */ - 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"); -} static void test_invalid() { - test_init(); + g_assert_null(playlist_get_queue(PL_SYSTEM, NULL)); + g_assert_null(playlist_get_queue(PL_SYSTEM, "Invalid")); - test_equal((void *)pl_system.pl_get_queue(NULL), NULL); - test_equal((void *)pl_system.pl_get_queue("Invalid"), NULL); + g_assert_false(playlist_new(PL_SYSTEM, "New Playlist")); + g_assert_false(playlist_delete(PL_SYSTEM, "Favorites")); - test_equal(pl_system.pl_new("New Playlist"), (bool)false); - test_equal(pl_system.pl_delete("Favorites"), (bool)false); + playlist_update(PL_SYSTEM, NULL); + g_assert_false(playlist_add(PL_SYSTEM, NULL, track_get(0))); + g_assert_false(playlist_remove(PL_SYSTEM, NULL, track_get(0))); + g_assert_false(playlist_has(PL_SYSTEM, NULL, track_get(0))); + g_assert_cmpuint(playlist_size(PL_SYSTEM, NULL), ==, 0); - test_equal(pl_system.pl_add_track(NULL, track_get(0)), (bool)false); - test_equal(pl_system.pl_remove_track(NULL, track_get(0)), (bool)false); + g_assert_false(playlist_get_random(PL_SYSTEM, NULL)); + playlist_set_random(PL_SYSTEM, NULL, true); + g_assert_false(playlist_get_random(PL_SYSTEM, NULL)); } static void test_favorites() { - struct queue *queue = pl_system.pl_get_queue("Favorites"); + struct queue *queue = playlist_get_queue(PL_SYSTEM, "Favorites"); - test_not_equal((void *)queue, NULL); - test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)false); + g_assert_nonnull(queue); + g_assert_false(queue_has_flag(queue, Q_ADD_FRONT)); - __test_playlist_random("Favorites", queue); - __test_playlist_add("Favorites", queue); - __test_playlist_reinit(queue, 2, true, true); - __test_playlist_update("Favorites", queue, 2, true, true); - __test_playlist_remove("Favorites", queue); + __test_playlist_random("Favorites"); + __test_playlist_add("Favorites"); + __test_playlist_reinit("Favorites", 2, true, true); + __test_playlist_update("Favorites", 2, true, true); + __test_playlist_remove("Favorites"); } static void test_hidden() { - struct queue *queue = pl_system.pl_get_queue("Hidden"); + struct queue *queue = playlist_get_queue(PL_SYSTEM, "Hidden"); - test_not_equal((void *)queue, NULL); - test_equal((void *)pl_system.pl_get_queue("Banned"), (void *)queue); - test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)false); + g_assert_nonnull(queue); + g_assert(playlist_get_queue(PL_SYSTEM, "Banned") == queue); + g_assert_false(queue_has_flag(queue, Q_ADD_FRONT)); - __test_playlist_random("Hidden", queue); - __test_playlist_add("Hidden", queue); - __test_playlist_reinit(queue, 2, true, true); - __test_playlist_update("Hidden", queue, 2, true, true); - __test_playlist_remove("Hidden", queue); + __test_playlist_random("Hidden"); + __test_playlist_add("Hidden"); + __test_playlist_reinit("Hidden", 2, true, true); + __test_playlist_update("Hidden", 2, true, true); + __test_playlist_remove("Hidden"); } static void test_collection() { - struct queue *queue = pl_system.pl_get_queue("Collection"); + struct queue *queue = playlist_get_queue(PL_SYSTEM, "Collection"); pl_system_deinit(); pl_system_init(NULL); - test_not_equal((void *)queue, NULL); - test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)true); + g_assert_nonnull(queue); + g_assert_true(queue_has_flag(queue, Q_ADD_FRONT)); - __test_playlist_random("Collection", queue); - __test_playlist_add("Collection", queue); - __test_playlist_hide_track("Collection", queue, 1, false, true); - __test_playlist_reinit(queue, 1, false, true); - __test_playlist_update("Collection", queue, 1, false, true); - __test_playlist_unhide_track("Collection", queue, 2, true, true); + __test_playlist_random("Collection"); + __test_playlist_add("Collection"); + __test_playlist_hide_track("Collection", 1, false, true); + __test_playlist_reinit("Collection", 1, false, true); + __test_playlist_update("Collection", 1, false, true); + __test_playlist_unhide_track("Collection", 2, true, true); } static void test_history() { - struct queue *queue = pl_system.pl_get_queue("History"); + struct queue *queue = playlist_get_queue(PL_SYSTEM, "History"); - test_not_equal((void *)queue, NULL); - test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)true); - test_equal(queue_has_flag(queue, Q_NO_SORT), (bool)true); + g_assert_nonnull(queue); + g_assert_true(queue_has_flag(queue, Q_ADD_FRONT)); + g_assert_true(queue_has_flag(queue, Q_NO_SORT)); - test_equal(g_slist_length(queue->q_sort), 0); - pl_system.pl_sort("History", COMPARE_TRACK, true); - test_equal(g_slist_length(queue->q_sort), 0); + g_assert_cmpuint(g_slist_length(queue->q_sort), ==, 0); + playlist_sort(PL_SYSTEM, "History", COMPARE_TRACK, true); + g_assert_cmpuint(g_slist_length(queue->q_sort), ==, 0); - test_equal(queue_has_flag(queue, Q_RANDOM), (bool)false); - pl_system.pl_set_flag("History", Q_RANDOM, true); - test_equal(queue_has_flag(queue, Q_RANDOM), (bool)false); + g_assert_false(playlist_get_random(PL_SYSTEM, "History")); + playlist_set_random(PL_SYSTEM, "History", true); + g_assert_false(playlist_get_random(PL_SYSTEM, "History")); - __test_playlist_state(queue, 0, false, false); - test_equal(pl_system.pl_add_track("History", track_get(0)), (bool)true); - test_equal(pl_system.pl_add_track("History", track_get(0)), (bool)true); - test_equal(pl_system.pl_add_track("History", track_get(1)), (bool)true); - test_equal(pl_system.pl_add_track("History", track_get(1)), (bool)true); - __test_playlist_state(queue, 4, true, true); + __test_playlist_state("History", 0, false, false); + g_assert_true(playlist_add(PL_SYSTEM, "History", track_get(0))); + g_assert_true(playlist_add(PL_SYSTEM, "History", track_get(0))); + g_assert_true(playlist_add(PL_SYSTEM, "History", track_get(1))); + g_assert_true(playlist_add(PL_SYSTEM, "History", track_get(1))); + __test_playlist_state("History", 4, true, true); - test_equal((void *)queue_next(queue), (void *)track_get(1)); - test_equal((void *)queue_next(queue), (void *)track_get(0)); - test_equal(queue_size(queue), 4); - test_equal(pl_system.pl_add_track("History", track_get(1)), (bool)true); - test_equal(queue_size(queue), 5); - test_equal((void *)queue_next(queue), (void *)track_get(1)); + g_assert(playlist_prev() == track_get(1)); + g_assert(playlist_prev() == track_get(0)); + g_assert_cmpuint(playlist_size(PL_SYSTEM, "History"), ==, 4); + g_assert_true(playlist_add(PL_SYSTEM, "History", track_get(1))); + g_assert_cmpuint(playlist_size(PL_SYSTEM, "History"), ==, 5); + g_assert(playlist_prev() == track_get(1)); - __test_playlist_remove("History", queue); - __test_playlist_update("History", queue, 0, false, false); + __test_playlist_remove("History"); + __test_playlist_update("History", 0, false, false); } static void test_unplayed() { - struct queue *queue = pl_system.pl_get_queue("Unplayed"); + struct queue *queue = playlist_get_queue(PL_SYSTEM, "Unplayed"); pl_system_deinit(); pl_system_init(NULL); - test_not_equal((void *)queue, NULL); - test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)true); + g_assert_nonnull(queue); + g_assert_true(queue_has_flag(queue, Q_ADD_FRONT)); - __test_playlist_random("Unplayed", queue); - __test_playlist_reinit(queue, 2, true, true); - __test_playlist_remove("Unplayed", queue); + __test_playlist_random("Unplayed"); + __test_playlist_reinit("Unplayed", 2, true, true); + __test_playlist_remove("Unplayed"); track_get(1)->tr_count = 1; - test_equal(pl_system.pl_add_track("Unplayed", track_get(0)), (bool)true); - test_equal(pl_system.pl_add_track("Unplayed", track_get(0)), (bool)false); - test_equal(queue_size(queue), 1); + g_assert_true( playlist_add(PL_SYSTEM, "Unplayed", track_get(0))); + g_assert_false(playlist_add(PL_SYSTEM, "Unplayed", track_get(1))); + g_assert_cmpuint(playlist_size(PL_SYSTEM, "Unplayed"), ==, 1); track_get(0)->tr_count = 1; track_get(1)->tr_count = 0; - __test_playlist_update("Unplayed", queue, 1, false, true); + __test_playlist_update("Unplayed", 1, false, true); track_get(0)->tr_count = 0; - __test_playlist_update("Unplayed", queue, 2, true, true); + __test_playlist_update("Unplayed", 2, true, true); - __test_playlist_hide_track("Unplayed", queue, 1, false, true); - __test_playlist_reinit(queue, 1, false, true); - __test_playlist_update("Unplayed", queue, 1, false, true); - __test_playlist_unhide_track("Unplayed", queue, 2, true, true); + __test_playlist_hide_track("Unplayed", 1, false, true); + __test_playlist_reinit("Unplayed", 1, false, true); + __test_playlist_update("Unplayed", 1, false, true); + __test_playlist_unhide_track("Unplayed", 2, true, true); } static void test_most_played() { - struct queue *most = pl_system.pl_get_queue("Most Played"); + struct queue *most = playlist_get_queue(PL_SYSTEM, "Most Played"); /* Set average = (4 / 2) = 2 */ track_played(track_get(0)); @@ -210,32 +213,35 @@ static void test_most_played() pl_system_deinit(); pl_system_init(NULL); - __test_playlist_random("Most Played", most); - __test_playlist_reinit(most, 1, false, true); + g_assert_nonnull(most); + g_assert_true(queue_has_flag(most, Q_ADD_FRONT)); - test_equal(pl_system.pl_remove_track("Most Played", track_get(0)), (bool)false); - test_equal(pl_system.pl_remove_track("Most Played", track_get(1)), (bool)true); - test_equal(pl_system.pl_remove_track("Most Played", track_get(1)), (bool)false); - __test_playlist_state(most, 0, false, false); + __test_playlist_random("Most Played"); + __test_playlist_reinit("Most Played", 1, false, true); - test_equal(pl_system.pl_add_track("Most Played", track_get(0)), (bool)false); - test_equal(pl_system.pl_add_track("Most Played", track_get(1)), (bool)true); - test_equal(pl_system.pl_add_track("Most Played", track_get(1)), (bool)false); - __test_playlist_state(most, 1, false, true); + g_assert_false(playlist_remove(PL_SYSTEM, "Most Played", track_get(0))); + g_assert_true( playlist_remove(PL_SYSTEM, "Most Played", track_get(1))); + g_assert_false(playlist_remove(PL_SYSTEM, "Most Played", track_get(1))); + __test_playlist_state("Most Played", 0, false, false); + + g_assert_false(playlist_add(PL_SYSTEM, "Most Played", track_get(0))); + g_assert_true( playlist_add(PL_SYSTEM, "Most Played", track_get(1))); + g_assert_false(playlist_add(PL_SYSTEM, "Most Played", track_get(1))); + __test_playlist_state("Most Played", 1, false, true); track_get(0)->tr_count = 3; track_get(1)->tr_count = 1; - __test_playlist_update("Most Played", most, 1, true, false); + __test_playlist_update("Most Played", 1, true, false); - __test_playlist_hide_track("Most Played", most, 0, false, false); - __test_playlist_reinit(most, 0, false, false); - __test_playlist_update("Most Played", most, 0, false, false); - __test_playlist_unhide_track("Most Played", most, 1, true, false); + __test_playlist_hide_track("Most Played", 0, false, false); + __test_playlist_reinit("Most Played", 0, false, false); + __test_playlist_update("Most Played", 0, false, false); + __test_playlist_unhide_track("Most Played", 1, true, false); } static void test_least_played() { - struct queue *least = pl_system.pl_get_queue("Least Played"); + struct queue *least = playlist_get_queue(PL_SYSTEM, "Least Played"); /* Reset playcounts so track 1 is "least played" */ track_get(0)->tr_count = 3; @@ -244,43 +250,61 @@ static void test_least_played() pl_system_deinit(); pl_system_init(NULL); - test_not_equal((void *)least, NULL); - test_equal(queue_has_flag(least, Q_ADD_FRONT), (bool)true); + g_assert_nonnull(least); + g_assert_true(queue_has_flag(least, Q_ADD_FRONT)); - __test_playlist_random("Least Played", least); - __test_playlist_reinit(least, 1, false, true); + __test_playlist_random("Least Played"); + __test_playlist_reinit("Least Played", 1, false, true); - test_equal(pl_system.pl_remove_track("Least Played", track_get(0)), (bool)false); - test_equal(pl_system.pl_remove_track("Least Played", track_get(1)), (bool)true); - test_equal(pl_system.pl_remove_track("Least Played", track_get(1)), (bool)false); - __test_playlist_state(least, 0, false, false); + g_assert_false(playlist_remove(PL_SYSTEM, "Least Played", track_get(0))); + g_assert_true( playlist_remove(PL_SYSTEM, "Least Played", track_get(1))); + g_assert_false(playlist_remove(PL_SYSTEM, "Least Played", track_get(1))); + __test_playlist_state("Least Played", 0, false, false); - test_equal(pl_system.pl_add_track("Least Played", track_get(0)), (bool)false); - test_equal(pl_system.pl_add_track("Least Played", track_get(1)), (bool)true); - test_equal(pl_system.pl_add_track("Least Played", track_get(1)), (bool)false); - __test_playlist_state(least, 1, false, true); + g_assert_false(playlist_add(PL_SYSTEM, "Least Played", track_get(0))); + g_assert_true( playlist_add(PL_SYSTEM, "Least Played", track_get(1))); + g_assert_false(playlist_add(PL_SYSTEM, "Least Played", track_get(1))); + __test_playlist_state("Least Played", 1, false, true); track_get(0)->tr_count = 1; track_get(1)->tr_count = 3; - __test_playlist_update("Least Played", least, 1, true, false); + __test_playlist_update("Least Played", 1, true, false); - __test_playlist_hide_track("Least Played", least, 0, false, false); - __test_playlist_reinit(least, 0, false, false); - __test_playlist_update("Least Played", least, 0, false, false); - __test_playlist_unhide_track("Least Played", least, 1, true, false); + __test_playlist_hide_track("Least Played", 0, false, false); + __test_playlist_reinit("Least Played", 0, false, false); + __test_playlist_update("Least Played", 0, false, false); + __test_playlist_unhide_track("Least Played", 1, true, false); +} + + +int main(int argc, char **argv) +{ + struct library *library; + int ret; + + idle_init_sync(); + tags_init(); + pl_system_init(NULL); + while (idle_run_task()) {}; + + /* Add tracks to the collection. */ + 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"); + + g_test_init(&argc, &argv, NULL); + g_test_add_func("/Core/Playlists/System/Invalid", test_invalid); + g_test_add_func("/Core/Playlists/System/Favorites", test_favorites); + g_test_add_func("/Core/Playlists/System/Hidden", test_hidden); + g_test_add_func("/Core/Playlists/System/Collection", test_collection); + g_test_add_func("/Core/Playlists/System/History", test_history); + g_test_add_func("/Core/Playlists/System/Unplayed Tracks", test_unplayed); + g_test_add_func("/Core/Playlists/System/Most Played Tracks", test_most_played); + g_test_add_func("/Core/Playlists/System/Least Played Tracks", test_least_played); + ret = g_test_run(); pl_system_deinit(); tags_deinit(); idle_deinit(); + return ret; } - -DECLARE_UNIT_TESTS( - UNIT_TEST("Invalid Playlist", test_invalid), - UNIT_TEST("Favorites Playlist", test_favorites), - UNIT_TEST("Hidden Playlist", test_hidden), - UNIT_TEST("Collection Playlist", test_collection), - UNIT_TEST("History Playlist", test_history), - UNIT_TEST("Unplayed Tracks Playlist", test_unplayed), - UNIT_TEST("Most Played Tracks Playlist", test_most_played), - UNIT_TEST("Least Played Tracks Playlist", test_least_played), -);