core/playlist: playlist_delete() uses a playlist-level function pointer

Rather than going through the playlist-type operations.  Additionally, I
take this opportunity to change playlist_delete() to take a playlist
struct directly.

Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>

core/playlist.c

@@ -70,9 +70,19 @@ struct playlist *playlist_new(enum playlist_type_t type, const gchar *name)
 	return NULL;
 }
 
-bool playlist_delete(enum playlist_type_t type, const gchar *name)
+bool playlist_delete(struct playlist *playlist)
 {
-	return playlist_types[type]->pl_delete(name);
+	enum playlist_type_t type;
+	bool                 ret;
+
+	if (!playlist || !playlist->pl_ops->pl_delete)
+		return false;
+
+	type = playlist->pl_type;
+	ret  = playlist->pl_ops->pl_delete(playlist);
+	if (ret)
+		playlist_types[type]->pl_save();
+	return ret;
 }
 
 bool playlist_add(enum playlist_type_t type, const gchar *name,

core/playlists/artist.c

@@ -8,6 +8,8 @@
 static struct queue_ops *artist_ops  = NULL;
 static struct file       artist_file = FILE_INIT("playlist.artist", 0);
 
+static struct playlist_ops pl_artist_ops;
+
 
 static struct playlist *__artist_pl_alloc(gchar *name)
 {
@@ -15,6 +17,7 @@ static struct playlist *__artist_pl_alloc(gchar *name)
 
 	playlist->pl_name = name;
 	playlist->pl_type = PL_ARTIST;
+	playlist->pl_ops  = &pl_artist_ops;
 	playlist_generic_init(playlist, Q_REPEAT, artist_ops);
 
 	return playlist;
@@ -117,11 +120,6 @@ static gchar *pl_artist_get_name(unsigned int id)
 	return artist ? g_strdup(artist->ar_name) : NULL;
 }
 
-static bool pl_artist_delete(const gchar *name)
-{
-	return false;
-}
-
 static bool pl_artist_add_rm(const gchar *name, struct track *track)
 {
 	return false;
@@ -161,7 +159,6 @@ struct playlist_type pl_artist = {
 	.pl_get_id       = pl_artist_get_id,
 	.pl_get_name     = pl_artist_get_name,
 	.pl_can_select   = pl_artist_can_select,
-	.pl_delete       = pl_artist_delete,
 	.pl_add_track    = pl_artist_add_rm,
 	.pl_remove_track = pl_artist_add_rm,
 	.pl_update       = pl_artist_update,

core/playlists/generic.c

@@ -13,10 +13,6 @@ bool playlist_noop_can_select(struct playlist *playlist)
 	return false;
 }
 
-void playlist_noop_clear(struct playlist *playlist)
-{
-}
-
 void playlist_noop_set_flag(struct playlist *playlist,
 			    enum queue_flags flag, bool enabled)
 {

core/playlists/library.c

@@ -5,6 +5,7 @@
 #include <core/playlists/artist.h>
 #include <core/playlists/library.h>
 #include <core/playlists/system.h>
+#include <core/playlists/user.h>
 #include <unistd.h>
 
 struct scan_data {
@@ -16,6 +17,8 @@ static bool __lib_pl_scan_dir(void *);
 static struct queue_ops *lib_ops  = NULL;
 static struct file       lib_file = FILE_INIT("playlist.library", 0);
 
+static struct playlist_ops pl_library_ops;
+
 
 static struct playlist *__lib_pl_alloc(struct library *library)
 {
@@ -23,6 +26,7 @@ static struct playlist *__lib_pl_alloc(struct library *library)
 
 	playlist->pl_name = library->li_path;
 	playlist->pl_type = PL_LIBRARY;
+	playlist->pl_ops  = &pl_library_ops;
 	playlist_generic_init(playlist, Q_REPEAT, lib_ops);
 
 	return playlist;
@@ -167,6 +171,32 @@ static bool __lib_pl_update(void *data)
 }
 
 
+static bool pl_library_delete(struct playlist *playlist)
+{
+	struct library *library = library_lookup(playlist->pl_name);
+	struct queue_iter it;
+
+	if (!library)
+		return false;
+
+	queue_for_each(&playlist->pl_queue, &it) {
+		pl_system_delete_track(queue_iter_val(&it));
+		pl_artist_delete_track(queue_iter_val(&it));
+		pl_user_delete_track(queue_iter_val(&it));
+	}
+	__lib_pl_free(playlist);
+
+	track_remove_all(library);
+	library_remove(library);
+	return true;
+}
+
+
+static struct playlist_ops pl_library_ops = {
+	.pl_delete = pl_library_delete,
+};
+
+
 static void pl_library_save(void)
 {
 	struct db_entry *dbe, *next;
@@ -222,27 +252,6 @@ static struct playlist *pl_library_new(const gchar *name)
 	return library->li_playlist;
 }
 
-static bool pl_library_delete(const gchar *name)
-{
-	struct playlist *playlist = __lib_pl_lookup(name);
-	struct library  *library  = library_lookup(name);
-	struct queue_iter it;
-
-	if (!library)
-		return false;
-
-	queue_for_each(&playlist->pl_queue, &it) {
-		pl_system_delete_track(queue_iter_val(&it));
-		pl_artist_delete_track(queue_iter_val(&it));
-	}
-	__lib_pl_free(playlist);
-
-	track_remove_all(library);
-	library_remove(library);
-	pl_library_save();
-	return true;
-}
-
 static bool pl_library_add_rm(const gchar *name, struct track *track)
 {
 	return false;
@@ -286,7 +295,6 @@ struct playlist_type pl_library = {
 	.pl_get_name     = pl_library_get_name,
 	.pl_can_select   = pl_library_can_select,
 	.pl_new          = pl_library_new,
-	.pl_delete       = pl_library_delete,
 	.pl_add_track    = pl_library_add_rm,
 	.pl_remove_track = pl_library_add_rm,
 	.pl_update       = pl_library_update,

core/playlists/system.c

@@ -22,6 +22,13 @@ static struct sys_playlist *sys_playlists[SYS_PL_NUM_PLAYLISTS];
 /*
  * Generic system playlist operations.
  */
+static bool sys_pl_delete_clear(struct playlist *playlist)
+{
+	playlist_generic_clear(playlist);
+	__sys_pl_save();
+	return false;
+}
+
 static void sys_pl_generic_init(struct playlist *playlist, unsigned int flags,
 				struct queue_ops *ops)
 {
@@ -78,15 +85,18 @@ static bool sys_pl_generic_add_front(struct playlist *playlist,
 /*
  * Favorite tracks playlist operations.
  */
+static struct playlist_ops favorites_ops = {
+	.pl_delete = sys_pl_delete_clear,
+};
+
 static struct sys_playlist sys_favorites = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Favorites"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Favorites", &favorites_ops),
 	.spl_init       = playlist_generic_init,
 	.spl_save       = sys_pl_save_full,
 	.spl_load       = sys_pl_load_full,
 	.spl_can_select = playlist_generic_can_select,
 	.spl_add        = playlist_generic_add_track,
 	.spl_remove     = playlist_generic_remove_track,
-	.spl_clear      = playlist_generic_clear,
 	.spl_set_flag   = playlist_generic_set_flag,
 	.spl_sort       = playlist_generic_sort,
 	.spl_next       = playlist_generic_next,
@@ -116,7 +126,7 @@ static bool sys_pl_hidden_remove(struct playlist *playlist, struct track *track)
 	return ret;
 }
 
-static void sys_pl_hidden_clear(struct playlist *playlist)
+static bool sys_pl_hidden_clear(struct playlist *playlist)
 {
 	struct track *track;
 
@@ -124,17 +134,23 @@ static void sys_pl_hidden_clear(struct playlist *playlist)
 		track = queue_at(&playlist->pl_queue, 0);
 		sys_pl_hidden_remove(playlist, track);
 	}
+
+	__sys_pl_save();
+	return false;
 }
 
+static struct playlist_ops hidden_ops = {
+	.pl_delete = sys_pl_hidden_clear,
+};
+
 static struct sys_playlist sys_hidden = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Hidden"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Hidden", &hidden_ops),
 	.spl_init       = playlist_generic_init,
 	.spl_save       = sys_pl_save_full,
 	.spl_load       = sys_pl_load_full,
 	.spl_can_select = playlist_generic_can_select,
 	.spl_add        = sys_pl_hidden_add,
 	.spl_remove     = sys_pl_hidden_remove,
-	.spl_clear      = sys_pl_hidden_clear,
 	.spl_set_flag   = playlist_generic_set_flag,
 	.spl_sort       = playlist_generic_sort,
 	.spl_next       = playlist_generic_next,
@@ -173,15 +189,18 @@ static void sys_pl_queued_init(struct playlist *playlist,
 	queue_init(&playlist->pl_queue, 0, ops, playlist);
 }
 
+static struct playlist_ops queued_ops = {
+	.pl_delete = sys_pl_delete_clear,
+};
+
 static struct sys_playlist sys_queued = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Queued Tracks"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Queued Tracks", &queued_ops),
 	.spl_init       = sys_pl_queued_init,
 	.spl_save       = sys_pl_save_full,
 	.spl_load       = sys_pl_load_full,
 	.spl_can_select = playlist_generic_can_select,
 	.spl_add        = playlist_generic_add_track,
 	.spl_remove     = playlist_generic_remove_track,
-	.spl_clear      = playlist_generic_clear,
 	.spl_set_flag   = playlist_generic_set_flag,
 	.spl_sort       = playlist_generic_sort,
 	.spl_next       = playlist_generic_next,
@@ -215,15 +234,17 @@ static bool sys_pl_collection_update(struct playlist *playlist,
 	return sys_pl_generic_add(playlist, track) || true;
 }
 
+static struct playlist_ops collection_ops;
+
 static struct sys_playlist sys_collection = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Collection"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Collection",
+					 &collection_ops),
 	.spl_init       = sys_pl_update_init,
 	.spl_save       = sys_pl_save_partial,
 	.spl_load       = sys_pl_load_partial,
 	.spl_can_select = sys_pl_collection_can_select,
 	.spl_add        = sys_pl_generic_add,
 	.spl_remove     = playlist_generic_remove_track,
-	.spl_clear      = playlist_noop_clear,
 	.spl_update     = sys_pl_collection_update,
 	.spl_set_flag   = playlist_generic_set_flag,
 	.spl_sort       = playlist_generic_sort,
@@ -247,15 +268,16 @@ static bool sys_pl_history_add(struct playlist *playlist, struct track *track)
 	return true;
 }
 
+static struct playlist_ops history_ops;
+
 static struct sys_playlist sys_history = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "History"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "History", &history_ops),
 	.spl_init       = sys_pl_history_init,
 	.spl_save       = sys_pl_save_partial,
 	.spl_load       = sys_pl_load_partial,
 	.spl_can_select = playlist_noop_can_select,
 	.spl_add        = sys_pl_history_add,
 	.spl_remove     = playlist_generic_remove_track,
