Exemple #1
0
        value = b"\xff\xff\x81"
        self.assertRaises(ValueError, value.decode, "utf-8")
        self.assertRaises(ValueError, value.decode, "cp1252")
        enc = locale.getpreferredencoding()

        # we need the decoding to fail for this test to work...
        try:
            value.decode(enc)
        except ValueError:
            pass
        else:
            return

        if not PY2:
            value = value.decode(enc, "surrogateescape")
        res, out = self.call("--TALB", value, self.filename)
        self.failIfEqual(res, 0)
        self.failUnless("TALB" in out)

    def test_invalid_escape(self):
        res, out = self.call("--TALB", '\\xaz', '-e', self.filename)
        self.failIfEqual(res, 0)
        self.failUnless("TALB" in out)

        res, out = self.call("--TALB", '\\', '-e', self.filename)
        self.failIfEqual(res, 0)
        self.failUnless("TALB" in out)


add(TMid3v2)
Exemple #2
0
        self.failIf(value and value != NOTFOUND)

    def test_flac_reference_delete_readd(self):
        if not have_flac: return
        self.audio.delete()
        self.audio.tags.clear()
        self.audio["foobar"] = "foobar" * 1000
        self.audio.save()
        self.scan_file()
        value = os.system("flac --ogg -t %s 2> %s" % (self.filename, devnull))
        self.failIf(value and value != NOTFOUND)

    def test_not_my_ogg(self):
        fn = os.path.join('tests', 'data', 'empty.ogg')
        self.failUnlessRaises(IOError, type(self.audio), fn)
        self.failUnlessRaises(IOError, self.audio.save, fn)
        self.failUnlessRaises(IOError, self.audio.delete, fn)

    def test_mime(self):
        self.failUnless("audio/x-oggflac" in self.audio.mime)


add(TOggFLAC)

NOTFOUND = os.system("tools/notarealprogram 2> %s" % devnull)

have_flac = True
if os.system("flac 2> %s > %s" % (devnull, devnull)) == NOTFOUND:
    have_flac = False
    print("WARNING: Skipping Ogg FLAC reference tests.")
import os
import glob

from tests import add
from tests.test_tools import _TTools


class TMutagenInspect(_TTools):

    TOOL_NAME = 'mutagen-inspect'

    def test_basic(self):
        base = os.path.join('tests', 'data')
        self.paths = glob.glob(os.path.join(base, 'empty*'))
        self.paths += glob.glob(os.path.join(base, 'silence-*'))

        for path in self.paths:
            res, out = self.call(path)
            self.failIf(res)
            self.failUnless(out.strip())
            self.failIf("Unknown file type" in out)
            self.failIf("Errno" in out)


add(TMutagenInspect)
Exemple #4
0
SAMPLE = os.path.join(DIR, "data", "click.mpc")
OLD = os.path.join(DIR, "data", "oldtag.apev2")
BROKEN = os.path.join(DIR, "data", "brokentag.apev2")
LYRICS2 = os.path.join(DIR, "data", "apev2-lyricsv2.mp3")
INVAL_ITEM_COUNT = os.path.join(DIR, "data", "145-invalid-item-count.apev2")

class Tis_valid_apev2_key(TestCase):

    def test_yes(self):
        for key in ["foo", "Foo", "   f ~~~"]:
            self.failUnless(is_valid_apev2_key(key))

    def test_no(self):
        for key in ["\x11hi", "ffoo\xFF", u"\u1234", "a", "", "foo" * 100]:
            self.failIf(is_valid_apev2_key(key))
add(Tis_valid_apev2_key)


class TAPEInvalidItemCount(TestCase):
    # http://code.google.com/p/mutagen/issues/detail?id=145

    def test_load(self):
        x = mutagen.apev2.APEv2(INVAL_ITEM_COUNT)
        self.failUnlessEqual(len(x.keys()), 17)

add(TAPEInvalidItemCount)


class TAPEWriter(TestCase):
    offset = 0
Exemple #5
0
            MusepackHeaderError, Musepack,
            os.path.join("tests", "data", "emptyfile.mp3"))

    def test_almost_my_file(self):
        self.failUnlessRaises(
            MusepackHeaderError, MusepackInfo, StringIO("MP+" + "\x00" * 100))

    def test_pprint(self):
        self.sv7.pprint()
        self.sv5.pprint()
        self.sv4.pprint()

    def test_mime(self):
        self.failUnless("audio/x-musepack" in self.sv7.mime)

add(TMusepack)


class TMusepackWithID3(TestCase):
    SAMPLE = os.path.join("tests", "data", "click.mpc")

    def setUp(self):
        fd, self.NEW = mkstemp(suffix='mpc')
        os.close(fd)
        shutil.copy(self.SAMPLE, self.NEW)
        self.failUnlessEqual(file(self.SAMPLE).read(), file(self.NEW).read())

    def tearDown(self):
        os.unlink(self.NEW)

    def test_ignore_id3(self):
Exemple #6
0
import os

from tests import add
from tests.test_tools import _TTools


class TMutagenPony(_TTools):

    TOOL_NAME = "mutagen-pony"

    def test_basic(self):
        base = os.path.join('tests', 'data')
        res, out = self.call(base)
        self.failIf(res)
        self.failUnless("Report for tests/data" in out)

add(TMutagenPony)
Exemple #7
0
    def test_length(self):
        self.failUnlessAlmostEqual(self.audio.info.length, 3.68, 2)

    def test_not_my_file(self):
        self.failUnlessRaises(IOError, WavPack,
                              os.path.join("tests", "data", "empty.ogg"))

    def test_pprint(self):
        self.audio.pprint()

    def test_mime(self):
        self.failUnless("audio/x-wavpack" in self.audio.mime)


add(TWavPack)


class TWavPackNoLength(TestCase):
    def setUp(self):
        self.audio = WavPack(os.path.join("tests", "data", "no_length.wv"))

    def test_version(self):
        self.failUnlessEqual(self.audio.info.version, 0x407)

    def test_channels(self):
        self.failUnlessEqual(self.audio.info.channels, 2)

    def test_sample_rate(self):
        self.failUnlessEqual(self.audio.info.sample_rate, 44100)
def test_call_with_add():
    ast = asg(v("a"), call(v("t"), [add(v("b"), c(2)), add(c(1), v("c"))]))

    parser = Parser(Tokenizer("a = t(b+2, 1+c)"))
    assert parser.statement() == ast
Exemple #9
0
        self.failUnlessEqual(self.rdict.get("a", "b"),
                             self.fdict.get("a", "b"))
        self.failUnlessEqual(self.rdict.get("foo"), self.fdict.get("foo"))

    def test_repr(self):
        self.failUnlessEqual(repr(self.rdict), repr(self.fdict))

    def test_len(self):
        self.failUnlessEqual(len(self.rdict), len(self.fdict))

    def tearDown(self):
        self.failUnlessEqual(self.fdict, self.rdict)
        self.failUnlessEqual(self.rdict, self.fdict)


