diff --git a/docs/changes.rst b/docs/changes.rst
index f6058708..0c4cac13 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -28,6 +28,26 @@ We got an updated :doc:`release roadmap <development/roadmap>`!
     with GMPC and ncmpc.
   - ``noidle`` command now returns ``OK`` instead of an error. Should make some
     clients work a bit better.
+  - Having multiple identical tracks in a playlist is now working properly.
+    (CPID refactoring)
+
+- Libspotify backend:
+
+  - Fix choppy playback using the Libspotify backend by using blocking ALSA
+    mode. (Fixes: GH-7)
+
+- Backend API:
+
+  - :meth:`mopidy.backends.BaseCurrentPlaylistController.load()` now accepts
+    lists of :class:`mopidy.models.Track` instead of
+    :class:`mopidy.models.Playlist`, as none of the other fields on the
+    ``Playlist`` model was in use.
+  - :meth:`mopidy.backends.BaseCurrentPlaylistController.remove()` now takes
+    criterias, just like
+    :meth:`mopidy.backends.BaseCurrentPlaylistController.get()`, and not the
+    track to remove.
+  - :attr:`mopidy.backends.BaseCurrentPlaylistController.tracks` is now
+    read-only. Use the methods to change its contents.
 
 
 0.1.0a2 (2010-06-02)
diff --git a/mopidy/backends/__init__.py b/mopidy/backends/__init__.py
index 56526eb8..64c4af53 100644
--- a/mopidy/backends/__init__.py
+++ b/mopidy/backends/__init__.py
@@ -5,6 +5,7 @@ import time
 
 from mopidy import settings
 from mopidy.models import Playlist
+from mopidy.mpd import serializer
 from mopidy.utils import get_class
 
 logger = logging.getLogger('mopidy.backends.base')
@@ -88,21 +89,37 @@ class BaseCurrentPlaylistController(object):
 
     def __init__(self, backend):
         self.backend = backend
-        self._playlist = Playlist()
+        self._cp_tracks = []
 
     def destroy(self):
         """Cleanup after component."""
         pass
 
     @property
-    def playlist(self):
-        """The currently loaded :class:`mopidy.models.Playlist`."""
-        return copy(self._playlist)
+    def tracks(self):
+        """
+        List of :class:`mopidy.model.Track` in the current playlist.
 
-    @playlist.setter
-    def playlist(self, new_playlist):
-        self._playlist = new_playlist
-        self.version += 1
+        Read-only.
+        """
+        return [t[1] for t in self._cp_tracks]
+
+    def _get_cp_track(self, **criteria):
+        matches = self._cp_tracks
+        for (key, value) in criteria.iteritems():
+            if key == 'cpid':
+                matches = filter(lambda ct: ct[0] == value, matches)
+            else:
+                matches = filter(lambda ct: getattr(ct[1], key) == value,
+                    matches)
+        if len(matches) == 1:
+            return matches[0]
+        criteria_string = ', '.join(
+            ['%s=%s' % (k, v) for (k, v) in criteria.iteritems()])
+        if len(matches) == 0:
+            raise LookupError(u'"%s" match no tracks' % criteria_string)
+        else:
+            raise LookupError(u'"%s" match multiple tracks' % criteria_string)
 
     def add(self, track, at_position=None):
         """
@@ -114,22 +131,20 @@ class BaseCurrentPlaylistController(object):
         :param at_position: position in current playlist to add track
         :type at_position: int or :class:`None`
         """
-        tracks = self.playlist.tracks
-
-        assert at_position <= len(tracks), 'at_position can not be greater' \
-            + ' than playlist length'
-
+        assert at_position <= len(self._cp_tracks), \
+            u'at_position can not be greater than playlist length'
         if at_position is not None:
-            tracks.insert(at_position, track)
+            self._cp_tracks.insert(at_position, (self.version, track))
         else:
-            tracks.append(track)
-        self.playlist = self.playlist.with_(tracks=tracks)
+            self._cp_tracks.append((self.version, track))
+        self.version += 1
 
     def clear(self):
         """Clear the current playlist."""
         self.backend.playback.stop()
         self.backend.playback.current_track = None
-        self.playlist = Playlist()
+        self._cp_tracks = []
+        self.version += 1
 
     def get(self, **criteria):
         """
@@ -139,6 +154,8 @@ class BaseCurrentPlaylistController(object):
 
         Examples::
 
+            get(cpid=7)             # Returns track with CPID 7
+                                    # (current playlist ID)
             get(id=1)               # Returns track with ID 1
             get(uri='xyz')          # Returns track with URI 'xyz'
             get(id=1, uri='xyz')    # Returns track with ID 1 and URI 'xyz'
@@ -147,26 +164,19 @@ class BaseCurrentPlaylistController(object):
         :type criteria: dict
         :rtype: :class:`mopidy.models.Track`
         """
-        matches = self._playlist.tracks
-        for (key, value) in criteria.iteritems():
-            matches = filter(lambda t: getattr(t, key) == value, matches)
-        if len(matches) == 1:
-            return matches[0]
-        criteria_string = ', '.join(
-            ['%s=%s' % (k, v) for (k, v) in criteria.iteritems()])
-        if len(matches) == 0:
-            raise LookupError(u'"%s" match no tracks' % criteria_string)
-        else:
-            raise LookupError(u'"%s" match multiple tracks' % criteria_string)
+        return self._get_cp_track(**criteria)[1]
 
-    def load(self, playlist):
+    def load(self, tracks):
         """
-        Replace the current playlist with the given playlist.
+        Replace the tracks in the current playlist with the given tracks.
 
-        :param playlist: playlist to load
-        :type playlist: :class:`mopidy.models.Playlist`
+        :param tracks: tracks to load
+        :type tracks: list of :class:`mopidy.models.Track`
         """
-        self.playlist = playlist
+        self._cp_tracks = []
+        self.version += 1
+        for track in tracks:
+            self.add(track)
         self.backend.playback.new_playlist_loaded_callback()
 
     def move(self, start, end, to_position):
@@ -183,35 +193,37 @@ class BaseCurrentPlaylistController(object):
         if start == end:
             end += 1
 
-        tracks = self.playlist.tracks
+        cp_tracks = self._cp_tracks
 
         assert start < end, 'start must be smaller than end'
         assert start >= 0, 'start must be at least zero'
-        assert end <= len(tracks), 'end can not be larger than playlist length'
+        assert end <= len(cp_tracks), \
+            'end can not be larger than playlist length'
         assert to_position >= 0, 'to_position must be at least zero'
-        assert to_position <= len(tracks), 'to_position can not be larger ' + \
-            'than playlist length'
+        assert to_position <= len(cp_tracks), \
+            'to_position can not be larger than playlist length'
 
-        new_tracks = tracks[:start] + tracks[end:]
-        for track in tracks[start:end]:
-            new_tracks.insert(to_position, track)
+        new_cp_tracks = cp_tracks[:start] + cp_tracks[end:]
+        for cp_track in cp_tracks[start:end]:
+            new_cp_tracks.insert(to_position, cp_track)
             to_position += 1
-        self.playlist = self.playlist.with_(tracks=new_tracks)
+        self._cp_tracks = new_cp_tracks
+        self.version += 1
 
-    def remove(self, track):
+    def remove(self, **criteria):
         """
         Remove the track from the current playlist.
 
-        :param track: track to remove
+        Uses :meth:`get` to lookup the track to remove.
+
+        :param criteria: on or more criteria to match by
+        :type criteria: dict
         :type track: :class:`mopidy.models.Track`
         """
-        tracks = self.playlist.tracks
-
-        assert track in tracks, 'track must be in playlist'
-
-        position = tracks.index(track)
-        del tracks[position]
-        self.playlist = self.playlist.with_(tracks=tracks)
+        cp_track = self._get_cp_track(**criteria)
+        position = self._cp_tracks.index(cp_track)
+        del self._cp_tracks[position]
+        self.version += 1
 
     def shuffle(self, start=None, end=None):
         """
@@ -223,7 +235,7 @@ class BaseCurrentPlaylistController(object):
         :param end: position after last track to shuffle
         :type end: int or :class:`None`
         """
-        tracks = self.playlist.tracks
+        cp_tracks = self._cp_tracks
 
         if start is not None and end is not None:
             assert start < end, 'start must be smaller than end'
@@ -232,18 +244,20 @@ class BaseCurrentPlaylistController(object):
             assert start >= 0, 'start must be at least zero'
 
         if end is not None:
-            assert end <= len(tracks), 'end can not be larger than ' + \
+            assert end <= len(cp_tracks), 'end can not be larger than ' + \
                 'playlist length'
 
-        before = tracks[:start or 0]
-        shuffled = tracks[start:end]
-        after = tracks[end or len(tracks):]
+        before = cp_tracks[:start or 0]
+        shuffled = cp_tracks[start:end]
+        after = cp_tracks[end or len(cp_tracks):]
         random.shuffle(shuffled)
-        self.playlist = self.playlist.with_(tracks=before+shuffled+after)
+        self._cp_tracks = before + shuffled + after
+        self.version += 1
 
-    def destroy(self):
-        """Cleanup after component."""
-        pass
+    def mpd_format(self, *args, **kwargs):
+        """Not a part of the generic backend API."""
+        kwargs['cpids'] = [ct[0] for ct in self._cp_tracks]
+        return serializer.tracks_to_mpd_format(self.tracks, *args, **kwargs)
 
 
 class BaseLibraryController(object):
@@ -322,6 +336,9 @@ class BasePlaybackController(object):
     #:     Tracks are not removed from the playlist.
     consume = False
 
