bool
sp_playlist_get_image(sp_playlist *playlist, byte *buffout)
{
if (playlist->image)
{
MEMCPY_N(buffout, playlist->image, byte, 20);
return true;
}
return false;
}
sp_playlist *
sp_mock_playlist_create(const char *name, bool is_loaded, sp_user *owner, bool is_collaborative,
const char *description, const byte *image, bool has_pending_changes,
unsigned int num_subscribers, sp_subscribers *subscribers, bool is_in_ram,
sp_playlist_offline_status offline_status, int offline_download_completed,
int num_tracks, sp_playlist_track_t *tracks)
{
int i;
sp_playlist *playlist = ALLOC(sp_playlist);
playlist->name = strclone(name);
playlist->is_loaded = is_loaded;
playlist->owner = owner;
playlist->is_collaborative = is_collaborative;
playlist->get_description = strclone(description);
if (image)
{
playlist->image = ALLOC_N(byte, 20);
MEMCPY_N(playlist->image, image, byte, 20);
}
playlist->has_pending_changes = has_pending_changes;
playlist->num_subscribers = num_subscribers;
playlist->subscribers = subscribers;
playlist->is_in_ram = is_in_ram;
playlist->get_offline_status = offline_status;
playlist->get_offline_download_completed = offline_download_completed;
playlist->num_tracks = num_tracks;
playlist->tracks = ALLOC_N(sp_playlist_track_t, num_tracks);
MEMCPY_N(playlist->tracks, tracks, sp_playlist_track_t, num_tracks);
/* private mock accessors */
playlist->autolink_tracks = false;
return playlist;
}
sp_artist *
mocksp_artist_create(const char *name, const byte* portrait, bool is_loaded)
{
sp_artist *artist = ALLOC(sp_artist);
artist->name = strclone(name);
artist->is_loaded = is_loaded;
if (portrait)
{
artist->portrait = ALLOC_N(byte, 20);
MEMCPY_N(artist->portrait, portrait, byte, 20);
}
return artist;
}
sp_search *
mocksp_search_create(sp_error error, const char *query, const char *did_you_mean,
int total_tracks, int num_tracks, const sp_track **tracks,
int total_albums, int num_albums, const sp_album **albums,
int total_artists, int num_artists, const sp_artist **artists,
int total_playlists, int num_playlists,
sp_search_playlist_t *playlists,
search_complete_cb *callback, void *userdata)
{
sp_search *search = ALLOC(sp_search);
search->error = error;
search->query = strclone(query);
if (did_you_mean)
{
search->did_you_mean = strclone(did_you_mean);
}
search->total_tracks = total_tracks;
search->total_artists = total_artists;
search->total_albums = total_albums;
search->total_playlists = total_playlists;
search->num_tracks = num_tracks;
search->num_artists = num_artists;
search->num_albums = num_albums;
search->num_playlists = num_playlists;
search->tracks = ALLOC_N(sp_track *, num_tracks);
search->artists = ALLOC_N(sp_artist *, num_artists);
search->albums = ALLOC_N(sp_album *, num_artists);
search->playlists = ALLOC_N(sp_search_playlist_t, num_playlists);
MEMCPY_N(search->tracks, tracks, sp_track *, num_tracks);
MEMCPY_N(search->artists, artists, sp_artist *, num_artists);
MEMCPY_N(search->albums, albums, sp_album *, num_albums);
MEMCPY_N(search->playlists, playlists, sp_search_playlist_t, num_playlists);
search->callback = callback;
search->userdata = userdata;
return search;
}
sp_playlistcontainer *
sp_mock_playlistcontainer_create(sp_user *owner, bool loaded,
int num_playlists, sp_playlistcontainer_playlist_t *playlists,
sp_playlistcontainer_callbacks *callbacks, void *userdata)
{
sp_playlistcontainer *container = ALLOC(sp_playlistcontainer);
container->is_loaded = loaded;
container->owner = owner;
container->num_playlists = num_playlists;
container->playlists = ALLOC_N(sp_playlistcontainer_playlist_t, num_playlists);
MEMCPY_N(container->playlists, playlists, sp_playlistcontainer_playlist_t, num_playlists);
container->callbacks = callbacks;
container->userdata = userdata;
return container;
}
sp_album *
mocksp_album_create(const char *name, sp_artist *artist, int year, const byte *cover,
sp_albumtype type, bool loaded, bool available)
{
sp_album *album = ALLOC(sp_album);
album->name = strclone(name);
album->year = year;
album->type = type;
album->artist = artist;
album->is_loaded = loaded;
album->is_available = available;
if (cover)
{
album->cover = ALLOC_N(byte, 20);
MEMCPY_N(album->cover, cover, byte, 20);
}
return album;
}