add(TDictMixin)


class Tcdata(TestCase):

    ZERO = b"\x00\x00\x00\x00"
    LEONE = b"\x01\x00\x00\x00"
    BEONE = b"\x00\x00\x00\x01"
    NEGONE = b"\xff\xff\xff\xff"

    def test_int_le(self):
        self.failUnlessEqual(cdata.int_le(self.ZERO), 0)
        self.failUnlessEqual(cdata.int_le(self.LEONE), 1)
        self.failUnlessEqual(cdata.int_le(self.BEONE), 16777216)
        self.failUnlessEqual(cdata.int_le(self.NEGONE), -1)
Exemple #10
0
        try:
            len(data)
        except OverflowError:
            # Py_ssize_t is still only 32 bits on this system.
            self.failUnlessRaises(OverflowError, Atom.render, "data", data)
        else:
            data = Atom.render("data", data)
            self.failUnlessEqual(len(data), 4 + 4 + 8 + 4)

    def test_length_0(self):
        fileobj = StringIO("\x00\x00\x00\x00atom")
        Atom(fileobj)
        self.failUnlessEqual(fileobj.tell(), 8)


add(TAtom)


class TAtoms(TestCase):
    uses_mmap = False
    filename = os.path.join("tests", "data", "has-tags.m4a")

    def setUp(self):
        self.atoms = Atoms(open(self.filename, "rb"))

    def test___contains__(self):
        self.failUnless(self.atoms["moov"])
        self.failUnless(self.atoms["moov.udta"])
        self.failUnlessRaises(KeyError, self.atoms.__getitem__, "whee")

    def test_name(self):
Exemple #11
0
# $Id: test_expr.py 1527 2006-05-07 16:41:16Z mu $
from tests import TestCase, add
from yasm import Expression
import operator


class TExpression(TestCase):
    def test_create(self):
        e1 = Expression(operator.add, 1, 2)
        e2 = Expression('+', 1, 2)

        self.assertEquals(e1.get_intnum(), e1.get_intnum())

    def test_extract(self):
        e1 = Expression('/', 15, 5)
        self.assertEquals(e1.get_intnum(), 3)
        self.assertRaises(ValueError, e1.extract_segoff)
        self.assertRaises(ValueError, e1.extract_wrt)


add(TExpression)
Exemple #12
0
    # which we need to make a best guess for.
    #
    #def test_find_last_invalid_sync(self):
    #    data = StringIO("if you think this is an OggS, you're crazy")
    #    self.failUnlessRaises(OggError, OggPage.find_last, data, 0)

    def test_find_last_invalid_sync(self):
        data = StringIO("if you think this is an OggS, you're crazy")
        page = OggPage.find_last(data, 0)
        self.failIf(page)

    def tearDown(self):
        self.fileobj.close()


add(TOggPage)


class TOggFileType(TestCase):
    def scan_file(self):
        fileobj = open(self.filename, "rb")
        try:
            try:
                while True:
                    page = OggPage(fileobj)
            except EOFError:
                pass
        finally:
            fileobj.close()

    def test_pprint_empty(self):
Exemple #13
0
        id3 = EasyID3(self.filename)
        self.failUnlessEqual(self.id3["date"], ["2004"])

        self.id3["date"] = "2004"
        self.id3.save(self.filename)
        id3 = EasyID3(self.filename)
        self.failUnlessEqual(self.id3["date"], ["2004"])

    def test_write_date_double(self):
        self.id3["date"] = ["2004", "2005"]
        self.id3.save(self.filename)
        id3 = EasyID3(self.filename)
        self.failUnlessEqual(self.id3["date"], ["2004", "2005"])

        self.id3["date"] = ["2004", "2005"]
        self.id3.save(self.filename)
        id3 = EasyID3(self.filename)
        self.failUnlessEqual(self.id3["date"], ["2004", "2005"])

    def test_write_invalid(self):
        self.failUnlessRaises(ValueError, self.id3.__getitem__, "notvalid")
        self.failUnlessRaises(ValueError, self.id3.__delitem__, "notvalid")
        self.failUnlessRaises(ValueError, self.id3.__setitem__, "notvalid",
                              "tests")

    def tearDown(self):
        os.unlink(self.filename)


add(TEasyID3)
Exemple #14
0
        self.failUnless(isinstance(value, bytes))

    def test_low_unicode(self):
        value = utf8(u"1234")
        self.failUnlessEqual(value, b"1234")
        self.failUnless(isinstance(value, bytes))

    def test_high_unicode(self):
        value = utf8(u"\u1234")
        self.failUnlessEqual(value, b'\xe1\x88\xb4')
        self.failUnless(isinstance(value, bytes))

    def test_invalid(self):
        self.failUnlessRaises(TypeError, utf8, 1234)

add(Tutf8)

class Tcdata(TestCase):

    ZERO = b"\x00\x00\x00\x00"
    LEONE = b"\x01\x00\x00\x00"
    BEONE = b"\x00\x00\x00\x01"
    NEGONE = b"\xff\xff\xff\xff"

    def test_int_le(self):
        self.failUnlessEqual(cdata.int_le(self.ZERO), 0)
        self.failUnlessEqual(cdata.int_le(self.LEONE), 1)
        self.failUnlessEqual(cdata.int_le(self.BEONE), 16777216)
        self.failUnlessEqual(cdata.int_le(self.NEGONE), -1)

    def test_uint_le(self):
Exemple #15
0
        self.failUnlessEqual(self.audio.info.sample_rate, 44100)

    def test_length(self):
        self.failUnlessAlmostEqual(self.audio.info.length, 3.68, 2)

    def test_not_my_file(self):
        self.failUnlessRaises(
            IOError, WavPack, os.path.join("tests", "data", "empty.ogg"))

    def test_pprint(self):
        self.audio.pprint()

    def test_mime(self):
        self.failUnless("audio/x-wavpack" in self.audio.mime)

add(TWavPack)


class TWavPackNoLength(TestCase):

    def setUp(self):
        self.audio = WavPack(os.path.join("tests", "data", "no_length.wv"))

    def test_version(self):
        self.failUnlessEqual(self.audio.info.version, 0x407)

    def test_channels(self):
        self.failUnlessEqual(self.audio.info.channels, 2)

    def test_sample_rate(self):
        self.failUnlessEqual(self.audio.info.sample_rate, 44100)
Exemple #16
0
    def test_ixor(self):
        a = IntNum(-234)
        b = IntNum(432)
        a ^= b
        b ^= a
        a ^= b
        self.assertEquals(a, 432)
        self.assertEquals(b, -234)

    def test_cmp(self):
        a = IntNum(-1)
        b = IntNum(0)
        c = IntNum(1)
        self.assert_(a < b < c)
        self.assert_(a <= b <= c)
        self.assert_(c >= b >= a)
        self.assert_(c > b > a)
        self.assert_(a != b != c)

    def test_abs(self):
        a = IntNum(-1)
        b = IntNum(0)
        c = IntNum(1)

        self.assertEquals(abs(a), abs(c))
        self.assertEquals(abs(a) - abs(c), abs(b))