+    #: The CPID (current playlist ID) of :attr:`current_track`.
+    current_cpid = 0 # TODO Get the correct CPID
+
     #: The currently playing or selected :class:`mopidy.models.Track`.
     current_track = None
 
@@ -362,7 +379,7 @@ class BasePlaybackController(object):
         if self.current_track is None:
             return None
         try:
-            return self.backend.current_playlist.playlist.tracks.index(
+            return self.backend.current_playlist.tracks.index(
                 self.current_track)
         except ValueError:
             return None
@@ -377,7 +394,7 @@ class BasePlaybackController(object):
         enabled this should be a random track, all tracks should be played once
         before the list repeats.
         """
-        tracks = self.backend.current_playlist.playlist.tracks
+        tracks = self.backend.current_playlist.tracks
 
         if not tracks:
             return None
@@ -418,7 +435,7 @@ class BasePlaybackController(object):
         if self.current_track is None or self.current_playlist_position == 0:
             return None
 
-        return self.backend.current_playlist.playlist.tracks[
+        return self.backend.current_playlist.tracks[
             self.current_playlist_position - 1]
 
     @property
@@ -506,7 +523,7 @@ class BasePlaybackController(object):
         self._shuffled = []
 
         if self.state == self.PLAYING:
-            if self.backend.current_playlist.playlist.length > 0:
+            if len(self.backend.current_playlist.tracks) > 0:
                 self.play()
             else:
                 self.stop()
@@ -528,7 +545,7 @@ class BasePlaybackController(object):
 
         # FIXME handle in play aswell?
         if self.consume:
-            self.backend.current_playlist.remove(original_track)
+            self.backend.current_playlist.remove(id=original_track.id)
 
         if self.random and self.current_track in self._shuffled:
             self._shuffled.remove(self.current_track)
@@ -553,7 +570,7 @@ class BasePlaybackController(object):
         """
 
         if track:
-            assert track in self.backend.current_playlist.playlist.tracks
+            assert track in self.backend.current_playlist.tracks
         elif not self.current_track:
             track = self.next_track
 
diff --git a/mopidy/models.py b/mopidy/models.py
index df1d12a1..09a509dc 100644
--- a/mopidy/models.py
+++ b/mopidy/models.py
@@ -1,5 +1,7 @@
 from copy import copy
 
+from mopidy.mpd import serializer
+
 class ImmutableObject(object):
     """
     Superclass for immutable objects whose fields can only be modified via the
@@ -138,43 +140,8 @@ class Track(ImmutableObject):
         """List of :class:`Artist`. Read-only."""
         return list(self._artists)
 
-    def mpd_format(self, position=0, search_result=False):
-        """
-        Format track for output to MPD client.
-
-        :param position: track's position in playlist
-        :type position: integer
-        :param search_result: format for output in search result
-        :type search_result: boolean
-        :rtype: list of two-tuples
-        """
-        result = [
-            ('file', self.uri or ''),
-            ('Time', self.length and (self.length // 1000) or 0),
-            ('Artist', self.mpd_format_artists()),
-            ('Title', self.name or ''),
-            ('Album', self.album and self.album.name or ''),
-            ('Date', self.date or ''),
-        ]
-        if self.album is not None and self.album.num_tracks != 0:
-            result.append(('Track', '%d/%d' % (
-                self.track_no, self.album.num_tracks)))
-        else:
-            result.append(('Track', self.track_no))
-        if not search_result:
-            result.append(('Pos', position))
-            result.append(('Id', self.id or position))
-        return result
-
-    def mpd_format_artists(self):
-        """
-        Format track artists for output to MPD client.
-
-        :rtype: string
-        """
-        artists = list(self._artists)
-        artists.sort(key=lambda a: a.name)
-        return u', '.join([a.name for a in artists])
+    def mpd_format(self, *args, **kwargs):
+        return serializer.track_to_mpd_format(self, *args, **kwargs)
 
 
 class Playlist(ImmutableObject):
@@ -214,33 +181,8 @@ class Playlist(ImmutableObject):
         """The number of tracks in the playlist. Read-only."""
         return len(self._tracks)
 
-    def mpd_format(self, start=0, end=None, search_result=False):
-        """
-        Format playlist for output to MPD client.
-
-        Optionally limit output to the slice ``[start:end]`` of the playlist.
-
-        :param start: position of first track to include in output
-        :type start: int (positive or negative)
-        :param end: position after last track to include in output
-        :type end: int (positive or negative) or :class:`None` for end of list
-        :rtype: list of lists of two-tuples
-        """
-        if start < 0:
-            range_start = self.length + start
-        else:
-            range_start = start
-        if end is not None and end < 0:
-            range_end = self.length - end
-        elif end is not None and end >= 0:
-            range_end = end
-        else:
-            range_end = self.length
-        tracks = []
-        for track, position in zip(self.tracks[start:end],
-                range(range_start, range_end)):
-            tracks.append(track.mpd_format(position, search_result))
-        return tracks
+    def mpd_format(self, *args, **kwargs):
+        return serializer.playlist_to_mpd_format(self, *args, **kwargs)
 
     def with_(self, uri=None, name=None, tracks=None, last_modified=None):
         """
diff --git a/mopidy/mpd/frontend.py b/mopidy/mpd/frontend.py
index 1a04514f..b71f6e6f 100644
--- a/mopidy/mpd/frontend.py
+++ b/mopidy/mpd/frontend.py
@@ -291,7 +291,7 @@ class MpdFrontend(object):
         track = self.backend.library.lookup(uri)
         if track is None:
             raise MpdNoExistError(u'No such song', command=u'addid')
-        if songpos and songpos > self.backend.current_playlist.playlist.length:
+        if songpos and songpos > len(self.backend.current_playlist.tracks):
             raise MpdArgError(u'Bad song index', command=u'addid')
         self.backend.current_playlist.add(track, at_position=songpos)
         return ('Id', track.id)
@@ -309,25 +309,25 @@ class MpdFrontend(object):
         if end is not None:
             end = int(end)
         else:
-            end = self.backend.current_playlist.playlist.length
-        tracks = self.backend.current_playlist.playlist.tracks[start:end]
+            end = len(self.backend.current_playlist.tracks)
+        tracks = self.backend.current_playlist.tracks[start:end]
         if not tracks:
             raise MpdArgError(u'Bad song index', command=u'delete')
         for track in tracks:
-            self.backend.current_playlist.remove(track)
+            self.backend.current_playlist.remove(id=track.id)
 
     @handle_pattern(r'^delete "(?P<songpos>\d+)"$')
     def _current_playlist_delete_songpos(self, songpos):
         """See :meth:`_current_playlist_delete_range`"""
         try:
             songpos = int(songpos)
-            track = self.backend.current_playlist.playlist.tracks[songpos]
-            self.backend.current_playlist.remove(track)
+            track = self.backend.current_playlist.tracks[songpos]
+            self.backend.current_playlist.remove(id=track.id)
         except IndexError:
             raise MpdArgError(u'Bad song index', command=u'delete')
 
-    @handle_pattern(r'^deleteid "(?P<songid>\d+)"$')
-    def _current_playlist_deleteid(self, songid):
+    @handle_pattern(r'^deleteid "(?P<cpid>\d+)"$')
+    def _current_playlist_deleteid(self, cpid):
         """
         *musicpd.org, current playlist section:*
 
@@ -335,10 +335,9 @@ class MpdFrontend(object):
 
             Deletes the song ``SONGID`` from the playlist
         """
-        songid = int(songid)
         try:
-            track = self.backend.current_playlist.get(id=songid)
-            return self.backend.current_playlist.remove(track)
+            cpid = int(cpid)
+            return self.backend.current_playlist.remove(cpid=cpid)
         except LookupError:
             raise MpdNoExistError(u'No such song', command=u'deleteid')
 
@@ -364,7 +363,7 @@ class MpdFrontend(object):
             ``TO`` in the playlist.
         """
         if end is None:
-            end = self.backend.current_playlist.playlist.length
+            end = len(self.backend.current_playlist.tracks)
         start = int(start)
         end = int(end)
         to = int(to)
@@ -377,8 +376,8 @@ class MpdFrontend(object):
         to = int(to)
         self.backend.current_playlist.move(songpos, songpos + 1, to)
 
-    @handle_pattern(r'^moveid "(?P<songid>\d+)" "(?P<to>\d+)"$')
-    def _current_playlist_moveid(self, songid, to):
+    @handle_pattern(r'^moveid "(?P<cpid>\d+)" "(?P<to>\d+)"$')
+    def _current_playlist_moveid(self, cpid, to):
         """
         *musicpd.org, current playlist section:*
 
@@ -388,10 +387,10 @@ class MpdFrontend(object):
             the playlist. If ``TO`` is negative, it is relative to the current
             song in the playlist (if there is one).
         """
-        songid = int(songid)
+        cpid = int(cpid)
         to = int(to)
-        track = self.backend.current_playlist.get(id=songid)
-        position = self.backend.current_playlist.playlist.tracks.index(track)
+        track = self.backend.current_playlist.get(cpid=cpid)
+        position = self.backend.current_playlist.tracks.index(track)
         self.backend.current_playlist.move(position, position + 1, to)
 
     @handle_pattern(r'^playlist$')
@@ -431,8 +430,8 @@ class MpdFrontend(object):
                 return None
         raise MpdNotImplemented # TODO
 
-    @handle_pattern(r'^playlistid( "(?P<songid>\d+)")*$')
-    def _current_playlist_playlistid(self, songid=None):
+    @handle_pattern(r'^playlistid( "(?P<cpid>\d+)")*$')
+    def _current_playlist_playlistid(self, cpid=None):
         """
         *musicpd.org, current playlist section:*
 
@@ -441,15 +440,16 @@ class MpdFrontend(object):
             Displays a list of songs in the playlist. ``SONGID`` is optional
             and specifies a single song to display info for.
         """
-        if songid is not None:
+        if cpid is not None:
             try:
-                songid = int(songid)
-                track = self.backend.current_playlist.get(id=songid)
-                return track.mpd_format()
+                cpid = int(cpid)
+                track = self.backend.current_playlist.get(cpid=cpid)
+                position = self.backend.current_playlist.tracks.index(track)
+                return track.mpd_format(position=position, cpid=cpid)
             except LookupError:
                 raise MpdNoExistError(u'No such song', command=u'playlistid')
         else:
-            return self.backend.current_playlist.playlist.mpd_format()
+            return self.backend.current_playlist.mpd_format()
 
     @handle_pattern(r'^playlistinfo$')
     @handle_pattern(r'^playlistinfo "(?P<songpos>-?\d+)"$')
@@ -479,15 +479,18 @@ class MpdFrontend(object):
             end = songpos + 1
             if start == -1:
                 end = None
-            return self.backend.current_playlist.playlist.mpd_format(
-                start, end)
+            return self.backend.current_playlist.mpd_format(start, end)
         else:
             if start is None:
                 start = 0
             start = int(start)
+            if not (0 <= start <= len(self.backend.current_playlist.tracks)):
+                raise MpdArgError(u'Bad song index', command=u'playlistinfo')
             if end is not None:
                 end = int(end)
-            return self.backend.current_playlist.playlist.mpd_format(start, end)
+                if end > len(self.backend.current_playlist.tracks):
+                    end = None
+            return self.backend.current_playlist.mpd_format(start, end)
 
     @handle_pattern(r'^playlistsearch "(?P<tag>[^"]+)" "(?P<needle>[^"]+)"$')
     def _current_playlist_playlistsearch(self, tag, needle):
@@ -515,7 +518,7 @@ class MpdFrontend(object):
         """
         # XXX Naive implementation that returns all tracks as changed
         if int(version) < self.backend.current_playlist.version:
-            return self.backend.current_playlist.playlist.mpd_format()
+            return self.backend.current_playlist.mpd_format()
 
     @handle_pattern(r'^plchangesposid "(?P<version>\d+)"$')
     def _current_playlist_plchangesposid(self, version):
@@ -535,7 +538,7 @@ class MpdFrontend(object):
         if int(version) != self.backend.current_playlist.version:
             result = []
             for position, track in enumerate(
-                    self.backend.current_playlist.playlist.tracks):
+                    self.backend.current_playlist.tracks):
                 result.append((u'cpos', position))
                 result.append((u'Id', track.id))
             return result