-	.spl_clear      = playlist_noop_clear,
 	.spl_set_flag   = playlist_noop_set_flag,
 	.spl_sort       = playlist_noop_sort,
 	.spl_next       = playlist_generic_next,
@@ -280,15 +302,16 @@ static bool sys_pl_unplayed_update(struct playlist *playlist,
 	return sys_pl_generic_add_front(playlist, track) || true;
 }
 
+static struct playlist_ops unplayed_ops;
+
 static struct sys_playlist sys_unplayed = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Unplayed"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Unplayed", &unplayed_ops),
 	.spl_init       = sys_pl_update_init,
 	.spl_save       = sys_pl_save_partial,
 	.spl_load       = sys_pl_load_partial,
 	.spl_can_select = playlist_generic_can_select,
 	.spl_add        = sys_pl_unplayed_add,
 	.spl_remove     = playlist_generic_remove_track,
-	.spl_clear      = playlist_noop_clear,
 	.spl_update     = sys_pl_unplayed_update,
 	.spl_set_flag   = playlist_generic_set_flag,
 	.spl_sort       = playlist_generic_sort,
@@ -316,8 +339,11 @@ static bool sys_pl_most_played_update(struct playlist *playlist,
 	return sys_pl_generic_add_front(playlist, track) || true;
 }
 