add(TIntNum)
Exemple #17
0
        self.failUnless(isinstance(value, str))

    def test_low_unicode(self):
        value = utf8(u"1234")
        self.failUnlessEqual(value, "1234")
        self.failUnless(isinstance(value, str))

    def test_high_unicode(self):
        value = utf8(u"\u1234")
        self.failUnlessEqual(value, '\xe1\x88\xb4')
        self.failUnless(isinstance(value, str))

    def test_invalid(self):
        self.failUnlessRaises(TypeError, utf8, 1234)

add(Tutf8)

class TDictMixin(TestCase):
    uses_mmap = False

    def setUp(self):
        self.fdict = FDict()
        self.rdict = {}
        self.fdict["foo"] = self.rdict["foo"] = "bar"

    def test_getsetitem(self):
        self.failUnlessEqual(self.fdict["foo"], "bar")
        self.failUnlessRaises(KeyError, self.fdict.__getitem__, "bar")

    def test_has_key_contains(self):
        self.failUnless("foo" in self.fdict)
Exemple #18
0
    except ImportError:
        pass
    else:

        def test_yaml(self, filename=filename):
            doc = BulletML.FromDocument(open(filename, "rU"))
            doc = yaml.load(yaml.dump(doc))
            doc = yaml.load(yaml.dump(doc))

        setattr(Texamples_yaml, "test_" + basename, test_yaml)

    def test_repr(self, filename=filename):
        doc = BulletML.FromDocument(open(filename, "rU"))
        repr(doc)

    setattr(Texamples_repr, "test_" + basename, test_repr)

    def test_run(self, filename=filename):
        doc = BulletML.FromDocument(open(filename, "rU"))
        bullets = [Bullet.FromDocument(doc)]
        for i in range(100):
            for bullet in bullets:
                bullets.extend(bullet.step())

    setattr(Texamples_run, "test_" + basename, test_run)

add(Texamples_xml)
add(Texamples_yaml)
add(Texamples_repr)
add(Texamples_run)
Exemple #19
0
    def setUp(self):
        self.ofr = OptimFROG(os.path.join("tests", "data", "empty.ofr"))
        self.ofs = OptimFROG(os.path.join("tests", "data", "empty.ofs"))

    def test_channels(self):
        self.failUnlessEqual(self.ofr.info.channels, 2)
        self.failUnlessEqual(self.ofs.info.channels, 2)

    def test_sample_rate(self):
        self.failUnlessEqual(self.ofr.info.sample_rate, 44100)
        self.failUnlessEqual(self.ofs.info.sample_rate, 44100)

    def test_length(self):
        self.failUnlessAlmostEqual(self.ofr.info.length, 3.68, 2)
        self.failUnlessAlmostEqual(self.ofs.info.length, 3.68, 2)

    def test_not_my_file(self):
        self.failUnlessRaises(
            OptimFROGHeaderError, OptimFROG,
            os.path.join("tests", "data", "empty.ogg"))
        self.failUnlessRaises(
            OptimFROGHeaderError, OptimFROG,
            os.path.join("tests", "data", "click.mpc"))

    def test_pprint(self):
        self.failUnless(self.ofr.pprint())
        self.failUnless(self.ofs.pprint())

add(TOptimFROG)
Exemple #20
0
        fd, self.filename = mkstemp(suffix='.ogg')
        os.close(fd)
        shutil.copy(original, self.filename)

        # append the second file
        first = open(self.filename, "ab")
        to_append = os.path.join('tests', 'data', 'multipage-setup.ogg')
        second = open(to_append, "rb")
        first.write(second.read())
        second.close()
        first.close()

    def tearDown(self):
        super(TMOggSPlit, self).tearDown()
        os.unlink(self.filename)

    def test_basic(self):
        d = os.path.dirname(self.filename)
        p = os.path.join(d, "%(stream)d.%(ext)s")
        res, out = self.call("--pattern", p, self.filename)
        self.failIf(res)
        self.failIf(out)

        for stream in [1002429366, 1806412655]:
            stream_path = os.path.join(d, str(stream) + ".ogg")
            self.failUnless(os.path.exists(stream_path))
            os.unlink(stream_path)


add(TMOggSPlit)
Exemple #21
0
    def test_invalid_not_first(self):
        page = OggPage(open(self.filename, "rb"))
        page.first = False
        self.failUnlessRaises(IOError, OggSpeexInfo, BytesIO(page.write()))

    def test_vendor(self):
        self.failUnless(
            self.audio.tags.vendor.startswith("Encoded with Speex 1.1.12"))
        self.failUnlessRaises(KeyError, self.audio.tags.__getitem__, "vendor")

    def test_not_my_ogg(self):
        fn = os.path.join('tests', 'data', 'empty.oggflac')
        self.failUnlessRaises(IOError, type(self.audio), fn)
        self.failUnlessRaises(IOError, self.audio.save, fn)
        self.failUnlessRaises(IOError, self.audio.delete, fn)

    def test_multiplexed_in_headers(self):
        shutil.copy(
            os.path.join("tests", "data", "multiplexed.spx"), self.filename)
        audio = self.Kind(self.filename)
        audio.tags["foo"] = ["bar"]
        audio.save()
        audio = self.Kind(self.filename)
        self.failUnlessEqual(audio.tags["foo"], ["bar"])

    def test_mime(self):
        self.failUnless("audio/x-speex" in self.audio.mime)

add(TOggSpeex)
Exemple #22
0
from tests import TestCase, add


class TWavPack(TestCase):
    uses_mmap = False

    def setUp(self):
        self.audio = WavPack(os.path.join("tests", "data", "silence-44-s.wv"))

    def test_channels(self):
        self.failUnlessEqual(self.audio.info.channels, 2)

    def test_sample_rate(self):
        self.failUnlessEqual(self.audio.info.sample_rate, 44100)

    def test_length(self):
        self.failUnlessAlmostEqual(self.audio.info.length, 3.68, 2)

    def test_not_my_file(self):
        self.failUnlessRaises(IOError, WavPack,
                              os.path.join("tests", "data", "empty.ogg"))

    def test_pprint(self):
        self.audio.pprint()

    def test_mime(self):
        self.failUnless("audio/x-wavpack" in self.audio.mime)


add(TWavPack)
        original = os.path.join('tests', 'data', 'multipagecomment.ogg')
        fd, self.filename = mkstemp(suffix='.ogg')
        os.close(fd)
        shutil.copy(original, self.filename)

        # append the second file
        first = open(self.filename, "ab")
        to_append = os.path.join('tests', 'data', 'multipage-setup.ogg')
        second = open(to_append, "rb")
        first.write(second.read())
        second.close()
        first.close()

    def tearDown(self):
        super(TMOggSPlit, self).tearDown()
        os.unlink(self.filename)

    def test_basic(self):
        d = os.path.dirname(self.filename)
        p = os.path.join(d, "%(stream)d.%(ext)s")
        res, out = self.call("--pattern", p, self.filename)
        self.failIf(res)
        self.failIf(out)

        for stream in [1002429366, 1806412655]:
            stream_path = os.path.join(d, str(stream) + ".ogg")
            self.failUnless(os.path.exists(stream_path))
            os.unlink(stream_path)

