def testRender(self): h = TagHeader() h.unsync = False header = h.render(100) h2 = TagHeader() found = h2.parse(StringIO(header)) assert_false(h2.unsync) assert_true(found) assert_equal(header, h2.render(100)) h = TagHeader() h.footer = True h.extended = True header = h.render(666) h2 = TagHeader() found = h2.parse(StringIO(header)) assert_true(found) assert_false(h2.unsync) assert_false(h2.experimental) assert_true(h2.footer) assert_true(h2.extended) assert_equal(h2.tag_size, 666) assert_equal(header, h2.render(666))
def pilImage(source): if not _have_PIL: return None from PIL import Image if isinstance(source, ImageFrame): return Image.open(StringIO(source.image_data)) else: return Image.open(source)
def testVersionOutput(self): for arg in ["--version"]: with RedirectStdStreams(stderr=StringIO()) as out: try: args, parser = main.parseCommandLine([arg]) except SystemExit as ex: out.stderr.seek(0) expected = "eyeD3 %s-%s" % (info.VERSION, info.RELEASE) assert_true(out.stderr.read().startswith(expected)) assert_equal(ex.code, 0)
def testInvalidFlagBits(self): for bad_flags in [b"\x00\x20", b"\x01\x01"]: h = ExtendedTagHeader() try: h.parse(StringIO(b"\x00\x00\x00\xff" + bad_flags), (2, 4, 0)) except TagException: pass else: assert_false("Bad ExtendedTagHeader flags, expected " "TagException")
def testRenderCrcPadding(self): version = (2, 4, 0) h = ExtendedTagHeader() h.crc_bit = 1 header = h.render(version, "\x01", 0) h2 = ExtendedTagHeader() h2.parse(StringIO(header), version) assert_equal(h.crc, h2.crc)
def testRender(self): version = (2, 4, 0) dummy_data = b"\xab" * 50 dummy_padding_len = 1024 h = ExtendedTagHeader() h.update_bit = 1 h.crc_bit = 1 h.tag_size_restriction = ExtendedTagHeader.RESTRICT_TAG_SZ_MED h.text_enc_restriction = ExtendedTagHeader.RESTRICT_TEXT_ENC_UTF8 h.text_length_restriction = ExtendedTagHeader.RESTRICT_TEXT_LEN_128 h.image_enc_restriction = ExtendedTagHeader.RESTRICT_IMG_ENC_PNG_JPG h.image_size_restriction = ExtendedTagHeader.RESTRICT_IMG_SZ_256 header = h.render(version, dummy_data, dummy_padding_len) h2 = ExtendedTagHeader() h2.parse(StringIO(header), version) assert_true(h2.update_bit) assert_true(h2.crc_bit) assert_true(h2.restrictions_bit) assert_equal(h.crc, h2.crc) assert_equal(h.tag_size_restriction, h2.tag_size_restriction) assert_equal(h.text_enc_restriction, h2.text_enc_restriction) assert_equal(h.text_length_restriction, h2.text_length_restriction) assert_equal(h.image_enc_restriction, h2.image_enc_restriction) assert_equal(h.image_size_restriction, h2.image_size_restriction) assert_equal(h2.render(version, dummy_data, dummy_padding_len), header) # version 2.3 header_23 = h.render((2, 3, 0), dummy_data, dummy_padding_len) h3 = ExtendedTagHeader() h3.parse(StringIO(header_23), (2, 3, 0)) assert_false(h3.update_bit) assert_true(h3.crc_bit) assert_false(h3.restrictions_bit) assert_equal(h.crc, h3.crc) assert_equal(0, h3.tag_size_restriction) assert_equal(0, h3.text_enc_restriction) assert_equal(0, h3.text_length_restriction) assert_equal(0, h3.image_enc_restriction) assert_equal(0, h3.image_size_restriction)
def testFindHeader(): from eyed3.mp3.headers import findHeader # No header buffer = StringIO(b'\x00' * 1024) (offset, header_int, header_bytes) = findHeader(buffer, 0) assert_equal(header_int, None) # Valid header buffer = StringIO(b'\x11\x12\x23' * 1024 + b"\xff\xfb\x90\x64" + b"\x00" * 1024) (offset, header_int, header_bytes) = findHeader(buffer, 0) assert_equal(header_int, 0xfffb9064) # Same thing with a false sync in the mix buffer = StringIO(b'\x11\x12\x23' * 1024 + b"\x11" * 100 + b"\xff\xea\x00\x00" + # false sync b"\x22" * 100 + b"\xff\xe2\x1c\x34" + # false sync b"\xee" * 100 + b"\xff\xfb\x90\x64" + b"\x00" * 1024) (offset, header_int, header_bytes) = findHeader(buffer, 0) assert_equal(header_int, 0xfffb9064)
def testParse(self): # Incomplete headers for data in [ b"", b"ID3", b"ID3\x04\x00", b"ID3\x02\x00\x00", b"ID3\x03\x00\x00", b"ID3\x04\x00\x00", ]: header = TagHeader() found = header.parse(StringIO(data)) assert_false(found) # Inalid versions for data in [ b"ID3\x01\x00\x00", b"ID3\x05\x00\x00", b"ID3\x06\x00\x00", ]: header = TagHeader() try: found = header.parse(StringIO(data)) except TagException: pass else: assert_false("Expected TagException invalid version") # Complete headers for data in [ b"ID3\x02\x00\x00", b"ID3\x03\x00\x00", b"ID3\x04\x00\x00", ]: for sz in [0, 10, 100, 1000, 2500, 5000, 7500, 10000]: sz_bytes = bin2bytes(bin2synchsafe(dec2bin(sz, 32))) header = TagHeader() found = header.parse(StringIO(data + sz_bytes)) assert_true(found) assert_equal(header.tag_size, sz)
def profileMain(args, config): # pragma: no cover '''This is the main function for profiling http://code.google.com/appengine/kb/commontasks.html#profiling ''' import cProfile import pstats eyed3.log.debug("driver profileMain") prof = cProfile.Profile() prof = prof.runctx("main(args)", globals(), locals()) stream = StringIO() stats = pstats.Stats(prof, stream=stream) stats.sort_stats("time") # Or cumulative stats.print_stats(100) # 80 = how many to print # The rest is optional. stats.print_callees() stats.print_callers() sys.stderr.write("Profile data:\n%s\n" % stream.getvalue()) return 0
def __init__(self, stdout=None, stderr=None, seek_on_exit=0): self.stdout = stdout or StringIO() self.stderr = stderr or StringIO() self._seek_offset = seek_on_exit