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), -);