add(TMOggSPlit)
Exemple #24
0
    def test_save_grown_split_setup_packet_reference(self):
        if ogg is None: return
        fn = os.path.join("tests", "data", "multipage-setup.ogg")
        shutil.copy(fn, self.filename)
        audio = OggVorbis(self.filename)
        audio["foobar"] = ["quux" * 50000]
        tags = audio.tags
        self.failUnless(tags)
        audio.save()
        self.audio = OggVorbis(self.filename)
        self.failUnlessEqual(self.audio.tags, tags)
        vfc = ogg.vorbis.VorbisFile(self.filename).comment()
        for key in self.audio:
            self.failUnlessEqual(vfc[key], self.audio[key])
        self.ogg_reference(self.filename)

    def test_mime(self):
        self.failUnless("audio/vorbis" in self.audio.mime)


# Don't think ogg.vorbis has been ported to Python3.
# See http://ekyo.nerim.net/software/pyogg/index.html for news/porting.
# I would do it, but I have no experience with C->Python wrappers. Maybe later.
try:
    import ogg.vorbis
except ImportError:
    print("WARNING: Skipping Ogg Vorbis reference tests.")
    ogg = None

add(TOggVorbis)
        self.failUnlessEqual(qltk.get_top_parent(w), w)
        self.failUnlessEqual(qltk.get_top_parent(l), None)
        w.destroy(); l.destroy()

    def test_gtp_packed(self):
        w = gtk.Window(); l = gtk.Label(); w.add(l)
        self.failUnlessEqual(qltk.get_top_parent(w), w)
        self.failUnlessEqual(qltk.get_top_parent(l), w)
        w.destroy(); l.destroy()

    def test_is_accel(self):
        e = gtk.gdk.Event(gtk.gdk.KEY_RELEASE)
        self.failIf(qltk.is_accel(e, "a"))

        e = gtk.gdk.Event(gtk.gdk.KEY_PRESS)
        e.keyval = 65293
        e.state =  gtk.gdk.CONTROL_MASK
        self.failUnless(qltk.is_accel(e, "<ctrl>Return"))

    def test_popup_menu_under_widget(self):
        w = gtk.Window()
        l = gtk.Label()
        w.add(l)
        m = gtk.Menu()
        l.realize()
        qltk.popup_menu_under_widget(m, l, 1, 0)
        w.destroy()
        m.destroy()

add(TQltk)
Exemple #26
0
    def test_numeric_pairs(self):
        for tag in ["tracknumber", "discnumber"]:
            self.mp4[tag] = "3"
            self.failUnlessEqual(self.mp4[tag], ["3"])
            self.mp4.save()
            mp4 = EasyMP4(self.filename)
            self.failUnlessEqual(mp4[tag], ["3"])

            del (mp4[tag])
            self.failIf(tag in mp4)
            self.failUnlessRaises(KeyError, mp4.__delitem__, tag)

            self.mp4[tag] = "3/10"
            self.failUnlessEqual(self.mp4[tag], ["3/10"])
            self.mp4.save()
            mp4 = EasyMP4(self.filename)
            self.failUnlessEqual(mp4[tag], ["3/10"])

            del (mp4[tag])
            self.failIf(tag in mp4)
            self.failUnlessRaises(KeyError, mp4.__delitem__, tag)

            self.failUnlessRaises(ValueError, self.mp4.__setitem__, tag,
                                  "hello")

    def tearDown(self):
        os.unlink(self.filename)


add(TEasyMP4)
Exemple #27
0
from mutagen.flac import to_int_be, Padding, VCFLACDict, MetadataBlock, error
from mutagen.flac import StreamInfo, SeekTable, CueSheet, FLAC, delete, Picture
from tests.test__vorbis import TVCommentDict, VComment
try: from os.path import devnull
except ImportError: devnull = "/dev/null"

class Tto_int_be(TestCase):
    uses_mmap = False

    def test_empty(self): self.failUnlessEqual(to_int_be(""), 0)
    def test_0(self): self.failUnlessEqual(to_int_be("\x00"), 0)
    def test_1(self): self.failUnlessEqual(to_int_be("\x01"), 1)
    def test_256(self): self.failUnlessEqual(to_int_be("\x01\x00"), 256)
    def test_long(self):
        self.failUnlessEqual(to_int_be("\x01\x00\x00\x00\x00"), 2**32)
add(Tto_int_be)

class TVCFLACDict(TVCommentDict):
    uses_mmap = False

    Kind = VCFLACDict

    def test_roundtrip_vc(self):
        self.failUnlessEqual(self.c, VComment(self.c.write() + "\x01"))
add(TVCFLACDict)

class TMetadataBlock(TestCase):
    uses_mmap = False

    def test_empty(self):
        self.failUnlessEqual(MetadataBlock("").write(), "")
Exemple #28
0
class Tis_valid_apev2_key(TestCase):
    def test_yes(self):
        for key in ["foo", "Foo", "   f ~~~"]:
            self.failUnless(is_valid_apev2_key(key))

    def test_no(self):
        for key in ["\x11hi", "ffoo\xFF", u"\u1234", "a", "", "foo" * 100]:
            self.failIf(is_valid_apev2_key(key))

    if PY3:

        def test_py3(self):
            self.assertRaises(TypeError, is_valid_apev2_key, b"abc")


add(Tis_valid_apev2_key)


class TAPEInvalidItemCount(TestCase):
    # http://code.google.com/p/mutagen/issues/detail?id=145

    def test_load(self):
        x = mutagen.apev2.APEv2(INVAL_ITEM_COUNT)
        self.failUnlessEqual(len(x.keys()), 17)


add(TAPEInvalidItemCount)


class TAPEWriter(TestCase):
    offset = 0
        mp3 = MP3(os.path.join("tests", "data", "silence-44-s.mp3"))
        self.failUnless(mp3.tags)
        self.failUnlessRaises(Exception, mp3.add_tags)

    def test_save_no_tags(self):
        self.mp3.tags = None
        self.failUnlessRaises(ValueError, self.mp3.save)

    def test_mime(self):
        self.failUnless("audio/mp3" in self.mp3.mime)

    def tearDown(self):
        os.unlink(self.filename)


add(TMP3)