+static struct playlist_ops most_played_ops;
+
 static struct sys_playlist sys_most_played = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Most Played"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Most Played",
+					 &most_played_ops),
 	.spl_init       = sys_pl_update_init,
 	.spl_save       = sys_pl_save_partial,
 	.spl_load       = sys_pl_load_partial,
@@ -325,7 +351,6 @@ static struct sys_playlist sys_most_played = {
 	.spl_add        = sys_pl_most_played_add,
 	.spl_remove     = playlist_generic_remove_track,
 	.spl_update     = sys_pl_most_played_update,
-	.spl_clear      = playlist_noop_clear,
 	.spl_set_flag   = playlist_generic_set_flag,
 	.spl_sort       = playlist_generic_sort,
 	.spl_next       = playlist_generic_next,
@@ -352,13 +377,15 @@ static bool sys_pl_least_played_update(struct playlist *playlist,
 	return sys_pl_generic_add_front(playlist, track) || true;
 }
 
+static struct playlist_ops least_played_ops;
+
 static struct sys_playlist sys_least_played = {
-	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Least Played"),
+	.spl_playlist   = DEFINE_PLAYLIST(PL_SYSTEM, "Least Played",
+					 &least_played_ops),
 	.spl_init       = sys_pl_update_init,
 	.spl_save       = sys_pl_save_partial,
 	.spl_load       = sys_pl_load_partial,
 	.spl_can_select = playlist_generic_can_select,
-	.spl_clear      = playlist_noop_clear,
 	.spl_add        = sys_pl_least_played_add,
 	.spl_remove     = playlist_generic_remove_track,
 	.spl_update     = sys_pl_least_played_update,
@@ -510,16 +537,6 @@ static bool pl_system_can_select(const gchar *name)
 	return sys_pl ? sys_pl->spl_can_select(&sys_pl->spl_playlist) : false;
 }
 
-static bool pl_system_delete(const gchar *name)
-{
-	struct sys_playlist *sys_pl = __sys_pl_lookup(name);
-	if (sys_pl) {
-		sys_pl->spl_clear(&sys_pl->spl_playlist);
-		__sys_pl_save();
-	}
-	return false; /* Don't remove the playlist from the sidebar. */
-}
-
 static bool pl_system_add_track(const gchar *name, struct track *track)
 {
 	struct sys_playlist *sys_pl = __sys_pl_lookup(name);
@@ -590,7 +607,6 @@ struct playlist_type pl_system = {
 	.pl_get_id       = pl_system_get_id,
 	.pl_get_name     = pl_system_get_name,
 	.pl_can_select   = pl_system_can_select,
-	.pl_delete       = pl_system_delete,
 	.pl_add_track    = pl_system_add_track,
 	.pl_remove_track = pl_system_remove_track,
 	.pl_update       = pl_system_update,
@@ -634,6 +650,6 @@ void pl_system_delete_track(struct track *track)
 
 	for (i = 0; i < SYS_PL_NUM_PLAYLISTS; i++) {
 		sys_pl = sys_playlists[i];
-		sys_pl->spl_remove(&sys_pl->spl_playlist, track);
+		playlist_generic_remove_track(&sys_pl->spl_playlist, track);
 	}
 }

core/playlists/user.c

@@ -3,8 +3,9 @@
  */
 #include <core/playlists/user.h>
 
-static struct queue_ops *user_pl_ops = NULL;
+static struct queue_ops   *user_pl_ops = NULL;
-static struct database   user_db;
+static struct database     user_db;
+static struct playlist_ops user_ops;
 
 static struct user_playlist *__user_db_alloc(gchar *name)
 {
@@ -13,6 +14,7 @@ static struct user_playlist *__user_db_alloc(gchar *name)
 	dbe_init(&playlist->pl_dbe, playlist);
 	playlist->pl_playlist.pl_name = name;
 	playlist->pl_playlist.pl_type = PL_USER;
+	playlist->pl_playlist.pl_ops = &user_ops;
 	playlist_generic_init(&playlist->pl_playlist, Q_REPEAT, user_pl_ops);
 
 	return playlist;
@@ -68,6 +70,22 @@ static const struct db_ops user_db_ops = {
 };
 
 
+static bool pl_user_delete(struct playlist *playlist)
+{
+	struct db_entry *dbe = db_get(&user_db, playlist->pl_name);
+	if (dbe) {
+		db_remove(&user_db, dbe);
+		db_defrag(&user_db);
+	}
+	return dbe != NULL;
+}
+
+
+static struct playlist_ops user_ops = {
+	.pl_delete = pl_user_delete,
+};
+
+
 static struct playlist *__user_pl_lookup(const gchar *name)
 {
 	struct db_entry *dbe = db_get(&user_db, name);
@@ -111,16 +129,6 @@ static struct playlist *pl_user_new(const gchar *name)
 	return dbe ? &USER_PLAYLIST(dbe)->pl_playlist : NULL;
 }
 
-static bool pl_user_delete(const gchar *name)
-{
-	struct db_entry *dbe = db_get(&user_db, name);
-	if (dbe) {
-		db_remove(&user_db, dbe);
-		db_defrag(&user_db);
-	}
-	return dbe != NULL;
-}
-
 static bool pl_user_add(const gchar *name, struct track *track)
 {
 	struct playlist *playlist = __user_pl_lookup(name);
@@ -184,7 +192,6 @@ struct playlist_type pl_user = {
 	.pl_get_name     = pl_user_get_name,
 	.pl_can_select   = pl_user_can_select,
 	.pl_new          = pl_user_new,
-	.pl_delete       = pl_user_delete,
 	.pl_add_track    = pl_user_add,
 	.pl_remove_track = pl_user_remove,
 	.pl_update       = pl_user_update,
@@ -210,3 +217,14 @@ struct database *pl_user_db_get()
 {
 	return &user_db;
 }
+
+void pl_user_delete_track(struct track *track)
+{
+	struct db_entry *dbe, *next;
+	struct playlist *playlist;
+
+	db_for_each(dbe, next, &user_db) {
+		playlist = &USER_PLAYLIST(dbe)->pl_playlist;
+		playlist_generic_remove_track(playlist, track);
+	}
+}

gui/sidebar.c

@@ -156,7 +156,7 @@ bool __gui_sidebar_keypress(GtkTreeView *treeview, GdkEventKey *event,
 		return false;
 
 	__gui_sidebar_filter_iter_convert(&iter, &child);
-	if (playlist_delete(playlist->pl_type, playlist->pl_name))
+	if (playlist_delete(playlist))
 		gtk_tree_store_remove(gui_sidebar_store(), &child);
 	return true;
 }

include/core/playlist.h

@@ -32,7 +32,7 @@ bool playlist_select(enum playlist_type_t, const gchar *);
 struct playlist *playlist_new(enum playlist_type_t, const gchar *);
 
 /* Called to delete a playlist. */
-bool playlist_delete(enum playlist_type_t, const gchar *);
+bool playlist_delete(struct playlist *);
 
 
 /* Called to add a track to a playlist. */

include/core/playlists/system.h

@@ -27,7 +27,6 @@ struct sys_playlist {
 	bool (*spl_can_select)(struct playlist *);
 	bool (*spl_add)(struct playlist *, struct track *);
 	bool (*spl_remove)(struct playlist *, struct track *);
-	void (*spl_clear)(struct playlist *);
 	bool (*spl_update)(struct playlist *, struct track *);
 	void (*spl_set_flag)(struct playlist *, enum queue_flags, bool);
 	void (*spl_sort)(struct playlist *, enum compare_t, bool);

include/core/playlists/type.h

@@ -8,6 +8,8 @@
 #include <glib.h>
 #include <stdbool.h>
 
+struct playlist;
+
 
 enum playlist_type_t {
 	PL_SYSTEM,
@@ -18,15 +20,27 @@ enum playlist_type_t {
 };
 
 
+struct playlist_ops {
+	/* Called to delete a playlist. */
+	bool (*pl_delete)(struct playlist *);
+};
+
+
 struct playlist {
 	enum   playlist_type_t  pl_type;    /* This playlist's type.            */
 	gchar                  *pl_name;    /* This playlist's name.            */
 	void                   *pl_private; /* This playlist's private data.    */
 	struct queue            pl_queue;   /* This playlist's queue of tracks. */
+
+	const struct playlist_ops *pl_ops; /* This playlist's supported operations. */
 };
 
 
-#define DEFINE_PLAYLIST(type, name) { .pl_type = type, .pl_name = name }
+#define DEFINE_PLAYLIST(type, name, ops) {	\
+		.pl_type = type,		\
+		.pl_name = name,		\
+		.pl_ops  = ops,			\
+}
 
 
 struct playlist_type {
@@ -48,9 +62,6 @@ struct playlist_type {
 	/* Called to create a new playlist. */
 	struct playlist *(*pl_new)(const gchar *);
 
-	/* Called to delete a playlist. */
-	bool (*pl_delete)(const gchar *);
-
 	/* Called to add a track to the playlist. */
 	bool (*pl_add_track)(const gchar *, struct track *);
 
@@ -74,9 +85,6 @@ struct playlist_type {
 /* Noop playlist can-select operation. */
 bool playlist_noop_can_select(struct playlist *);
 
-/* Noop playlist clear operation. */
-void playlist_noop_clear(struct playlist *);
-
 /* Noop playlist set_flag operation. */
 void playlist_noop_set_flag(struct playlist *, enum queue_flags, bool);
 

include/core/playlists/user.h

@@ -24,5 +24,8 @@ void pl_user_init(struct queue_ops *ops);
 /* Called to deinitialize user playlists. */
 void pl_user_deinit();
 
+/* Called to tell user playlists that a track is getting deleted. */
+void pl_user_delete_track(struct track *);
+
 struct database *pl_user_db_get();
 #endif /* OCARINA_CORE_PLAYLISTS_USER_H */

tests/core/playlist.c

@@ -10,6 +10,7 @@ static void test_null()
 {
 	g_assert_null(playlist_new(PL_MAX_TYPE, "NULL"));
 	g_assert_null(playlist_new(PL_MAX_TYPE, NULL));
+	g_assert_false(playlist_delete(NULL));
 }
 
 int main(int argc, char **argv)

tests/core/playlists/artist.c

@@ -12,7 +12,8 @@
 
 void test_artist()
 {
-	struct artist *artist;
+	struct playlist *playlist;
+	struct artist   *artist;
 
 	g_assert_null(playlist_new(PL_ARTIST, "Koji Kondo"));
 	g_assert_null(playlist_get_queue(PL_ARTIST, "Koji Kondo"));
@@ -30,6 +31,9 @@ void test_artist()
 	g_assert_cmpstr_free(playlist_get_name(PL_ARTIST, 0), ==, "Koji Kondo");
 	while (idle_run_task()) {};
 
+	playlist = playlist_get(PL_ARTIST, "Koji Kondo");
+	g_assert_nonnull(playlist);
+
 	g_assert_cmpuint(playlist_size(PL_ARTIST, "Koji Kondo"), ==, 2);
 	g_assert_nonnull(artist->ar_playlist);
 	g_assert_false(playlist_remove(PL_ARTIST, "Koji Kondo", track_get(0)));
@@ -41,7 +45,7 @@ void test_artist()
 	g_assert_cmpuint(settings_get("core.playlist.cur.id"),   ==, 0);
 	g_assert(playlist_cur() == playlist_get(PL_ARTIST, "Koji Kondo"));
 
-	g_assert_false(playlist_delete(PL_ARTIST, "Koji Kondo"));
+	g_assert_false(playlist_delete(playlist));
 	pl_artist_deinit();
 	g_assert_null(artist->ar_playlist);
 }

tests/core/playlists/library.c

@@ -94,8 +94,7 @@ void test_library()
 	g_assert_cmpuint(track_db_get()->db_size, ==, 48);
 	g_assert_cmpuint(playlist_size(PL_LIBRARY, "tests/Music"), ==, 48);
 
-	g_assert_true( playlist_delete(PL_LIBRARY, "tests/Music"));
+	g_assert_true(playlist_delete(playlist));
-	g_assert_false(playlist_delete(PL_LIBRARY, "tests/Music"));
 	g_assert_null(library_get(0));
 	g_assert_cmpuint(playlist_size(PL_SYSTEM,  "Unplayed"),    ==, 0);
 	g_assert_cmpuint(playlist_size(PL_SYSTEM,  "Collection"),  ==, 0);

tests/core/playlists/system.c

@@ -45,10 +45,6 @@
 	g_assert_false(playlist_remove(PL_SYSTEM, name, track_get(1)));	\
 	__test_playlist_state(name, 0, false, false)
 
-#define __test_playlist_clear(name, ex_size, ex_track0, ex_track1)	\
-	g_assert_false(playlist_delete(PL_SYSTEM, name));		\
-	__test_playlist_state(name, 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()) {};					\
@@ -64,7 +60,8 @@
 	__test_playlist_state(name, ex_size, ex_track0, ex_track1)
 
 #define __test_playlist_clear_hidden(name, ex_size, ex_track0, ex_track1)	\
-	__test_playlist_clear("Hidden", 0, false, false);			\
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Hidden")));	\
+	__test_playlist_state("Hidden", 0, false, false);			\
 	__test_playlist_state(name, ex_size, ex_track0, ex_track1);
 
 #define __test_playlist_select(name, id)					\
@@ -126,15 +123,12 @@ static void test_invalid()
 			 SYS_PL_NUM_PLAYLISTS);
 	g_assert_null(playlist_get_name(PL_SYSTEM, SYS_PL_NUM_PLAYLISTS));
 
-	g_assert_false(playlist_delete(PL_SYSTEM, "Favorites"));
-
 	__test_playlist_noselect(NULL);
 	__test_playlist_noselect("Invalid");
 
 	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_delete(PL_SYSTEM, NULL));
 	g_assert_false(playlist_has(PL_SYSTEM, NULL, track_get(0)));
 	g_assert_cmpuint(playlist_size(PL_SYSTEM, NULL), ==, 0);
 
@@ -157,9 +151,6 @@ static void test_favorites()
 	__test_playlist_select("Favorites", SYS_PL_FAVORITES);
 	__test_playlist_reinit("Favorites", 2, true, true);
 	__test_playlist_update("Favorites", 2, true, true);
-	__test_playlist_clear("Favorites",  0, false, false);
-	__test_playlist_reinit("Favorites", 0, false, false);
-	__test_playlist_add("Favorites");
 	__test_playlist_remove("Favorites");
 }
 
@@ -178,9 +169,6 @@ static void test_hidden()
 	__test_playlist_select("Hidden", SYS_PL_HIDDEN);
 	__test_playlist_reinit("Hidden", 2, true, true);
 	__test_playlist_update("Hidden", 2, true, true);
-	__test_playlist_clear("Hidden",  0, false, false);
-	__test_playlist_reinit("Hidden", 0, false, false);
-	__test_playlist_add("Hidden");
 	__test_playlist_remove("Hidden");
 }
 
@@ -212,9 +200,6 @@ static void test_queued()
 	__test_playlist_add("Queued Tracks");
 	__test_playlist_remove("Queued Tracks");
 	__test_playlist_update("Queued Tracks", 0, false, false);
-	__test_playlist_add("Queued Tracks");
-	__test_playlist_clear("Queued Tracks", 0, false, false);
-	__test_playlist_reinit("Queued Tracks", 0, false, false);
 }
 
 static void test_collection()
@@ -237,7 +222,6 @@ static void test_collection()
 	__test_playlist_unhide_track("Collection", 2, true, true);
 	__test_playlist_hide_track("Collection",   1, false, true);
 	__test_playlist_clear_hidden("Collection", 2, true, true);
-	__test_playlist_clear("Collection", 2, true, true);
 }
 
 static void test_history()
@@ -272,7 +256,6 @@ static void test_history()
 	g_assert_cmpuint(playlist_size(PL_SYSTEM, "History"), ==, 5);
 	g_assert(playlist_prev() == track_get(1));
 
-	__test_playlist_clear("History",  5, true, true);
 	__test_playlist_remove("History");
 	__test_playlist_update("History", 0, false, false);
 }
@@ -312,7 +295,6 @@ static void test_unplayed()
 	__test_playlist_unhide_track("Unplayed", 2, true, true);
 	__test_playlist_hide_track("Unplayed",   1, false, true);
 	__test_playlist_clear_hidden("Unplayed", 2, true, true);
-	__test_playlist_clear("Unplayed", 2, true, true);
 }
 
 static void test_most_played()
@@ -357,7 +339,6 @@ static void test_most_played()
 	__test_playlist_unhide_track("Most Played", 1, true, false);
 	__test_playlist_hide_track("Most Played",   0, false, false);
 	__test_playlist_clear_hidden("Most Played", 1, true, false);
-	__test_playlist_clear("Most Played", 1, true, false);
 }
 
 static void test_least_played()
