def test(self):
        lib = SongFileLibrary()

        with temp_filename() as song_fn:
            song = AudioFile({"~filename": song_fn})
            song.sanitize()
            lib.add([song])

            with temp_filename() as xml_fn:
                with open(xml_fn, "wb") as h:
                    x = get_example_xml(song("~filename"), 1, 1371802107)
                    h.write(x)

                handler = self.mod.RBDBContentHandler(lib)
                xml.sax.parse(xml_fn, handler)

                self.assertEqual(song("~#rating"), 0.2)
                self.assertEqual(song("~#lastplayed"), 1371802107)
                self.assertEqual(song("~#playcount"), 1)

                with open(xml_fn, "wb") as h:
                    x = get_example_xml(song("~filename"), 2, 1371802107 - 1)
                    h.write(x)

                handler = self.mod.RBDBContentHandler(lib)
                xml.sax.parse(xml_fn, handler)

                self.assertEqual(song("~#rating"), 0.4)
                self.assertEqual(song("~#lastplayed"), 1371802107)

    def test_embedded_special_cover_words(self):
        """Tests that words incidentally containing embedded "special" words 
        album keywords (e.g. cover, disc, back) don't trigger
        See Issue 818"""

        song = AudioFile(
            {"~filename": "tests/data/asong.ogg", "album": "foobar", "title": "Ode to Baz", "artist": "Q-Man"}
        )
        files = [
            self.full_path(f)
            for f in [
                "back.jpg",
                "discovery.jpg",
                "Pharell - frontin'.jpg",
                "nickelback - Curb.jpg",
                "foobar.jpg",
                "folder.jpg",  # Though this is debatable
                "Q-Man - foobar.jpg",
                "Q-man - foobar (cover).jpg",
            ]
        ]
        for f in files:
            file(f, "w").close()
            self.files.append(f)
            cover = song.find_cover()
            if cover:
                actual = os.path.abspath(cover.name)
                self.failUnlessEqual(actual, f, '"%s" should trump "%s"' % (f, actual))
            else:
                self.failUnless(f, self.full_path("back.jpg"))

 def test_to_dump_unicode(self):
     b = AudioFile(bar_1_1)
     b[u"öäü"] = u"öäü"
     dump = b.to_dump()
     n = AudioFile()
     n.from_dump(dump)
     self.assertEqual(n[u"öäü"], u"öäü")

 def setUp(self):
     self.rg_data = {"replaygain_album_gain": "-1.00 dB",
                     "replaygain_album_peak": "1.1",
                     "replaygain_track_gain": "+1.0000001 dB",
                     "replaygain_track_peak": "0.9"}
     self.song = AudioFile(self.rg_data)
     self.no_rg_song = AudioFile()

 def test_people(self):
     q = AudioFile([("performer:vocals", "A"), ("performer:guitar", "B"),
                    ("performer", "C"), ("arranger", "A"),
                    ("albumartist", "B"), ("artist", "C")])
     self.failUnlessEqual(q.list("~people"), ["C", "B", "A"])
     self.failUnlessEqual(q.list("~people:roles"),
                      ["C", "B (Guitar)", "A (Arrangement, Vocals)"])

 def test_msic(self):
     with realized(self.b):
         self.b.activate()
         self.b.statusbar(1000)
         self.b.statusbar(1)
         song = AudioFile({"~filename": fsnative(u"/fake")})
         song.sanitize()
         self.b.scroll(song)

 def setUp(self):
     config.init()
     player = NullPlayer()
     song = AudioFile()
     song.bookmarks = [(10, "bla")]
     song.sanitize("/")
     player.song = song
     self.player = player

 def test_performers(self):
     q = AudioFile([("performer:vocals", "A"), ("performer:guitar", "B"), ("performer", "C")])
     self.failUnless("A (Vocals)" in q.list("~performers"))
     self.failUnless("B (Guitar)" in q.list("~performers"))
     self.failUnless("C" in q.list("~performers"))
     self.failUnless("A (Vocals)" in q.list("~people"))
     self.failUnless("B (Guitar)" in q.list("~people"))
     self.failUnlessEqual(len(q.list("~performers")), 3)

 def test_people_mix(self):
     q = AudioFile([
         ("performer:arrangement", "A"),
         ("arranger", "A"),
         ("performer", "A"),
         ("performer:foo", "A"),
     ])
     self.failUnlessEqual(q.list("~people"), ["A"])
     self.failUnlessEqual(q.list("~people:roles"),
                          ["A (Arrangement, Arrangement, Foo)"])

 def test_menuitem(self):
     library = SongLibrary()
     library.librarian = SongLibrarian()
     a = AudioFile({"~filename": fsnative(u"/foo")})
     a.sanitize()
     x = RatingsMenuItem([a], library)
     x.set_rating(0, [a], library)
     x.destroy()
     library.destroy()
     library.librarian.destroy()