class TMPEGInfo(TestCase):
    uses_mmap = False

    def test_not_real_file(self):
        filename = os.path.join("tests", "data", "silence-44-s-v1.mp3")
        fileobj = StringIO(file(filename, "rb").read(20))
        MPEGInfo(fileobj)

    def test_empty(self):
        fileobj = StringIO("")
        self.failUnlessRaises(IOError, MPEGInfo, fileobj)

        fileobj = cBytesIO(page.write())
        self.failUnlessRaises(IOError, OggTheoraInfo, fileobj)

    def test_vendor(self):
        self.failUnless(
            self.audio.tags.vendor.startswith("Xiph.Org libTheora"))
        self.failUnlessRaises(KeyError, self.audio.tags.__getitem__, "vendor")

    def test_not_my_ogg(self):
        fn = os.path.join('tests', 'data', 'empty.ogg')
        self.failUnlessRaises(IOError, type(self.audio), fn)
        self.failUnlessRaises(IOError, self.audio.save, fn)
        self.failUnlessRaises(IOError, self.audio.delete, fn)

    def test_length(self):
        self.failUnlessAlmostEqual(5.5, self.audio.info.length, 1)
        self.failUnlessAlmostEqual(0.75, self.audio2.info.length, 2)

    def test_bitrate(self):
        self.failUnlessEqual(16777215, self.audio3.info.bitrate)

    def test_module_delete(self):
        delete(self.filename)
        self.scan_file()
        self.failIf(OggTheora(self.filename).tags)

    def test_mime(self):
        self.failUnless("video/x-theora" in self.audio.mime)

add(TOggTheora)
Exemple #31
0
    class FakeMeta(Metadata):
        def __init__(self): pass

    def test_virtual_constructor(self):
        self.failUnlessRaises(NotImplementedError, Metadata, "filename")

    def test_virtual_save(self):
        self.failUnlessRaises(NotImplementedError, self.FakeMeta().save)
        self.failUnlessRaises(
            NotImplementedError, self.FakeMeta().save, "filename")

    def test_virtual_delete(self):
        self.failUnlessRaises(NotImplementedError, self.FakeMeta().delete)
        self.failUnlessRaises(
            NotImplementedError, self.FakeMeta().delete, "filename")
add(TMetadata)

class TFileType(TestCase):
    uses_mmap = False

    def setUp(self):
        self.vorbis = File(os.path.join("tests", "data", "empty.ogg"))

    def test_delitem_not_there(self):
        self.failUnlessRaises(KeyError, self.vorbis.__delitem__, "foobar")

    def test_delitem(self):
        self.vorbis["foobar"] = "quux"
        del(self.vorbis["foobar"])
        self.failIf("quux" in self.vorbis)
add(TFileType)
Exemple #32
0
        self.failUnlessEqual(self.audio.info.channels, 1)
        self.failUnless(self.audio.tags.vendor.startswith("libopus"))

    def test_module_delete(self):
        delete(self.filename)
        self.scan_file()
        self.failIf(self.Kind(self.filename).tags)

    def test_mime(self):
        self.failUnless("audio/ogg" in self.audio.mime)
        self.failUnless("audio/ogg; codecs=opus" in self.audio.mime)

    def test_invalid_not_first(self):
        page = OggPage(open(self.filename, "rb"))
        page.first = False
        self.failUnlessRaises(IOError, OggOpusInfo, BytesIO(page.write()))

    def test_unsupported_version(self):
        page = OggPage(open(self.filename, "rb"))
        data = bytearray(page.packets[0])

        data[8] = 0x03
        page.packets[0] = bytes(data)
        OggOpusInfo(BytesIO(page.write()))

        data[8] = 0x10
        page.packets[0] = bytes(data)
        self.failUnlessRaises(IOError, OggOpusInfo, BytesIO(page.write()))

add(TOggOpus)
Exemple #33
0
                          'global')

    def test_iters(self):
        tab = self.symtab
        tab.declare("foo", None, 0)
        tab.declare("bar", None, 0)
        tab.declare("baz", None, 0)

        # while ordering is not known, it must be consistent
        self.assertEquals(list(tab.keys()), list(tab.iterkeys()))
        self.assertEquals(list(tab.values()), list(tab.itervalues()))
        self.assertEquals(list(tab.items()), list(tab.iteritems()))
        self.assertEquals(list(tab.iteritems()), zip(tab.keys(), tab.values()))


add(TSymbolTable)


class TSymbolAttr(TestCase):
    def setUp(self):
        self.symtab = SymbolTable()
        self.declsym = self.symtab.declare("foo", None, 0)

    def test_visibility(self):
        sym = self.symtab.declare("local1", None, 0)
        self.assertEquals(sym.visibility, set())
        sym = self.symtab.declare("local2", '', 0)
        self.assertEquals(sym.visibility, set())
        sym = self.symtab.declare("local3", 'local', 0)
        self.assertEquals(sym.visibility, set())
        sym = self.symtab.declare("global", 'global', 0)
Exemple #34
0
    def test_sample_rate(self):
        self.failUnlessEqual(self.mac399.info.sample_rate, 44100)
        self.failUnlessEqual(self.mac396.info.sample_rate, 44100)
        self.failUnlessEqual(self.mac390.info.sample_rate, 44100)

    def test_length(self):
        self.failUnlessAlmostEqual(self.mac399.info.length, 3.68, 2)
        self.failUnlessAlmostEqual(self.mac396.info.length, 3.68, 2)
        self.failUnlessAlmostEqual(self.mac390.info.length, 15.63, 2)

    def test_version(self):
        self.failUnlessEqual(self.mac399.info.version, 3.99)
        self.failUnlessEqual(self.mac396.info.version, 3.96)
        self.failUnlessEqual(self.mac390.info.version, 3.90)

    def test_not_my_file(self):
        self.failUnlessRaises(MonkeysAudioHeaderError, MonkeysAudio,
                              os.path.join("tests", "data", "empty.ogg"))
        self.failUnlessRaises(MonkeysAudioHeaderError, MonkeysAudio,
                              os.path.join("tests", "data", "click.mpc"))

    def test_mime(self):
        self.failUnless("audio/x-ape" in self.mac399.mime)

    def test_pprint(self):
        self.failUnless(self.mac399.pprint())
        self.failUnless(self.mac396.pprint())


add(TMonkeysAudio)
Exemple #35
0
        self.failUnlessRaises(NotImplementedError, Metadata, "filename")

    def test_load(self):
        m = Metadata()
        self.failUnlessRaises(NotImplementedError, m.load, "filename")

    def test_virtual_save(self):
        self.failUnlessRaises(NotImplementedError, self.FakeMeta().save)
        self.failUnlessRaises(
            NotImplementedError, self.FakeMeta().save, "filename")

    def test_virtual_delete(self):
        self.failUnlessRaises(NotImplementedError, self.FakeMeta().delete)
        self.failUnlessRaises(
            NotImplementedError, self.FakeMeta().delete, "filename")
add(TMetadata)

class TFileType(TestCase):

    def setUp(self):
        self.vorbis = File(os.path.join("tests", "data", "empty.ogg"))

    def test_delitem_not_there(self):
        self.failUnlessRaises(KeyError, self.vorbis.__delitem__, "foobar")

    def test_add_tags(self):
        self.failUnlessRaises(NotImplementedError, FileType().add_tags)

    def test_delitem(self):
        self.vorbis["foobar"] = "quux"
        del(self.vorbis["foobar"])