@@ -400,7 +381,37 @@ static void test_least_played()
 	__test_playlist_unhide_track("Least Played", 1, true, false);
 	__test_playlist_hide_track("Least Played",   0, false, false);
 	__test_playlist_clear_hidden("Least Played", 1, true, false);
-	__test_playlist_clear("Least Played", 1, true, false);
+}
+
+static void test_delete()
+{
+	struct library *library = library_find("tests/Music");
+	track_add(library, "tests/Music/Hyrule Symphony/03 - Hyrule Field.ogg");
+	pl_system_new_track(track_get(2));
+
+	playlist_add(PL_SYSTEM, "Favorites",     track_get(0));
+	playlist_add(PL_SYSTEM, "Hidden ",       track_get(1));
+	playlist_add(PL_SYSTEM, "Hidden ",       track_get(2));
+	playlist_add(PL_SYSTEM, "Queued Tracks", track_get(0));
+	playlist_add(PL_SYSTEM, "History",       track_get(0));
+
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Favorites")));
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Hidden")));
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Queued Tracks")));
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Collection")));
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "History")));
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Unplayed")));
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Most Played")));
+	g_assert_false(playlist_delete(playlist_get(PL_SYSTEM, "Least Played")));
+
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Favorites"),     ==, 0);
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Hidden"),        ==, 0);
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Queued Tracks"), ==, 0);
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Collection"),    ==, 3);
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "History"),       ==, 1);
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Unplayed"),      ==, 1);
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Most Played"),   ==, 1);
+	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Least Played"),  ==, 1);
 }
 
 static void test_delete_tracks()