@@ -568,18 +571,17 @@ class MpdFrontend(object):
         """
         songpos1 = int(songpos1)
         songpos2 = int(songpos2)
-        playlist = self.backend.current_playlist.playlist
-        tracks = playlist.tracks
+        tracks = self.backend.current_playlist.tracks
         song1 = tracks[songpos1]
         song2 = tracks[songpos2]
         del tracks[songpos1]
         tracks.insert(songpos1, song2)
         del tracks[songpos2]
         tracks.insert(songpos2, song1)
-        self.backend.current_playlist.load(playlist.with_(tracks=tracks))
+        self.backend.current_playlist.load(tracks)
 
-    @handle_pattern(r'^swapid "(?P<songid1>\d+)" "(?P<songid2>\d+)"$')
-    def _current_playlist_swapid(self, songid1, songid2):
+    @handle_pattern(r'^swapid "(?P<cpid1>\d+)" "(?P<cpid2>\d+)"$')
+    def _current_playlist_swapid(self, cpid1, cpid2):
         """
         *musicpd.org, current playlist section:*
 
@@ -587,13 +589,13 @@ class MpdFrontend(object):
 
             Swaps the positions of ``SONG1`` and ``SONG2`` (both song ids).
         """
-        songid1 = int(songid1)
-        songid2 = int(songid2)
-        song1 = self.backend.current_playlist.get(id=songid1)
-        song2 = self.backend.current_playlist.get(id=songid2)
-        songpos1 = self.backend.current_playlist.playlist.tracks.index(song1)
-        songpos2 = self.backend.current_playlist.playlist.tracks.index(song2)
-        self._current_playlist_swap(songpos1, songpos2)
+        cpid1 = int(cpid1)
+        cpid2 = int(cpid2)
+        track1 = self.backend.current_playlist.get(cpid=cpid1)
+        track2 = self.backend.current_playlist.get(cpid=cpid2)
+        position1 = self.backend.current_playlist.tracks.index(track1)
+        position2 = self.backend.current_playlist.tracks.index(track2)
+        self._current_playlist_swap(position1, position2)
 
     @handle_pattern(r'^$')
     def _empty(self):
@@ -635,8 +637,7 @@ class MpdFrontend(object):
         - capitalizes the type argument.
         """
         query = self._build_query(mpd_query)
-        return self.backend.library.find_exact(query).mpd_format(
-            search_result=True)
+        return self.backend.library.find_exact(query).mpd_format()
 
     @handle_pattern(r'^findadd '
          r'(?P<query>("?([Aa]lbum|[Aa]rtist|[Ff]ilename|[Tt]itle|[Aa]ny)"? "[^"]+"\s?)+)$')
@@ -799,8 +800,7 @@ class MpdFrontend(object):
         - capitalizes the field argument.
         """
         query = self._build_query(mpd_query)
-        return self.backend.library.search(query).mpd_format(
-            search_result=True)
+        return self.backend.library.search(query).mpd_format()
 
     @handle_pattern(r'^update( "(?P<uri>[^"]+)")*$')
     def _music_db_update(self, uri=None, rescan_unmodified_files=False):
@@ -928,9 +928,9 @@ class MpdFrontend(object):
         """
         return self.backend.playback.play()
 
-    @handle_pattern(r'^playid "(?P<songid>\d+)"$')
-    @handle_pattern(r'^playid "(?P<songid>-1)"$')
-    def _playback_playid(self, songid):
+    @handle_pattern(r'^playid "(?P<cpid>\d+)"$')
+    @handle_pattern(r'^playid "(?P<cpid>-1)"$')
+    def _playback_playid(self, cpid):
         """
         *musicpd.org, playback section:*
 
@@ -943,12 +943,12 @@ class MpdFrontend(object):
         - issues ``playid "-1"`` after playlist replacement to start playback
           at the first track.
         """
-        songid = int(songid)
+        cpid = int(cpid)
         try:
-            if songid == -1:
-                track = self.backend.current_playlist.playlist.tracks[0]
+            if cpid == -1:
+                track = self.backend.current_playlist.tracks[0]
             else:
-                track = self.backend.current_playlist.get(id=songid)
+                track = self.backend.current_playlist.get(cpid=cpid)
             return self.backend.playback.play(track)
         except LookupError:
             raise MpdNoExistError(u'No such song', command=u'playid')
@@ -970,9 +970,9 @@ class MpdFrontend(object):
         songpos = int(songpos)
         try:
             if songpos == -1:
-                track = self.backend.current_playlist.playlist.tracks[0]
+                track = self.backend.current_playlist.tracks[0]
             else:
-                track = self.backend.current_playlist.playlist.tracks[songpos]
+                track = self.backend.current_playlist.tracks[songpos]
             return self.backend.playback.play(track)
         except IndexError:
             raise MpdArgError(u'Bad song index', command=u'play')
@@ -1091,8 +1091,8 @@ class MpdFrontend(object):
         """
         raise MpdNotImplemented # TODO
 
-    @handle_pattern(r'^seekid "(?P<songid>\d+)" "(?P<seconds>\d+)"$')
-    def _playback_seekid(self, songid, seconds):
+    @handle_pattern(r'^seekid "(?P<cpid>\d+)" "(?P<seconds>\d+)"$')
+    def _playback_seekid(self, cpid, seconds):
         """
         *musicpd.org, playback section:*
 
@@ -1246,7 +1246,8 @@ class MpdFrontend(object):
         """
         if self.backend.playback.current_track is not None:
             return self.backend.playback.current_track.mpd_format(
-                position=self.backend.playback.current_playlist_position)
+                position=self.backend.playback.current_playlist_position,
+                cpid=self.backend.playback.current_cpid)
 
     @handle_pattern(r'^idle$')
     @handle_pattern(r'^idle (?P<subsystems>.+)$')
@@ -1381,7 +1382,7 @@ class MpdFrontend(object):
             return 0
 
     def __status_status_playlist_length(self):
-        return self.backend.current_playlist.playlist.length
+        return len(self.backend.current_playlist.tracks)
 
     def __status_status_playlist_version(self):
         return self.backend.current_playlist.version
@@ -1396,6 +1397,7 @@ class MpdFrontend(object):
         return int(self.backend.playback.single)
 
     def __status_status_songid(self):
+        # TODO Replace track.id with CPID
         if self.backend.playback.current_track.id is not None:
             return self.backend.playback.current_track.id
         else:
@@ -1535,8 +1537,7 @@ class MpdFrontend(object):
             Album, Artist, Track
         """
         try:
-            return self.backend.stored_playlists.get(name=name).mpd_format(
-                search_result=True)
+            return self.backend.stored_playlists.get(name=name).mpd_format()
         except LookupError:
             raise MpdNoExistError(
                 u'No such playlist', command=u'listplaylistinfo')