Exemple #36
0
    def test_length_0(self):
        fileobj = StringIO("\x00\x00\x00\x00atom" + 40 * "\x00")
        atom = Atom(fileobj)
        self.failUnlessEqual(fileobj.tell(), 48)
        self.failUnlessEqual(atom.length, 48)

    def test_length_0_container(self):
        data = StringIO(struct.pack(">I4s", 0, "moov") +
                        Atom.render("data", "whee"))
        atom = Atom(data)
        self.failUnlessEqual(len(atom.children), 1)
        self.failUnlessEqual(atom.length, 20)
        self.failUnlessEqual(atom.children[-1].length, 12)

add(TAtom)

class TAtoms(TestCase):
    uses_mmap = False
    filename = os.path.join("tests", "data", "has-tags.m4a")

    def setUp(self):
        self.atoms = Atoms(open(self.filename, "rb"))

    def test___contains__(self):
        self.failUnless(self.atoms["moov"])
        self.failUnless(self.atoms["moov.udta"])
        self.failUnlessRaises(KeyError, self.atoms.__getitem__, "whee")

    def test_name(self):
        self.failUnlessEqual(self.atoms.atoms[0].name, "ftyp")
        self.failUnlessRaises(IOError, TrueAudio, filename)

    def test_module_delete(self):
        delete(os.path.join("tests", "data", "empty.tta"))

    def test_delete(self):
        self.audio.delete()
        self.failIf(self.audio.tags)

    def test_pprint(self):
        self.failUnless(self.audio.pprint())

    def test_save_reload(self):
        try:
            fd, filename = mkstemp(suffix='.tta')
            os.close(fd)
            shutil.copy(self.audio.filename, filename)
            audio = TrueAudio(filename)
            audio.add_tags()
            audio.tags.add(TIT1(encoding=0, text="A Title"))
            audio.save()
            audio = TrueAudio(filename)
            self.failUnlessEqual(audio["TIT1"], "A Title")
        finally:
            os.unlink(filename)

    def test_mime(self):
        self.failUnless("audio/x-tta" in self.audio.mime)

add(TTrueAudio)
Exemple #38
0
        self.assertEquals(
            s.write(f, [(u"A", 100)]), b"\xff\xfeA\x00\x00\x00\x00\x00\x00d")

        # utf-16be
        f.encoding = 2
        self.assertEqual(s.read(f, s.write(f, values)), (values, b""))
        self.assertEquals(
            s.write(f, [(u"A", 100)]), b"\x00A\x00\x00\x00\x00\x00d")

        # utf-8
        f.encoding = 3
        self.assertEqual(s.read(f, s.write(f, values)), (values, b""))
        self.assertEquals(s.write(f, [(u"A", 100)]), b"A\x00\x00\x00\x00d")


add(SpecSanityChecks)


class SpecValidateChecks(TestCase):

    def test_volumeadjustmentspec(self):
        from mutagen.id3 import VolumeAdjustmentSpec
        s = VolumeAdjustmentSpec('gain')
        self.assertRaises(ValueError, s.validate, None, 65)

    def test_volumepeakspec(self):
        from mutagen.id3 import VolumePeakSpec
        s = VolumePeakSpec('peak')
        self.assertRaises(ValueError, s.validate, None, 2)

    def test_bytespec(self):
        self.__save_tags(
            {self.SINGLE: "1/2", self.FALLBACK: "3"},
            {self.SINGLE: "1", self.MAIN: "2", self.FALLBACK: "3"})

    def test_save_all(self):
        # not clear what to do here...
        self.__save_tags(
            {self.SINGLE: "1/2", self.MAIN: "4", self.FALLBACK: "3"},
            {self.SINGLE: "1", self.MAIN: "4", self.FALLBACK: "3"})


class TTrackTotal(TTotalTagsBase):
    MAIN = "tracktotal"
    FALLBACK = "totaltracks"
    SINGLE = "tracknumber"
add(TTrackTotal)


class TDiscTotal(TTotalTagsBase):
    MAIN = "disctotal"
    FALLBACK = "totaldiscs"
    SINGLE = "discnumber"
add(TDiscTotal)


class TFLACFile(TVCFile):
    def setUp(self):
        TVCFile.setUp(self)
        self.filename = tempfile.mkstemp(".flac")[1]
        shutil.copy(os.path.join('tests', 'data', 'empty.flac'), self.filename)
        self.song = FLACFile(self.filename)
        fd, filename = mkstemp()
        try:
            os.close(fd)
            self.library.add(self.Frange(30))
            self.library.save(filename)

            library = self.Library()
            library.load(filename)
            self.failUnlessEqual(
                sorted(self.library.items()), sorted(library.items()))
        finally:
            os.unlink(filename)

    def tearDown(self):
        self.library.destroy()
add(TLibrary)

class TLibrarian(TestCase):
    Fake = Fake
    Frange = staticmethod(Frange)
    Librarian = Librarian
    Library = Library

    def setUp(self):
        self.librarian = self.Librarian()
        self.Library.librarian = self.librarian
        self.lib1 = self.Library("One")
        self.lib2 = self.Library("Two")

        self.added_1 = []
        self.changed_1 = []
Exemple #41
0
        fileobj = cBytesIO(page.write())
        self.failUnlessRaises(IOError, OggTheoraInfo, fileobj)

    def test_vendor(self):
        self.failUnless(
            self.audio.tags.vendor.startswith("Xiph.Org libTheora"))
        self.failUnlessRaises(KeyError, self.audio.tags.__getitem__, "vendor")

    def test_not_my_ogg(self):
        fn = os.path.join('tests', 'data', 'empty.ogg')
        self.failUnlessRaises(IOError, type(self.audio), fn)
        self.failUnlessRaises(IOError, self.audio.save, fn)
        self.failUnlessRaises(IOError, self.audio.delete, fn)

    def test_length(self):
        self.failUnlessAlmostEqual(5.5, self.audio.info.length, 1)
        self.failUnlessAlmostEqual(0.75, self.audio2.info.length, 2)

    def test_bitrate(self):
        self.failUnlessEqual(16777215, self.audio3.info.bitrate)

    def test_module_delete(self):
        delete(self.filename)
        self.scan_file()
        self.failIf(OggTheora(self.filename).tags)

    def test_mime(self):
        self.failUnless("video/x-theora" in self.audio.mime)

add(TOggTheora)
Exemple #42
0
    def test_save_grown_split_setup_packet_reference(self):
        if ogg is None:
            return
        fn = os.path.join("tests", "data", "multipage-setup.ogg")
        shutil.copy(fn, self.filename)
        audio = OggVorbis(self.filename)
        audio["foobar"] = ["quux" * 50000]
        tags = audio.tags
        self.failUnless(tags)
        audio.save()
        self.audio = OggVorbis(self.filename)
        self.failUnlessEqual(self.audio.tags, tags)
        vfc = ogg.vorbis.VorbisFile(self.filename).comment()
        for key in self.audio:
            self.failUnlessEqual(vfc[key], self.audio[key])
        self.ogg_reference(self.filename)

    def test_mime(self):
        self.failUnless("audio/vorbis" in self.audio.mime)