@@ -411,6 +422,7 @@ static void test_delete_tracks()
 
 	pl_system_delete_track(track_get(0));
 	pl_system_delete_track(track_get(1));
+	pl_system_delete_track(track_get(2));
 
 	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Favorites"),     ==, 0);
 	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Hidden"),        ==, 0);
@@ -444,6 +456,7 @@ int main(int argc, char **argv)
 	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);
+	g_test_add_func("/Core/Playlists/System/Delete", test_delete);
 	g_test_add_func("/Core/PLaylists/System/Delete Tracks", test_delete_tracks);
 	ret = g_test_run();
 

tests/core/playlists/user.c

@@ -52,6 +52,9 @@ void test_user()
 	while (idle_run_task()) {};
 	g_assert_cmpuint(db->db_size, ==, 1);
 
+	playlist = playlist_get(PL_USER, "Test Playlist");
+	g_assert_nonnull(playlist);
+
 	g_assert_cmpuint(playlist_size(PL_USER, "Test Playlist"), ==, 1);
 	g_assert_true( playlist_has(   PL_USER, "Test Playlist", track_get(0)));
 	g_assert_true( playlist_remove(PL_USER, "Test Playlist", track_get(0)));
@@ -59,8 +62,7 @@ void test_user()
 	g_assert_false(playlist_has(   PL_USER, "Test Playlist", track_get(0)));
 	g_assert_cmpuint(playlist_size(PL_USER, "Test Playlist"), ==, 0);
 
-	g_assert_true( playlist_delete(PL_USER, "Test Playlist"));
+	g_assert_true(playlist_delete(playlist));
-	g_assert_false(playlist_delete(PL_USER, "Test Playlist"));
 	g_assert_cmpuint(db->db_size, ==, 0);
 	g_assert_cmpuint(db_actual_size(db), ==, 0);
 }