def _print_playing(app, fstring="<artist~album~tracknumber~title>"):
    from quodlibet.formats._audio import AudioFile
    from quodlibet.pattern import Pattern

    song = app.player.song
    if song is None:
        song = AudioFile({"~filename": fsnative(u"/")})
        song.sanitize()

    return Pattern(fstring).format(song) + "\n"

 def test_remove_all(self):
     song = AudioFile()
     song.add("foo", "bar")
     song.add("foo", "another")
     song.add("foo", "one more")
     song.remove("foo")
     self.assertFalse("foo" in song)

    def test_people_multi_value(self):
        q = AudioFile([
            ("arranger", "A\nX"),
            ("performer", "A\nY"),
            ("performer:foo", "A\nX"),
        ])

        self.failUnlessEqual(q.list("~people"), ["A", "Y", "X"])
        self.failUnlessEqual(
            q.list("~people:roles"),
            ["A (Arrangement, Foo)", "Y", "X (Arrangement, Foo)"])

    def test_to_dump(self):
        dump = bar_1_1.to_dump()
        num = len(set(bar_1_1.keys()) | INTERN_NUM_DEFAULT)
        self.failUnlessEqual(dump.count("\n"), num + 2)
        for key, value in bar_1_1.items():
            self.failUnless(key in dump)
            self.failUnless(value in dump)
        for key in INTERN_NUM_DEFAULT:
            self.failUnless(key in dump)

        n = AudioFile()
        n.from_dump(dump)
        self.failUnless(set(dump.split("\n")) == set(n.to_dump().split("\n")))

 def test_album_key(self):
     album_key_tests = [
         ({}, ("", "")),
         ({"album": "foo"}, (("foo",), "")),
         ({"labelid": "foo"}, ("", "foo")),
         ({"musicbrainz_albumid": "foo"}, ("", "foo")),
         ({"album": "foo", "labelid": "bar"}, (("foo",), "bar")),
         ({"album": "foo", "labelid": "bar", "musicbrainz_albumid": "quux"}, (("foo",), "bar")),
     ]
     for tags, expected in album_key_tests:
         afile = AudioFile(**tags)
         afile.sanitize("/dir/fn")
         self.failUnlessEqual(afile.album_key, expected)

def print_playing(fstring="<artist~album~tracknumber~title>"):
    from quodlibet.formats._audio import AudioFile
    from quodlibet.parse import Pattern

    try:
        text = open(const.CURRENT, "rb").read()
        song = AudioFile()
        song.from_dump(text)
        print_(Pattern(fstring).format(song))
        quodlibet.exit()
    except (OSError, IOError):
        print_(_("No song is currently playing."))
        quodlibet.exit(True)

 def getline(key, value):
     song = AudioFile({"~filename": "/dev/null"})
     song.sanitize()
     song[key] = value
     lines = format_tags(song).splitlines()
     if not lines:
         return ""
     if len(lines) == 1:
         return lines[0]
     # hackery since title defaults to the filename..
     for l in lines:
         if not l.startswith("Title"):
             return l

 def test_peoplesort(self):
     q = AudioFile([("performer:vocals", "The A"),
                    ("performersort:vocals", "A, The"),
                    ("performer:guitar", "The B"),
                    ("performersort:guitar", "B, The"),
                    ("performer", "The C"),
                    ("performersort", "C, The"),
                    ("albumartist", "The B"),
                    ("albumartistsort", "B, The")])
     self.failUnlessEqual(q.list("~peoplesort"),
                          ["B, The", "C, The", "A, The"])
     self.failUnlessEqual(q.list("~peoplesort:roles"),
                          ["B, The (Guitar)", "C, The", "A, The (Vocals)"])

 def test_sanitize(self):
     q = AudioFile(quux)
     b = AudioFile(bar_1_1)
     q.sanitize()
     b.pop("~filename")
     self.failUnlessRaises(ValueError, b.sanitize)
     n = AudioFile({"artist": u"foo\0bar", "title": u"baz\0", "~filename": "whatever"})
     n.sanitize()
     self.failUnlessEqual(n["artist"], "foo\nbar")
     self.failUnlessEqual(n["title"], "baz")

 def test_album_id_values_with_artist(self):
     album_key_tests = [
         # The artist should now appear
         ({"album": "foo", "artist": "bar", "title": "baz"}, {"album": "foo", "artist": "bar"}),
         # But albumartist > album still
         ({"album": "foo", "albumartist": "bar", "artist": "baz"}, {"album": "foo", "albumartist": "bar"}),
     ]
     for tags, expected in album_key_tests:
         if expected is None:
             expected = tags
         afile = AudioFile(**tags)
         afile.sanitize("/dir/fn")
         # Use alternate version, that includes artist in dict
         self.failUnlessEqual(afile._album_id_values(True), HashableDict(expected))