# Don't think ogg.vorbis has been ported to Python3.
# See http://ekyo.nerim.net/software/pyogg/index.html for news/porting.
# I would do it, but I have no experience with C->Python wrappers. Maybe later.
try:
    import ogg.vorbis
except ImportError:
    print("WARNING: Skipping Ogg Vorbis reference tests.")
    ogg = None

add(TOggVorbis)
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation

import sys

from tests import TestCase, add
from quodlibet import formats

class TFormats(TestCase):
    def test_presence(self):
        self.failUnless(formats.midi)
        self.failUnless(formats.mod)
        self.failUnless(formats.monkeysaudio)
        self.failUnless(formats.mpc)
        self.failUnless(formats.mp3)
        self.failUnless(formats.mp4)
        self.failUnless(formats.spc)
        self.failUnless(formats.trueaudio)

    def test_infos(self):
        self.failUnless(formats._infos[".mp3"] is formats.mp3.MP3File)

    def test_migration(self):
        self.failUnless(formats.mp3 is sys.modules["quodlibet.formats.mp3"])
        self.failUnless(formats.mp3 is sys.modules["quodlibet/formats/mp3"])
        self.failUnless(formats.mp3 is sys.modules["formats.mp3"])

        self.failUnless(formats.xiph is sys.modules["formats.flac"])
        self.failUnless(formats.xiph is sys.modules["formats.oggvorbis"])
add(TFormats)
    def test_invalid_not_first(self):
        page = OggPage(open(self.filename, "rb"))
        page.first = False
        self.failUnlessRaises(IOError, OggSpeexInfo, cBytesIO(page.write()))

    def test_vendor(self):
        self.failUnless(
            self.audio.tags.vendor.startswith("Encoded with Speex 1.1.12"))
        self.failUnlessRaises(KeyError, self.audio.tags.__getitem__, "vendor")

    def test_not_my_ogg(self):
        fn = os.path.join('tests', 'data', 'empty.oggflac')
        self.failUnlessRaises(IOError, type(self.audio), fn)
        self.failUnlessRaises(IOError, self.audio.save, fn)
        self.failUnlessRaises(IOError, self.audio.delete, fn)

    def test_multiplexed_in_headers(self):
        shutil.copy(os.path.join("tests", "data", "multiplexed.spx"),
                    self.filename)
        audio = self.Kind(self.filename)
        audio.tags["foo"] = ["bar"]
        audio.save()
        audio = self.Kind(self.filename)
        self.failUnlessEqual(audio.tags["foo"], ["bar"])

    def test_mime(self):
        self.failUnless("audio/x-speex" in self.audio.mime)


add(TOggSpeex)
Exemple #45
0
    try:
        import yaml
    except ImportError:
        pass
    else:
        def test_yaml(self, filename=filename):
            doc = BulletML.FromDocument(open(filename, "rU"))
            doc = yaml.load(yaml.dump(doc))
            doc = yaml.load(yaml.dump(doc))
        setattr(Texamples_yaml, "test_" + basename, test_yaml)

    def test_repr(self, filename=filename):
        doc = BulletML.FromDocument(open(filename, "rU"))
        repr(doc)
    setattr(Texamples_repr, "test_" + basename, test_repr)

    def test_run(self, filename=filename):
        doc = BulletML.FromDocument(open(filename, "rU"))
        bullets = [Bullet.FromDocument(doc)]
        for i in range(100):
            for bullet in bullets:
                bullets.extend(bullet.step())
    setattr(Texamples_run, "test_" + basename, test_run)
                

add(Texamples_xml)
add(Texamples_yaml)
add(Texamples_repr)
add(Texamples_run)
        self.c = TaskController()
        self.f = FakeStatusBar()
        self.c.parent = self.f

    def test_reparent(self):
        def set_parent(p):
            self.c.parent = p
        set_parent(None)
        set_parent(FakeStatusBar())
        self.assertRaises(ValueError, set_parent, FakeStatusBar())

    def test_multiple_tasks(self):
        self.assertEquals(self.c.active_tasks, [])
        self.assertNotEqual(self.c.source, "")
        t1 = Task("src", "desc", controller = self.c)
        self.assertEquals(self.c.source, "src")
        self.assertEquals(self.c.active_tasks, [t1])
        t1.update(0.5)
        self.assertEquals(self.c.frac, 0.5)
        t2 = Task("src2", "desc2", controller = self.c)
        self.assertEquals(self.c.source, _("Active tasks"))
        self.assertEquals(self.c.frac, 0.25)
        Task("src3", "desc3", controller = self.c, known_length=False)
        self.assertAlmostEqual(self.c.frac, 0.5/3)
        t1.finish()
        t2.finish()
        self.assertEquals(self.c.desc, "desc3")
        self.assertEquals(self.c.frac, None)

add(TTaskController)
from tests import TestCase, add

from quodlibet.qltk.sortdialog import SortDialog

class TSortDialog(TestCase):
    def test(self):
        SortDialog(None).destroy()

add(TSortDialog)
        thumb = thumbnails.get_thumbnail(s.filename, (50, 60))

        #check for right scaling
        s.failUnless(thumb)
        s.failUnlessEqual((thumb.get_width(), thumb.get_height()), (50, 3))

        #test the thumbnail filename
        uri = "file://" + urllib.pathname2url(s.filename)
        name = hash.md5(uri).hexdigest() + ".png"
        path = os.path.expanduser("~/.thumbnails")
        # newer spec
        new_path = os.path.expanduser("~/.cache/thumbnails")
        if os.path.exists(new_path):
            path = new_path
        path = os.path.join(path, "normal", name)

        s.failUnless(os.path.isfile(path))

        #check for metadata
        thumb_pb = gtk.gdk.pixbuf_new_from_file(path)
        meta_mtime = thumb_pb.get_option("tEXt::Thumb::MTime")
        meta_uri = thumb_pb.get_option("tEXt::Thumb::URI")

        s.failUnlessEqual(int(meta_mtime), int(mtime(s.filename)))
        s.failUnlessEqual(meta_uri, uri)

        #check rights
        s.failUnlessEqual(os.stat(path).st_mode, 33152)

add(TThumb)
Exemple #49
0
            def __len__(self):
                return 1L << 32
        data = TooBig("test")
        try: len(data)
        except OverflowError:
            # Py_ssize_t is still only 32 bits on this system.
            self.failUnlessRaises(OverflowError, Atom.render, "data", data)
        else:
            data = Atom.render("data", data)
            self.failUnlessEqual(len(data), 4 + 4 + 8 + 4)

    def test_length_0(self):
        fileobj = StringIO("\x00\x00\x00\x00atom")
        Atom(fileobj)
        self.failUnlessEqual(fileobj.tell(), 8)