@@ -1586,8 +1587,7 @@ class MpdFrontend(object):
         """
         matches = self.backend.stored_playlists.search(name)
         if matches:
-            self.backend.current_playlist.load(matches[0])
-            self.backend.playback.new_playlist_loaded_callback() # FIXME not needed?
+            self.backend.current_playlist.load(matches[0].tracks)
 
     @handle_pattern(r'^playlistadd "(?P<name>[^"]+)" "(?P<uri>[^"]+)"$')
     def _stored_playlist_playlistadd(self, name, uri):
diff --git a/mopidy/mpd/serializer.py b/mopidy/mpd/serializer.py
new file mode 100644
index 00000000..b8b6550b
--- /dev/null
+++ b/mopidy/mpd/serializer.py
@@ -0,0 +1,74 @@
+def track_to_mpd_format(track, position=None, cpid=None):
+    """
+    Format track for output to MPD client.
+
+    :param track: the track
+    :type track: :class:`mopidy.models.Track`
+    :param position: track's position in playlist
+    :type position: integer
+    :param cpid: track's CPID (current playlist ID)
+    :type cpid: integer
+    :rtype: list of two-tuples
+    """
+    result = [
+        ('file', track.uri or ''),
+        ('Time', track.length and (track.length // 1000) or 0),
+        ('Artist', track_artists_to_mpd_format(track)),
+        ('Title', track.name or ''),
+        ('Album', track.album and track.album.name or ''),
+        ('Date', track.date or ''),
+    ]
+    if track.album is not None and track.album.num_tracks != 0:
+        result.append(('Track', '%d/%d' % (
+            track.track_no, track.album.num_tracks)))
+    else:
+        result.append(('Track', track.track_no))
+    if position is not None and cpid is not None:
+        result.append(('Pos', position))
+        result.append(('Id', cpid))
+    return result
+
+def track_artists_to_mpd_format(track):
+    """
+    Format track artists for output to MPD client.
+
+    :param track: the track
+    :type track: :class:`mopidy.models.Track`
+    :rtype: string
+    """
+    artists = track.artists
+    artists.sort(key=lambda a: a.name)
+    return u', '.join([a.name for a in artists])
+
+def tracks_to_mpd_format(tracks, start=0, end=None, cpids=None):
+    """
+    Format list of tracks for output to MPD client.
+
+    Optionally limit output to the slice ``[start:end]`` of the list.
+
+    :param tracks: the tracks
+    :type tracks: list of :class:`mopidy.models.Track`
+    :param start: position of first track to include in output
+    :type start: int (positive or negative)
+    :param end: position after last track to include in output
+    :type end: int (positive or negative) or :class:`None` for end of list
+    :rtype: list of lists of two-tuples
+    """
+    if end is None:
+        end = len(tracks)
+    tracks = tracks[start:end]
+    positions = range(start, end)
+    cpids = cpids and cpids[start:end] or [None for t in tracks]
+    assert len(tracks) == len(positions) == len(cpids)
+    result = []
+    for track, position, cpid in zip(tracks, positions, cpids):
+        result.append(track_to_mpd_format(track, position, cpid))
+    return result
+
+def playlist_to_mpd_format(playlist, *args, **kwargs):
+    """
+    Format playlist for output to MPD client.
+
+    Arguments as for :func:`tracks_to_mpd_format`, except the first one.
+    """
+    return tracks_to_mpd_format(playlist.tracks, *args, **kwargs)
diff --git a/tests/backends/base.py b/tests/backends/base.py
index 562e3eee..926d9a05 100644
--- a/tests/backends/base.py
+++ b/tests/backends/base.py
@@ -44,12 +44,12 @@ class BaseCurrentPlaylistControllerTest(object):
     def test_add(self):
         for track in self.tracks:
             self.controller.add(track)
-            self.assertEqual(track, self.controller.playlist.tracks[-1])
+            self.assertEqual(track, self.controller.tracks[-1])
 
     def test_add_at_position(self):
         for track in self.tracks[:-1]:
             self.controller.add(track, 0)
-            self.assertEqual(track, self.controller.playlist.tracks[0])
+            self.assertEqual(track, self.controller.tracks[0])
 
     @populate_playlist
     def test_add_at_position_outside_of_playlist(self):
@@ -58,12 +58,18 @@ class BaseCurrentPlaylistControllerTest(object):
 
     @populate_playlist
     def test_add_sets_id_property(self):
-        for track in self.controller.playlist.tracks:
+        for track in self.controller.tracks:
             self.assertNotEqual(None, track.id)
 
+    @populate_playlist
+    def test_get_by_cpid(self):
+        track = self.controller.tracks[1]
+        cpid = self.controller._cp_tracks[1][0] # XXX Messing in internals
+        self.assertEqual(track, self.controller.get(cpid=cpid))
+
     @populate_playlist
     def test_get_by_id(self):
-        track = self.controller.playlist.tracks[1]
+        track = self.controller.tracks[1]
         self.assertEqual(track, self.controller.get(id=track.id))
 
     @populate_playlist
@@ -72,7 +78,7 @@ class BaseCurrentPlaylistControllerTest(object):
 
     @populate_playlist
     def test_get_by_uri(self):
-        track = self.controller.playlist.tracks[1]
+        track = self.controller.tracks[1]
         self.assertEqual(track, self.controller.get(uri=track.uri))
 
     @populate_playlist
@@ -83,11 +89,11 @@ class BaseCurrentPlaylistControllerTest(object):
     @populate_playlist
     def test_clear(self):
         self.controller.clear()
-        self.assertEqual(len(self.controller.playlist.tracks), 0)
+        self.assertEqual(len(self.controller.tracks), 0)
 
     def test_clear_empty_playlist(self):
         self.controller.clear()
-        self.assertEqual(len(self.controller.playlist.tracks), 0)
+        self.assertEqual(len(self.controller.tracks), 0)
 
     @populate_playlist
     def test_clear_when_playing(self):
@@ -97,21 +103,19 @@ class BaseCurrentPlaylistControllerTest(object):
         self.assertEqual(self.playback.state, self.playback.STOPPED)
 
     def test_load(self):
-        new_playlist = Playlist()
-        self.assertNotEqual(id(new_playlist), id(self.controller.playlist))
-        self.controller.load(new_playlist)
-        # FIXME how do we test this without going into internals?
-        self.assertEqual(new_playlist, self.controller._playlist)
+        tracks = []
+        self.assertNotEqual(id(tracks), id(self.controller.tracks))
+        self.controller.load(tracks)
+        self.assertEqual(tracks, self.controller.tracks)
 
     def test_get_by_id_returns_unique_match(self):
         track = Track(id=1)
-        self.controller.playlist = Playlist(
-            tracks=[Track(id=13), track, Track(id=17)])
+        self.controller.load([Track(id=13), track, Track(id=17)])
         self.assertEqual(track, self.controller.get(id=1))
 
     def test_get_by_id_raises_error_if_multiple_matches(self):
         track = Track(id=1)
-        self.controller.playlist = Playlist(tracks=[Track(id=13), track, track])
+        self.controller.load([Track(id=13), track, track])
         try:
             self.controller.get(id=1)
             self.fail(u'Should raise LookupError if multiple matches')
@@ -128,14 +132,12 @@ class BaseCurrentPlaylistControllerTest(object):
 
     def test_get_by_uri_returns_unique_match(self):
         track = Track(uri='a')
-        self.controller.playlist = Playlist(
-            tracks=[Track(uri='z'), track, Track(uri='y')])
+        self.controller.load([Track(uri='z'), track, Track(uri='y')])
         self.assertEqual(track, self.controller.get(uri='a'))
 
     def test_get_by_uri_raises_error_if_multiple_matches(self):
         track = Track(uri='a')
-        self.controller.playlist = Playlist(
-            tracks=[Track(uri='z'), track, track])
+        self.controller.load([Track(uri='z'), track, track])
         try:
             self.controller.get(uri='a')
             self.fail(u'Should raise LookupError if multiple matches')
@@ -155,7 +157,7 @@ class BaseCurrentPlaylistControllerTest(object):
         track1 = Track(id=1, uri='a')
         track2 = Track(id=1, uri='b')
         track3 = Track(id=2, uri='b')
-        self.controller.playlist = Playlist(tracks=[track1, track2, track3])
+        self.controller.load([track1, track2, track3])
         self.assertEqual(track1, self.controller.get(id=1, uri='a'))
         self.assertEqual(track2, self.controller.get(id=1, uri='b'))
         self.assertEqual(track3, self.controller.get(id=2, uri='b'))
@@ -164,37 +166,35 @@ class BaseCurrentPlaylistControllerTest(object):
         track1 = Track(id=1)
         track2 = Track(uri='b')
         track3 = Track(id=2)
-        self.controller.playlist = Playlist(tracks=[track1, track2, track3])
+        self.controller.load([track1, track2, track3])
         self.assertEqual(track1, self.controller.get(id=1))
 
     @populate_playlist
     def test_load_replaces_playlist(self):
-        self.backend.current_playlist.load(Playlist())
-        tracks = self.backend.current_playlist.playlist.tracks
-        self.assertEqual(len(tracks), 0)
+        self.backend.current_playlist.load([])
+        self.assertEqual(len(self.backend.current_playlist.tracks), 0)
 
     def test_load_does_not_reset_version(self):
         version = self.controller.version
-
-        self.controller.load(Playlist())
-        self.assertEqual(self.controller.version, version+1)
+        self.controller.load([])
+        self.assertEqual(self.controller.version, version + 1)
 
     @populate_playlist
     def test_load_preserves_playing_state(self):
-        tracks = self.controller.playlist.tracks
+        tracks = self.controller.tracks
         playback = self.playback
 
         self.playback.play()
-        self.controller.load(Playlist(tracks=[tracks[1]]))
+        self.controller.load([tracks[1]])
         self.assertEqual(playback.state, playback.PLAYING)
         self.assertEqual(tracks[1], self.playback.current_track)
 
     @populate_playlist
     def test_load_preserves_stopped_state(self):
-        tracks = self.controller.playlist.tracks
+        tracks = self.controller.tracks
         playback = self.playback
 
-        self.controller.load(Playlist(tracks=[tracks[2]]))
+        self.controller.load([tracks[2]])
         self.assertEqual(playback.state, playback.STOPPED)
         self.assertEqual(None, self.playback.current_track)
 
@@ -202,32 +202,32 @@ class BaseCurrentPlaylistControllerTest(object):
     def test_move_single(self):
         self.controller.move(0, 0, 2)
 
-        tracks = self.controller.playlist.tracks
+        tracks = self.controller.tracks
         self.assertEqual(tracks[2], self.tracks[0])
 
     @populate_playlist
     def test_move_group(self):
         self.controller.move(0, 2, 1)
 
-        tracks = self.controller.playlist.tracks
+        tracks = self.controller.tracks
         self.assertEqual(tracks[1], self.tracks[0])
         self.assertEqual(tracks[2], self.tracks[1])
 
     @populate_playlist
     def test_moving_track_outside_of_playlist(self):
-        tracks = len(self.controller.playlist.tracks)
+        tracks = len(self.controller.tracks)
         test = lambda: self.controller.move(0, 0, tracks+5)
         self.assertRaises(AssertionError, test)
 
     @populate_playlist
     def test_move_group_outside_of_playlist(self):
-        tracks = len(self.controller.playlist.tracks)
+        tracks = len(self.controller.tracks)
         test = lambda: self.controller.move(0, 2, tracks+5)
         self.assertRaises(AssertionError, test)
 
     @populate_playlist
     def test_move_group_out_of_range(self):
-        tracks = len(self.controller.playlist.tracks)
+        tracks = len(self.controller.tracks)
         test = lambda: self.controller.move(tracks+2, tracks+3, 0)
         self.assertRaises(AssertionError, test)
 
@@ -236,35 +236,36 @@ class BaseCurrentPlaylistControllerTest(object):
         test = lambda: self.controller.move(2, 1, 0)
         self.assertRaises(AssertionError, test)
 
-    def test_playlist_attribute_is_immutable(self):
-        playlist1 = self.controller.playlist
-        playlist2 = self.controller.playlist
-
-        self.assertNotEqual(id(playlist1), id(playlist2))
+    def test_tracks_attribute_is_immutable(self):
+        tracks1 = self.controller.tracks
+        tracks2 = self.controller.tracks
+        self.assertNotEqual(id(tracks1), id(tracks2))
 
     @populate_playlist
     def test_remove(self):
-        track1 = self.controller.playlist.tracks[1]
-        track2 = self.controller.playlist.tracks[2]
-        self.controller.remove(track1)
-        self.assert_(track1 not in self.controller.playlist.tracks)
-        self.assertEqual(track2, self.controller.playlist.tracks[1])
+        track1 = self.controller.tracks[1]
+        track2 = self.controller.tracks[2]
+        version = self.controller.version
+        self.controller.remove(id=track1.id)
+        self.assert_(version < self.controller.version)
+        self.assert_(track1 not in self.controller.tracks)
+        self.assertEqual(track2, self.controller.tracks[1])
 
     @populate_playlist
     def test_removing_track_that_does_not_exist(self):
-        test = lambda: self.controller.remove(Track())
-        self.assertRaises(AssertionError, test)
+        test = lambda: self.controller.remove(id=12345)
+        self.assertRaises(LookupError, test)
 
     def test_removing_from_empty_playlist(self):
-        test = lambda: self.controller.remove(Track())
-        self.assertRaises(AssertionError, test)
+        test = lambda: self.controller.remove(id=12345)
+        self.assertRaises(LookupError, test)
 
     @populate_playlist
     def test_shuffle(self):
         random.seed(1)
         self.controller.shuffle()
 
-        shuffled_tracks = self.controller.playlist.tracks
+        shuffled_tracks = self.controller.tracks
 
         self.assertNotEqual(self.tracks, shuffled_tracks)
         self.assertEqual(set(self.tracks), set(shuffled_tracks))
@@ -274,7 +275,7 @@ class BaseCurrentPlaylistControllerTest(object):
         random.seed(1)
         self.controller.shuffle(1, 3)
 
-        shuffled_tracks = self.controller.playlist.tracks
+        shuffled_tracks = self.controller.tracks
 
         self.assertNotEqual(self.tracks, shuffled_tracks)
         self.assertEqual(self.tracks[0], shuffled_tracks[0])
@@ -287,7 +288,7 @@ class BaseCurrentPlaylistControllerTest(object):
 
     @populate_playlist
     def test_shuffle_superset(self):
-        tracks = len(self.controller.playlist.tracks)
+        tracks = len(self.controller.tracks)
         test = lambda: self.controller.shuffle(1, tracks+5)
         self.assertRaises(AssertionError, test)
 
@@ -296,7 +297,7 @@ class BaseCurrentPlaylistControllerTest(object):
         random.seed(1)
         self.controller.shuffle(1)
 
-        shuffled_tracks = self.controller.playlist.tracks
+        shuffled_tracks = self.controller.tracks
 
         self.assertNotEqual(self.tracks, shuffled_tracks)
         self.assertEqual(self.tracks[0], shuffled_tracks[0])
@@ -304,8 +305,8 @@ class BaseCurrentPlaylistControllerTest(object):
 
     def test_version(self):
         version = self.controller.version
-        self.controller.playlist = Playlist()
-        self.assertEqual(version+1, self.controller.version)
+        self.controller.load([])
+        self.assert_(version < self.controller.version)
 
 
 class BasePlaybackControllerTest(object):
@@ -614,7 +615,7 @@ class BasePlaybackControllerTest(object):
         wrapper.called = False
 
         self.playback.new_playlist_loaded_callback = wrapper
-        self.backend.current_playlist.load(Playlist())
+        self.backend.current_playlist.load([])
 
         self.assert_(wrapper.called)
 
@@ -639,26 +640,23 @@ class BasePlaybackControllerTest(object):
 
     @populate_playlist
     def test_new_playlist_loaded_callback_when_playing(self):
-        playlist = Playlist(tracks=[self.tracks[2]])
         self.playback.play()
-        self.backend.current_playlist.load(playlist)
+        self.backend.current_playlist.load([self.tracks[2]])
         self.assertEqual(self.playback.state, self.playback.PLAYING)
         self.assertEqual(self.playback.current_track, self.tracks[2])
 
     @populate_playlist
     def test_new_playlist_loaded_callback_when_stopped(self):
-        playlist = Playlist(tracks=[self.tracks[2]])
-        self.backend.current_playlist.load(playlist)
+        self.backend.current_playlist.load([self.tracks[2]])
         self.assertEqual(self.playback.state, self.playback.STOPPED)
         self.assertEqual(self.playback.current_track, None)
         self.assertEqual(self.playback.next_track, self.tracks[2])
 
     @populate_playlist
     def test_new_playlist_loaded_callback_when_paused(self):
-        playlist = Playlist(tracks=[self.tracks[2]])
         self.playback.play()
         self.playback.pause()
-        self.backend.current_playlist.load(playlist)
+        self.backend.current_playlist.load([self.tracks[2]])
         self.assertEqual(self.playback.state, self.playback.STOPPED)
         self.assertEqual(self.playback.current_track, None)
         self.assertEqual(self.playback.next_track, self.tracks[2])
@@ -735,7 +733,7 @@ class BasePlaybackControllerTest(object):
 
     @populate_playlist
     def test_seek_when_playing(self):
-        length = self.backend.current_playlist.playlist.tracks[0].length
+        length = self.backend.current_playlist.tracks[0].length
         self.playback.play()
         self.playback.seek(length - 1000)
         position = self.playback.time_position
@@ -743,7 +741,7 @@ class BasePlaybackControllerTest(object):
 
     @populate_playlist
     def test_seek_when_paused(self):
-        length = self.backend.current_playlist.playlist.tracks[0].length
+        length = self.backend.current_playlist.tracks[0].length
         self.playback.play()
         self.playback.pause()
         self.playback.seek(length - 1000)
@@ -842,16 +840,15 @@ class BasePlaybackControllerTest(object):
         self.playback.consume = True
         self.playback.play()
         self.playback.next()
-        tracks = self.backend.current_playlist.playlist.tracks
-        self.assert_(self.tracks[0] not in tracks)
+        self.assert_(self.tracks[0] not in self.backend.current_playlist.tracks)
 
     @populate_playlist
     def test_playlist_is_empty_after_all_tracks_are_played_with_consume(self):
         self.playback.consume = True
         self.playback.play()
-        for i in range(len(self.backend.current_playlist.playlist.tracks)):
+        for i in range(len(self.backend.current_playlist.tracks)):
             self.playback.next()
-        self.assertEqual(len(self.backend.current_playlist.playlist.tracks), 0)
+        self.assertEqual(len(self.backend.current_playlist.tracks), 0)
 
     @populate_playlist
     def test_play_with_random(self):
@@ -932,7 +929,7 @@ class BasePlaybackControllerTest(object):
         random.seed(1)
         self.playback.random = True
         self.assertEqual(self.playback.next_track, self.tracks[2])
-        self.backend.current_playlist.load(Playlist(tracks=self.tracks[:1]))
+        self.backend.current_playlist.load(self.tracks[:1])
         self.assertEqual(self.playback.next_track, self.tracks[0])
 
     @populate_playlist
@@ -946,8 +943,7 @@ class BasePlaybackControllerTest(object):
             self.playback.next()
 
     def test_playing_track_with_invalid_uri(self):
-        playlist = Playlist(tracks=[Track(uri='foobar')])
-        self.backend.current_playlist.load(playlist)
+        self.backend.current_playlist.load([Track(uri='foobar')])
         self.playback.play()
         self.assertEqual(self.playback.state, self.playback.STOPPED)
 
diff --git a/tests/models_test.py b/tests/models_test.py
index 1bafd792..7fab86f5 100644
--- a/tests/models_test.py
+++ b/tests/models_test.py
@@ -228,45 +228,6 @@ class TrackTest(unittest.TestCase):
         self.assertEqual(track.id, track_id)
         self.assertRaises(AttributeError, setattr, track, 'id', None)
 
-    def test_mpd_format_for_empty_track(self):
-        track = Track()
-        result = track.mpd_format()
-        self.assert_(('file', '') in result)
-        self.assert_(('Time', 0) in result)
-        self.assert_(('Artist', '') in result)
-        self.assert_(('Title', '') in result)
-        self.assert_(('Album', '') in result)
-        self.assert_(('Track', 0) in result)
-        self.assert_(('Date', '') in result)
-        self.assert_(('Pos', 0) in result)
-        self.assert_(('Id', 0) in result)
-
-    def test_mpd_format_for_nonempty_track(self):
-        track = Track(
-            uri=u'a uri',
-            artists=[Artist(name=u'an artist')],
-            name=u'a name',
-            album=Album(name=u'an album', num_tracks=13),
-            track_no=7,
-            date=dt.date(1977, 1, 1),
-            length=137000,
-            id=122,
-        )
-        result = track.mpd_format(position=9)
-        self.assert_(('file', 'a uri') in result)
-        self.assert_(('Time', 137) in result)
-        self.assert_(('Artist', 'an artist') in result)
-        self.assert_(('Title', 'a name') in result)
-        self.assert_(('Album', 'an album') in result)
-        self.assert_(('Track', '7/13') in result)
-        self.assert_(('Date', dt.date(1977, 1, 1)) in result)
-        self.assert_(('Pos', 9) in result)
-        self.assert_(('Id', 122) in result)
-
-    def test_mpd_format_artists(self):
-        track = Track(artists=[Artist(name=u'ABBA'), Artist(name=u'Beatles')])
-        self.assertEqual(track.mpd_format_artists(), u'ABBA, Beatles')
-
     def test_invalid_kwarg(self):
         test = lambda: Track(foo='baz')
         self.assertRaises(TypeError, test)
@@ -450,33 +411,6 @@ class PlaylistTest(unittest.TestCase):
         self.assertRaises(AttributeError, setattr, playlist, 'last_modified',
             None)
 
-    def test_mpd_format(self):
-        playlist = Playlist(tracks=[
-            Track(track_no=1), Track(track_no=2), Track(track_no=3)])
-        result = playlist.mpd_format()
-        self.assertEqual(len(result), 3)
-
-    def test_mpd_format_with_range(self):
-        playlist = Playlist(tracks=[
-            Track(track_no=1), Track(track_no=2), Track(track_no=3)])
-        result = playlist.mpd_format(1, 2)
-        self.assertEqual(len(result), 1)
-        self.assertEqual(dict(result[0])['Track'], 2)
-
-    def test_mpd_format_with_negative_start_and_no_end(self):
-        playlist = Playlist(tracks=[
-            Track(track_no=1), Track(track_no=2), Track(track_no=3)])
-        result = playlist.mpd_format(-1, None)
-        self.assertEqual(len(result), 1)
-        self.assertEqual(dict(result[0])['Track'], 3)
-
-    def test_mpd_format_with_negative_start_and_end(self):
-        playlist = Playlist(tracks=[
-            Track(track_no=1), Track(track_no=2), Track(track_no=3)])
-        result = playlist.mpd_format(-2, -1)
-        self.assertEqual(len(result), 1)
-        self.assertEqual(dict(result[0])['Track'], 2)
-
     def test_with_new_uri(self):
         tracks = [Track()]
         last_modified = dt.datetime.now()
diff --git a/tests/mpd/frontend_test.py b/tests/mpd/frontend_test.py
index b5f61b07..2f121b3c 100644
--- a/tests/mpd/frontend_test.py
+++ b/tests/mpd/frontend_test.py
@@ -118,7 +118,7 @@ class StatusHandlerTest(unittest.TestCase):
 
     def test_currentsong(self):
         track = Track()
-        self.b.current_playlist.playlist = Playlist(tracks=[track])
+        self.b.current_playlist.load([track])
         self.b.playback.current_track = track
         result = self.h.handle_request(u'currentsong')
         self.assert_(u'file: ' in result)
@@ -258,7 +258,7 @@ class StatusHandlerTest(unittest.TestCase):
 
     def test_status_method_when_playlist_loaded_contains_song(self):
         track = Track()
-        self.b.current_playlist.load(Playlist(tracks=[track]))
+        self.b.current_playlist.load([track])
         self.b.playback.current_track = track
         result = dict(self.h._status_status())
         self.assert_('song' in result)
@@ -266,7 +266,7 @@ class StatusHandlerTest(unittest.TestCase):
 
     def test_status_method_when_playlist_loaded_contains_pos_as_songid(self):
         track = Track()
-        self.b.current_playlist.load(Playlist(tracks=[track]))
+        self.b.current_playlist.load([track])
         self.b.playback.current_track = track
         result = dict(self.h._status_status())
         self.assert_('songid' in result)
@@ -274,7 +274,7 @@ class StatusHandlerTest(unittest.TestCase):
 
     def test_status_method_when_playlist_loaded_contains_id_as_songid(self):
         track = Track(id=1)
-        self.b.current_playlist.load(Playlist(tracks=[track]))
+        self.b.current_playlist.load([track])
         self.b.playback.current_track = track
         result = dict(self.h._status_status())
         self.assert_('songid' in result)
@@ -447,7 +447,7 @@ class PlaybackControlHandlerTest(unittest.TestCase):
 
     def test_pause_off(self):
         track = Track()
-        self.b.current_playlist.playlist = Playlist(tracks=[track])
+        self.b.current_playlist.load([track])
         self.b.playback.current_track = track
         self.h.handle_request(u'play "0"')
         self.h.handle_request(u'pause "1"')
@@ -457,7 +457,7 @@ class PlaybackControlHandlerTest(unittest.TestCase):
 
     def test_pause_on(self):
         track = Track()
-        self.b.current_playlist.playlist = Playlist(tracks=[track])
+        self.b.current_playlist.load([track])
         self.b.playback.current_track = track
         self.h.handle_request(u'play "0"')
         result = self.h.handle_request(u'pause "1"')
@@ -466,7 +466,7 @@ class PlaybackControlHandlerTest(unittest.TestCase):
 
     def test_play_without_pos(self):
         track = Track()
-        self.b.current_playlist.playlist = Playlist(tracks=[track])
+        self.b.current_playlist.load([track])
         self.b.playback.current_track = track
         self.b.playback.state = self.b.playback.PAUSED
         result = self.h.handle_request(u'play')
@@ -474,42 +474,42 @@ class PlaybackControlHandlerTest(unittest.TestCase):
         self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
 
     def test_play_with_pos(self):
-        self.b.current_playlist.load(Playlist(tracks=[Track()]))
+        self.b.current_playlist.load([Track()])
         result = self.h.handle_request(u'play "0"')
         self.assert_(u'OK' in result)
         self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
 
     def test_play_with_pos_out_of_bounds(self):
-        self.b.current_playlist.load(Playlist())
+        self.b.current_playlist.load([])
         result = self.h.handle_request(u'play "0"')
         self.assertEqual(result[0], u'ACK [2@0] {play} Bad song index')
         self.assertEqual(self.b.playback.STOPPED, self.b.playback.state)
 
     def test_play_minus_one_plays_first_in_playlist(self):
-        track = Track(id=0)
-        self.b.current_playlist.load(Playlist(tracks=[track]))
+        track = Track()
+        self.b.current_playlist.load([track])
         result = self.h.handle_request(u'play "-1"')
         self.assert_(u'OK' in result)
         self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
         self.assertEqual(self.b.playback.current_track, track)
 
     def test_playid(self):
-        self.b.current_playlist.load(Playlist(tracks=[Track(id=0)]))
-        result = self.h.handle_request(u'playid "0"')
+        self.b.current_playlist.load([Track()])
+        result = self.h.handle_request(u'playid "1"')
         self.assert_(u'OK' in result)
         self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
 
     def test_playid_minus_one_plays_first_in_playlist(self):
-        track = Track(id=0)
-        self.b.current_playlist.load(Playlist(tracks=[track]))
+        track = Track()
+        self.b.current_playlist.load([track])
         result = self.h.handle_request(u'playid "-1"')
         self.assert_(u'OK' in result)
         self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
         self.assertEqual(self.b.playback.current_track, track)
 
     def test_playid_which_does_not_exist(self):
-        self.b.current_playlist.load(Playlist(tracks=[Track(id=0)]))
-        result = self.h.handle_request(u'playid "1"')
+        self.b.current_playlist.load([Track()])
+        result = self.h.handle_request(u'playid "12345"')
         self.assertEqual(result[0], u'ACK [50@0] {playid} No such song')
 
     def test_previous(self):
@@ -539,12 +539,12 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
     def test_add(self):
         needle = Track(uri='dummy://foo')
         self.b.library._library = [Track(), Track(), needle, Track()]
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(), Track(), Track(), Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'add "dummy://foo"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 6)
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5], needle)
+        self.assertEqual(len(self.b.current_playlist.tracks), 6)
+        self.assertEqual(self.b.current_playlist.tracks[5], needle)
         self.assertEqual(len(result), 1)
         self.assert_(u'OK' in result)
 
@@ -556,33 +556,33 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
     def test_addid_without_songpos(self):
         needle = Track(uri='dummy://foo', id=137)
         self.b.library._library = [Track(), Track(), needle, Track()]
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(), Track(), Track(), Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'addid "dummy://foo"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 6)
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5], needle)
+        self.assertEqual(len(self.b.current_playlist.tracks), 6)
+        self.assertEqual(self.b.current_playlist.tracks[5], needle)
         self.assert_(u'Id: 137' in result)
         self.assert_(u'OK' in result)
 
     def test_addid_with_songpos(self):
         needle = Track(uri='dummy://foo', id=137)
         self.b.library._library = [Track(), Track(), needle, Track()]
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(), Track(), Track(), Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'addid "dummy://foo" "3"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 6)
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3], needle)
+        self.assertEqual(len(self.b.current_playlist.tracks), 6)
+        self.assertEqual(self.b.current_playlist.tracks[3], needle)
         self.assert_(u'Id: 137' in result)
         self.assert_(u'OK' in result)
 
     def test_addid_with_songpos_out_of_bounds_should_ack(self):
         needle = Track(uri='dummy://foo', id=137)
         self.b.library._library = [Track(), Track(), needle, Track()]
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(), Track(), Track(), Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'addid "dummy://foo" "6"')
         self.assertEqual(result[0], u'ACK [2@0] {addid} Bad song index')
 
@@ -591,118 +591,122 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
         self.assertEqual(result[0], u'ACK [50@0] {addid} No such song')
 
     def test_clear(self):
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(), Track(), Track(), Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'clear')
-        self.assertEqual(self.b.current_playlist.playlist.length, 0)
+        self.assertEqual(len(self.b.current_playlist.tracks), 0)
         self.assertEqual(self.b.playback.current_track, None)
         self.assert_(u'OK' in result)
 
     def test_delete_songpos(self):
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(id=1), Track(id=2), Track(id=3), Track(id=4), Track(id=5)])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'delete "2"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 4)
+        self.assertEqual(len(self.b.current_playlist.tracks), 4)
         self.assert_(u'OK' in result)
 
     def test_delete_songpos_out_of_bounds(self):
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(), Track(), Track(), Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'delete "5"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index')
 
     def test_delete_open_range(self):
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(id=1), Track(id=2), Track(id=3), Track(id=4), Track(id=5)])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'delete "1:"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 1)
+        self.assertEqual(len(self.b.current_playlist.tracks), 1)
         self.assert_(u'OK' in result)
 
     def test_delete_closed_range(self):
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(id=1), Track(id=2), Track(id=3), Track(id=4), Track(id=5)])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'delete "1:3"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 3)
+        self.assertEqual(len(self.b.current_playlist.tracks), 3)
         self.assert_(u'OK' in result)
 
     def test_delete_range_out_of_bounds(self):
-        self.b.current_playlist.playlist = Playlist(
-            tracks=[Track(), Track(), Track(), Track(), Track()])
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.b.current_playlist.load(
+            [Track(), Track(), Track(), Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         result = self.h.handle_request(u'delete "5:7"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 5)
+        self.assertEqual(len(self.b.current_playlist.tracks), 5)
         self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index')
 
     def test_deleteid(self):
-        self.b.current_playlist.load(Playlist(tracks=[Track(id=0), Track()]))
-        self.assertEqual(self.b.current_playlist.playlist.length, 2)
-        result = self.h.handle_request(u'deleteid "0"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 1)
+        self.b.current_playlist.load([Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 2)
+        result = self.h.handle_request(u'deleteid "2"')
+        self.assertEqual(len(self.b.current_playlist.tracks), 1)
         self.assert_(u'OK' in result)
 
     def test_deleteid_does_not_exist(self):
-        self.b.current_playlist.load(Playlist(tracks=[Track(id=1), Track()]))
-        self.assertEqual(self.b.current_playlist.playlist.length, 2)
-        result = self.h.handle_request(u'deleteid "0"')
-        self.assertEqual(self.b.current_playlist.playlist.length, 2)
+        self.b.current_playlist.load([Track(), Track()])
+        self.assertEqual(len(self.b.current_playlist.tracks), 2)
+        result = self.h.handle_request(u'deleteid "12345"')
+        self.assertEqual(len(self.b.current_playlist.tracks), 2)
         self.assertEqual(result[0], u'ACK [50@0] {deleteid} No such song')
 
     def test_move_songpos(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e'), Track(name='f')]))
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
         result = self.h.handle_request(u'move "1" "0"')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'b')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'e')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'b')
+        self.assertEqual(self.b.current_playlist.tracks[1].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
+        self.assertEqual(self.b.current_playlist.tracks[4].name, 'e')
+        self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
         self.assert_(u'OK' in result)
 
     def test_move_open_range(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e'), Track(name='f')]))
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
         result = self.h.handle_request(u'move "2:" "0"')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'c')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'd')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'e')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'f')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'b')
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'c')
+        self.assertEqual(self.b.current_playlist.tracks[1].name, 'd')
+        self.assertEqual(self.b.current_playlist.tracks[2].name, 'e')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'f')
+        self.assertEqual(self.b.current_playlist.tracks[4].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[5].name, 'b')
         self.assert_(u'OK' in result)
 
     def test_move_closed_range(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e'), Track(name='f')]))
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
         result = self.h.handle_request(u'move "1:3" "0"')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'b')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'c')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'e')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'b')
+        self.assertEqual(self.b.current_playlist.tracks[1].name, 'c')
+        self.assertEqual(self.b.current_playlist.tracks[2].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
+        self.assertEqual(self.b.current_playlist.tracks[4].name, 'e')
+        self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
         self.assert_(u'OK' in result)
 
     def test_moveid(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e', id=137), Track(name='f')]))
-        result = self.h.handle_request(u'moveid "137" "2"')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'b')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'e')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'c')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'd')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        result = self.h.handle_request(u'moveid "5" "2"')
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[1].name, 'b')
+        self.assertEqual(self.b.current_playlist.tracks[2].name, 'e')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'c')
+        self.assertEqual(self.b.current_playlist.tracks[4].name, 'd')
+        self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
         self.assert_(u'OK' in result)
 
     def test_playlist_returns_same_as_playlistinfo(self):
@@ -715,54 +719,70 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
         self.assert_(u'ACK [0@0] {} Not implemented' in result)
 
     def test_playlistfind_by_filename(self):
-        result = self.h.handle_request(u'playlistfind "filename" "file:///dev/null"')
+        result = self.h.handle_request(
+            u'playlistfind "filename" "file:///dev/null"')
         self.assert_(u'OK' in result)
 
     def test_playlistfind_by_filename_without_quotes(self):
-        result = self.h.handle_request(u'playlistfind filename "file:///dev/null"')
+        result = self.h.handle_request(
+            u'playlistfind filename "file:///dev/null"')
         self.assert_(u'OK' in result)
 
     def test_playlistfind_by_filename_in_current_playlist(self):
-        self.b.current_playlist.playlist = Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(uri='file:///exists')])
-        result = self.h.handle_request(u'playlistfind filename "file:///exists"')
+        result = self.h.handle_request(
+            u'playlistfind filename "file:///exists"')
         self.assert_(u'file: file:///exists' in result)
         self.assert_(u'OK' in result)
 
     def test_playlistid_without_songid(self):
-        self.b.current_playlist.load(Playlist(
-            tracks=[Track(name='a', id=33), Track(name='b', id=38)]))
+        self.b.current_playlist.load([Track(name='a'), Track(name='b')])
         result = self.h.handle_request(u'playlistid')
         self.assert_(u'Title: a' in result)
-        self.assert_(u'Id: 33' in result)
         self.assert_(u'Title: b' in result)
-        self.assert_(u'Id: 38' in result)
         self.assert_(u'OK' in result)
 
     def test_playlistid_with_songid(self):
-        self.b.current_playlist.load(Playlist(
-            tracks=[Track(name='a', id=33), Track(name='b', id=38)]))
-        result = self.h.handle_request(u'playlistid "38"')
+        self.b.current_playlist.load([Track(name='a'), Track(name='b')])
+        result = self.h.handle_request(u'playlistid "2"')
         self.assert_(u'Title: a' not in result)
-        self.assert_(u'Id: 33' not in result)
+        self.assert_(u'Id: 1' not in result)
         self.assert_(u'Title: b' in result)
-        self.assert_(u'Id: 38' in result)
+        self.assert_(u'Id: 2' in result)
         self.assert_(u'OK' in result)
 
     def test_playlistid_with_not_existing_songid_fails(self):
-        self.b.current_playlist.load(Playlist(
-            tracks=[Track(name='a', id=33), Track(name='b', id=38)]))
+        self.b.current_playlist.load([Track(name='a'), Track(name='b')])
         result = self.h.handle_request(u'playlistid "25"')
         self.assertEqual(result[0], u'ACK [50@0] {playlistid} No such song')
 
     def test_playlistinfo_without_songpos_or_range(self):
-        # FIXME testing just ok is not enough
+        self.b.current_playlist.load([
+            Track(name='a'), Track(name='b'), Track(name='c'),
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
         result = self.h.handle_request(u'playlistinfo')
+        self.assert_(u'Title: a' in result)
+        self.assert_(u'Title: b' in result)
+        self.assert_(u'Title: c' in result)
+        self.assert_(u'Title: d' in result)
+        self.assert_(u'Title: e' in result)
+        self.assert_(u'Title: f' in result)
         self.assert_(u'OK' in result)
 
     def test_playlistinfo_with_songpos(self):
-        # FIXME testing just ok is not enough
-        result = self.h.handle_request(u'playlistinfo "5"')
+        self.b.current_playlist.load([
+            Track(name='a'), Track(name='b'), Track(name='c'),
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        result = self.h.handle_request(u'playlistinfo "4"')
+        self.assert_(u'Title: a' not in result)
+        self.assert_(u'Title: b' not in result)
+        self.assert_(u'Title: c' not in result)
+        self.assert_(u'Title: d' not in result)
+        self.assert_(u'Title: e' in result)
+        self.assert_(u'Title: f' not in result)
         self.assert_(u'OK' in result)
 
     def test_playlistinfo_with_negative_songpos_same_as_playlistinfo(self):
@@ -771,13 +791,39 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
         self.assertEqual(result1, result2)
 
     def test_playlistinfo_with_open_range(self):
-        # FIXME testing just ok is not enough
-        result = self.h.handle_request(u'playlistinfo "10:"')
+        self.b.current_playlist.load([
+            Track(name='a'), Track(name='b'), Track(name='c'),
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        result = self.h.handle_request(u'playlistinfo "2:"')
+        self.assert_(u'Title: a' not in result)
+        self.assert_(u'Title: b' not in result)
+        self.assert_(u'Title: c' in result)
+        self.assert_(u'Title: d' in result)
+        self.assert_(u'Title: e' in result)
+        self.assert_(u'Title: f' in result)
         self.assert_(u'OK' in result)
 
     def test_playlistinfo_with_closed_range(self):
-        # FIXME testing just ok is not enough
+        self.b.current_playlist.load([
+            Track(name='a'), Track(name='b'), Track(name='c'),
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        result = self.h.handle_request(u'playlistinfo "2:4"')
+        self.assert_(u'Title: a' not in result)
+        self.assert_(u'Title: b' not in result)
+        self.assert_(u'Title: c' in result)
+        self.assert_(u'Title: d' in result)
+        self.assert_(u'Title: e' not in result)
+        self.assert_(u'Title: f' not in result)
+        self.assert_(u'OK' in result)
+
+    def test_playlistinfo_with_too_high_start_of_range_returns_arg_error(self):
         result = self.h.handle_request(u'playlistinfo "10:20"')
+        self.assert_(u'ACK [2@0] {playlistinfo} Bad song index' in result)
+
+    def test_playlistinfo_with_too_high_end_of_range_returns_ok(self):
+        result = self.h.handle_request(u'playlistinfo "0:20"')
         self.assert_(u'OK' in result)
 
     def test_playlistsearch(self):
@@ -785,8 +831,8 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
         self.assert_(u'ACK [0@0] {} Not implemented' in result)
 
     def test_plchanges(self):
-        self.b.current_playlist.load(Playlist(
-            tracks=[Track(name='a'), Track(name='b'), Track(name='c')]))
+        self.b.current_playlist.load(
+            [Track(name='a'), Track(name='b'), Track(name='c')])
         result = self.h.handle_request(u'plchanges "0"')
         self.assert_(u'Title: a' in result)
         self.assert_(u'Title: b' in result)
@@ -794,8 +840,8 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
         self.assert_(u'OK' in result)
 
     def test_plchangesposid(self):
-        self.b.current_playlist.load(Playlist(
-            tracks=[Track(id=11), Track(id=12), Track(id=13)]))
+        self.b.current_playlist.load(
+            [Track(id=11), Track(id=12), Track(id=13)])
         result = self.h.handle_request(u'plchangesposid "0"')
         self.assert_(u'cpos: 0' in result)
         self.assert_(u'Id: 11' in result)
@@ -806,64 +852,69 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
         self.assert_(u'OK' in result)
 
     def test_shuffle_without_range(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e'), Track(name='f')]))
-        self.assertEqual(self.b.current_playlist.version, 1)
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        version = self.b.current_playlist.version
         result = self.h.handle_request(u'shuffle')
-        self.assertEqual(self.b.current_playlist.version, 2)
+        self.assert_(version < self.b.current_playlist.version)
         self.assert_(u'OK' in result)
 
     def test_shuffle_with_open_range(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e'), Track(name='f')]))
-        self.assertEqual(self.b.current_playlist.version, 1)
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        version = self.b.current_playlist.version
         result = self.h.handle_request(u'shuffle "4:"')
-        self.assertEqual(self.b.current_playlist.version, 2)
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'b')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
+        self.assert_(version < self.b.current_playlist.version)
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[1].name, 'b')
+        self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
         self.assert_(u'OK' in result)
 
     def test_shuffle_with_closed_range(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e'), Track(name='f')]))
-        self.assertEqual(self.b.current_playlist.version, 1)
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        version = self.b.current_playlist.version
         result = self.h.handle_request(u'shuffle "1:3"')
-        self.assertEqual(self.b.current_playlist.version, 2)
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'e')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
+        self.assert_(version < self.b.current_playlist.version)
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
+        self.assertEqual(self.b.current_playlist.tracks[4].name, 'e')
+        self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
         self.assert_(u'OK' in result)
 
     def test_swap(self):
-        self.b.current_playlist.load(Playlist(tracks=[
+        self.b.current_playlist.load([
             Track(name='a'), Track(name='b'), Track(name='c'),
-            Track(name='d'), Track(name='e'), Track(name='f')]))
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
         result = self.h.handle_request(u'swap "1" "4"')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'e')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'b')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[1].name, 'e')
+        self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
+        self.assertEqual(self.b.current_playlist.tracks[4].name, 'b')
+        self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
         self.assert_(u'OK' in result)
 
     def test_swapid(self):
-        self.b.current_playlist.load(Playlist(tracks=[
-            Track(name='a'), Track(name='b', id=13), Track(name='c'),
-            Track(name='d'), Track(name='e', id=29), Track(name='f')]))
-        result = self.h.handle_request(u'swapid "13" "29"')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'e')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'b')
-        self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
+        self.b.current_playlist.load([
+            Track(name='a'), Track(name='b'), Track(name='c'),
+            Track(name='d'), Track(name='e'), Track(name='f'),
+        ])
+        result = self.h.handle_request(u'swapid "2" "5"')
+        self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
+        self.assertEqual(self.b.current_playlist.tracks[1].name, 'e')
+        self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
+        self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
+        self.assertEqual(self.b.current_playlist.tracks[4].name, 'b')
+        self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
         self.assert_(u'OK' in result)
 
 
diff --git a/tests/mpd/serializer_test.py b/tests/mpd/serializer_test.py
new file mode 100644
index 00000000..38c240c2
--- /dev/null
+++ b/tests/mpd/serializer_test.py
@@ -0,0 +1,57 @@
+import datetime as dt
+import unittest
+
+from mopidy.models import Album, Artist, Playlist, Track
+from mopidy.mpd import serializer
+
+class TrackMpdFormatTest(unittest.TestCase):
+    def test_mpd_format_for_empty_track(self):
+        result = serializer.track_to_mpd_format(Track())
+        self.assert_(('file', '') in result)
+        self.assert_(('Time', 0) in result)
+        self.assert_(('Artist', '') in result)
+        self.assert_(('Title', '') in result)
+        self.assert_(('Album', '') in result)
+        self.assert_(('Track', 0) in result)
+        self.assert_(('Date', '') in result)
+
+    def test_mpd_format_for_nonempty_track(self):
+        track = Track(
+            uri=u'a uri',
+            artists=[Artist(name=u'an artist')],
+            name=u'a name',
+            album=Album(name=u'an album', num_tracks=13),
+            track_no=7,
+            date=dt.date(1977, 1, 1),
+            length=137000,
+        )
+        result = serializer.track_to_mpd_format(track, position=9, cpid=122)
+        self.assert_(('file', 'a uri') in result)
+        self.assert_(('Time', 137) in result)
+        self.assert_(('Artist', 'an artist') in result)
+        self.assert_(('Title', 'a name') in result)
+        self.assert_(('Album', 'an album') in result)
+        self.assert_(('Track', '7/13') in result)
+        self.assert_(('Date', dt.date(1977, 1, 1)) in result)
+        self.assert_(('Pos', 9) in result)
+        self.assert_(('Id', 122) in result)
+
+    def test_mpd_format_artists(self):
+        track = Track(artists=[Artist(name=u'ABBA'), Artist(name=u'Beatles')])
+        self.assertEqual(serializer.track_artists_to_mpd_format(track),
+            u'ABBA, Beatles')
+
+
+class PlaylistMpdFormatTest(unittest.TestCase):
+    def test_mpd_format(self):
+        playlist = Playlist(tracks=[
+            Track(track_no=1), Track(track_no=2), Track(track_no=3)])
+        result = serializer.playlist_to_mpd_format(playlist)
+        self.assertEqual(len(result), 3)
+
+    def test_mpd_format_with_range(self):
+        playlist = Playlist(tracks=[
+            Track(track_no=1), Track(track_no=2), Track(track_no=3)])
+        result = serializer.playlist_to_mpd_format(playlist, 1, 2)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(dict(result[0])['Track'], 2)