add(TAtom)

class TAtoms(TestCase):
    uses_mmap = False
    filename = os.path.join("tests", "data", "has-tags.m4a")

    def setUp(self):
        self.atoms = Atoms(file(self.filename, "rb"))

    def test___contains__(self):
        self.failUnless(self.atoms["moov"])
        self.failUnless(self.atoms["moov.udta"])
        self.failUnlessRaises(KeyError, self.atoms.__getitem__, "whee")

    def test_name(self):
        self.failUnlessEqual(self.atoms.atoms[0].name, "ftyp")
# $Id: test_expr.py,v 1.1.1.1 2012/03/29 17:20:59 uid42307 Exp $
from tests import TestCase, add
from yasm import Expression
import operator

class TExpression(TestCase):
    def test_create(self):
        e1 = Expression(operator.add, 1, 2)
        e2 = Expression('+', 1, 2)
        
        self.assertEquals(e1.get_intnum(), e1.get_intnum())

    def test_extract(self):
        e1 = Expression('/', 15, 5)
        self.assertEquals(e1.get_intnum(), 3)
        self.assertRaises(ValueError, e1.extract_segoff)
        self.assertRaises(ValueError, e1.extract_wrt)

add(TExpression)
Exemple #51
0
    def test_space(self):
        self.failUnless(istag("ti tle"))

    def test_ugly(self):
        self.failUnless(istag("!{}[]-_()*&"))

    def test_unicode(self):
        self.failUnless(istag(u"ti tle"))

    if PY3:

        def test_py3(self):
            self.failUnlessRaises(ValueError, istag, b"abc")


add(Tistag)


class TVComment(TestCase):
    Kind = VComment

    def setUp(self):
        self.c = VComment()
        self.c.append(("artist", u"piman"))
        self.c.append(("artist", u"mu"))
        self.c.append(("title", u"more fakes"))

    def test_invalid_init(self):
        self.failUnlessRaises(TypeError, VComment, [])

    def test_equal(self):
    def setUp(self):
        quodlibet.config.init()
        self.library = SongLibrary()

    def test_none(self):
        Information(self.library, []).destroy()

    def test_one(self):
        f = AF({"~filename": "/dev/null"})
        Information(self.library, [f]).destroy()

    def test_two(self):
        f = AF({"~filename": "/dev/null"})
        f2 = AF({"~filename": "/dev/null2"})
        Information(self.library, [f, f2]).destroy()

    def test_album(self):
        f = AF({"~filename": "/dev/null", "album": "woo"})
        f2 = AF({"~filename": "/dev/null2", "album": "woo"})
        Information(self.library, [f, f2]).destroy()

    def test_artist(self):
        f = AF({"~filename": "/dev/null", "artist": "woo"})
        f2 = AF({"~filename": "/dev/null2", "artist": "woo"})
        Information(self.library, [f, f2]).destroy()

    def tearDown(self):
        self.library.destroy()
        quodlibet.config.quit()
add(TInformation)
Exemple #53
0
        self.failUnless(isinstance(value, bytes))

    def test_low_unicode(self):
        value = utf8(u"1234")
        self.failUnlessEqual(value, b"1234")
        self.failUnless(isinstance(value, bytes))

    def test_high_unicode(self):
        value = utf8(u"\u1234")
        self.failUnlessEqual(value, b'\xe1\x88\xb4')
        self.failUnless(isinstance(value, bytes))

    def test_invalid(self):
        self.failUnlessRaises(TypeError, utf8, 1234)

add(Tutf8)

class Tcdata(TestCase):

    ZERO = b"\x00\x00\x00\x00"
    LEONE = b"\x01\x00\x00\x00"
    BEONE = b"\x00\x00\x00\x01"
    NEGONE = b"\xff\xff\xff\xff"

    def test_int_le(self):
        self.failUnlessEqual(cdata.int_le(self.ZERO), 0)
        self.failUnlessEqual(cdata.int_le(self.LEONE), 1)
        self.failUnlessEqual(cdata.int_le(self.BEONE), 16777216)
        self.failUnlessEqual(cdata.int_le(self.NEGONE), -1)

    def test_uint_le(self):
Exemple #54
0
    def test_empty(self):
        self.failUnlessEqual(to_int_be(b""), 0)

    def test_0(self):
        self.failUnlessEqual(to_int_be(b"\x00"), 0)

    def test_1(self):
        self.failUnlessEqual(to_int_be(b"\x01"), 1)

    def test_256(self):
        self.failUnlessEqual(to_int_be(b"\x01\x00"), 256)

    def test_long(self):
        self.failUnlessEqual(to_int_be(b"\x01\x00\x00\x00\x00"), 2 ** 32)
add(Tto_int_be)


class TVCFLACDict(TVCommentDict):

    Kind = VCFLACDict

    def test_roundtrip_vc(self):
        self.failUnlessEqual(self.c, VComment(self.c.write() + b"\x01"))
add(TVCFLACDict)


class TMetadataBlock(TestCase):

    def test_empty(self):
        self.failUnlessEqual(MetadataBlock(b"").write(), b"")
Exemple #55
0
    def test_invalid_encoding(self):
        value = b"\xff\xff\x81"
        self.assertRaises(ValueError, value.decode, "utf-8")
        self.assertRaises(ValueError, value.decode, "cp1252")
        enc = locale.getpreferredencoding()

        # we need the decoding to fail for this test to work...
        try:
            value.decode(enc)
        except ValueError:
            pass
        else:
            return

        if not PY2:
            value = value.decode(enc, "surrogateescape")
        res, out = self.call("--TALB", value, self.filename)
        self.failIfEqual(res, 0)
        self.failUnless("TALB" in out)

    def test_invalid_escape(self):
        res, out = self.call("--TALB", '\\xaz', '-e', self.filename)
        self.failIfEqual(res, 0)
        self.failUnless("TALB" in out)

        res, out = self.call("--TALB", '\\', '-e', self.filename)
        self.failIfEqual(res, 0)
        self.failUnless("TALB" in out)

add(TMid3v2)
Exemple #56
0
    def test_module_delete(self):
        delete(os.path.join("tests", "data", "empty.tta"))

    def test_delete(self):
        self.audio.delete()
        self.failIf(self.audio.tags)

    def test_pprint(self):
        self.failUnless(self.audio.pprint())

    def test_save_reload(self):
        try:
            fd, filename = mkstemp(suffix='.tta')
            os.close(fd)
            shutil.copy(self.audio.filename, filename)
            audio = TrueAudio(filename)
            audio.add_tags()
            audio.tags.add(TIT1(encoding=0, text="A Title"))
            audio.save()
            audio = TrueAudio(filename)
            self.failUnlessEqual(audio["TIT1"], "A Title")
        finally:
            os.unlink(filename)

    def test_mime(self):
        self.failUnless("audio/x-tta" in self.audio.mime)


add(TTrueAudio)