--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Lib/test/test_zlib.py Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,480 @@
+import unittest
+from test import test_support
+import zlib
+import binascii
+import random
+
+
+class ChecksumTestCase(unittest.TestCase):
+ # checksum test cases
+ def test_crc32start(self):
+ self.assertEqual(zlib.crc32(""), zlib.crc32("", 0))
+ self.assert_(zlib.crc32("abc", 0xffffffff))
+
+ def test_crc32empty(self):
+ self.assertEqual(zlib.crc32("", 0), 0)
+ self.assertEqual(zlib.crc32("", 1), 1)
+ self.assertEqual(zlib.crc32("", 432), 432)
+
+ def test_adler32start(self):
+ self.assertEqual(zlib.adler32(""), zlib.adler32("", 1))
+ self.assert_(zlib.adler32("abc", 0xffffffff))
+
+ def test_adler32empty(self):
+ self.assertEqual(zlib.adler32("", 0), 0)
+ self.assertEqual(zlib.adler32("", 1), 1)
+ self.assertEqual(zlib.adler32("", 432), 432)
+
+ def assertEqual32(self, seen, expected):
+ # 32-bit values masked -- checksums on 32- vs 64- bit machines
+ # This is important if bit 31 (0x08000000L) is set.
+ self.assertEqual(seen & 0x0FFFFFFFFL, expected & 0x0FFFFFFFFL)
+
+ def test_penguins(self):
+ self.assertEqual32(zlib.crc32("penguin", 0), 0x0e5c1a120L)
+ self.assertEqual32(zlib.crc32("penguin", 1), 0x43b6aa94)
+ self.assertEqual32(zlib.adler32("penguin", 0), 0x0bcf02f6)
+ self.assertEqual32(zlib.adler32("penguin", 1), 0x0bd602f7)
+
+ self.assertEqual(zlib.crc32("penguin"), zlib.crc32("penguin", 0))
+ self.assertEqual(zlib.adler32("penguin"),zlib.adler32("penguin",1))
+
+ def test_abcdefghijklmnop(self):
+ """test issue1202 compliance: signed crc32, adler32 in 2.x"""
+ foo = 'abcdefghijklmnop'
+ # explicitly test signed behavior
+ self.assertEqual(zlib.crc32(foo), -1808088941)
+ self.assertEqual(zlib.crc32('spam'), 1138425661)
+ self.assertEqual(zlib.adler32(foo+foo), -721416943)
+ self.assertEqual(zlib.adler32('spam'), 72286642)
+
+ def test_same_as_binascii_crc32(self):
+ foo = 'abcdefghijklmnop'
+ self.assertEqual(binascii.crc32(foo), zlib.crc32(foo))
+ self.assertEqual(binascii.crc32('spam'), zlib.crc32('spam'))
+
+ def test_negative_crc_iv_input(self):
+ # The range of valid input values for the crc state should be
+ # -2**31 through 2**32-1 to allow inputs artifically constrained
+ # to a signed 32-bit integer.
+ self.assertEqual(zlib.crc32('ham', -1), zlib.crc32('ham', 0xffffffffL))
+ self.assertEqual(zlib.crc32('spam', -3141593),
+ zlib.crc32('spam', 0xffd01027L))
+ self.assertEqual(zlib.crc32('spam', -(2**31)),
+ zlib.crc32('spam', (2**31)))
+
+
+class ExceptionTestCase(unittest.TestCase):
+ # make sure we generate some expected errors
+ def test_badlevel(self):
+ # specifying compression level out of range causes an error
+ # (but -1 is Z_DEFAULT_COMPRESSION and apparently the zlib
+ # accepts 0 too)
+ self.assertRaises(zlib.error, zlib.compress, 'ERROR', 10)
+
+ def test_badcompressobj(self):
+ # verify failure on building compress object with bad params
+ self.assertRaises(ValueError, zlib.compressobj, 1, zlib.DEFLATED, 0)
+ # specifying total bits too large causes an error
+ self.assertRaises(ValueError,
+ zlib.compressobj, 1, zlib.DEFLATED, zlib.MAX_WBITS + 1)
+
+ def test_baddecompressobj(self):
+ # verify failure on building decompress object with bad params
+ self.assertRaises(ValueError, zlib.decompressobj, 0)
+
+ def test_decompressobj_badflush(self):
+ # verify failure on calling decompressobj.flush with bad params
+ self.assertRaises(ValueError, zlib.decompressobj().flush, 0)
+ self.assertRaises(ValueError, zlib.decompressobj().flush, -1)
+
+
+
+class CompressTestCase(unittest.TestCase):
+ # Test compression in one go (whole message compression)
+ def test_speech(self):
+ x = zlib.compress(HAMLET_SCENE)
+ self.assertEqual(zlib.decompress(x), HAMLET_SCENE)
+
+ def test_speech128(self):
+ # compress more data
+ data = HAMLET_SCENE * 128
+ x = zlib.compress(data)
+ self.assertEqual(zlib.decompress(x), data)
+
+
+
+
+class CompressObjectTestCase(unittest.TestCase):
+ # Test compression object
+ def test_pair(self):
+ # straightforward compress/decompress objects
+ data = HAMLET_SCENE * 128
+ co = zlib.compressobj()
+ x1 = co.compress(data)
+ x2 = co.flush()
+ self.assertRaises(zlib.error, co.flush) # second flush should not work
+ dco = zlib.decompressobj()
+ y1 = dco.decompress(x1 + x2)
+ y2 = dco.flush()
+ self.assertEqual(data, y1 + y2)
+
+ def test_compressoptions(self):
+ # specify lots of options to compressobj()
+ level = 2
+ method = zlib.DEFLATED
+ wbits = -12
+ memlevel = 9
+ strategy = zlib.Z_FILTERED
+ co = zlib.compressobj(level, method, wbits, memlevel, strategy)
+ x1 = co.compress(HAMLET_SCENE)
+ x2 = co.flush()
+ dco = zlib.decompressobj(wbits)
+ y1 = dco.decompress(x1 + x2)
+ y2 = dco.flush()
+ self.assertEqual(HAMLET_SCENE, y1 + y2)
+
+ def test_compressincremental(self):
+ # compress object in steps, decompress object as one-shot
+ data = HAMLET_SCENE * 128
+ co = zlib.compressobj()
+ bufs = []
+ for i in range(0, len(data), 256):
+ bufs.append(co.compress(data[i:i+256]))
+ bufs.append(co.flush())
+ combuf = ''.join(bufs)
+
+ dco = zlib.decompressobj()
+ y1 = dco.decompress(''.join(bufs))
+ y2 = dco.flush()
+ self.assertEqual(data, y1 + y2)
+
+ def test_decompinc(self, flush=False, source=None, cx=256, dcx=64):
+ # compress object in steps, decompress object in steps
+ source = source or HAMLET_SCENE
+ data = source * 128
+ co = zlib.compressobj()
+ bufs = []
+ for i in range(0, len(data), cx):
+ bufs.append(co.compress(data[i:i+cx]))
+ bufs.append(co.flush())
+ combuf = ''.join(bufs)
+
+ self.assertEqual(data, zlib.decompress(combuf))
+
+ dco = zlib.decompressobj()
+ bufs = []
+ for i in range(0, len(combuf), dcx):
+ bufs.append(dco.decompress(combuf[i:i+dcx]))
+ self.assertEqual('', dco.unconsumed_tail, ########
+ "(A) uct should be '': not %d long" %
+ len(dco.unconsumed_tail))
+ if flush:
+ bufs.append(dco.flush())
+ else:
+ while True:
+ chunk = dco.decompress('')
+ if chunk:
+ bufs.append(chunk)
+ else:
+ break
+ self.assertEqual('', dco.unconsumed_tail, ########
+ "(B) uct should be '': not %d long" %
+ len(dco.unconsumed_tail))
+ self.assertEqual(data, ''.join(bufs))
+ # Failure means: "decompressobj with init options failed"
+
+ def test_decompincflush(self):
+ self.test_decompinc(flush=True)
+
+ def test_decompimax(self, source=None, cx=256, dcx=64):
+ # compress in steps, decompress in length-restricted steps
+ source = source or HAMLET_SCENE
+ # Check a decompression object with max_length specified
+ data = source * 128
+ co = zlib.compressobj()
+ bufs = []
+ for i in range(0, len(data), cx):
+ bufs.append(co.compress(data[i:i+cx]))
+ bufs.append(co.flush())
+ combuf = ''.join(bufs)
+ self.assertEqual(data, zlib.decompress(combuf),
+ 'compressed data failure')
+
+ dco = zlib.decompressobj()
+ bufs = []
+ cb = combuf
+ while cb:
+ #max_length = 1 + len(cb)//10
+ chunk = dco.decompress(cb, dcx)
+ self.failIf(len(chunk) > dcx,
+ 'chunk too big (%d>%d)' % (len(chunk), dcx))
+ bufs.append(chunk)
+ cb = dco.unconsumed_tail
+ bufs.append(dco.flush())
+ self.assertEqual(data, ''.join(bufs), 'Wrong data retrieved')
+
+ def test_decompressmaxlen(self, flush=False):
+ # Check a decompression object with max_length specified
+ data = HAMLET_SCENE * 128
+ co = zlib.compressobj()
+ bufs = []
+ for i in range(0, len(data), 256):
+ bufs.append(co.compress(data[i:i+256]))
+ bufs.append(co.flush())
+ combuf = ''.join(bufs)
+ self.assertEqual(data, zlib.decompress(combuf),
+ 'compressed data failure')
+
+ dco = zlib.decompressobj()
+ bufs = []
+ cb = combuf
+ while cb:
+ max_length = 1 + len(cb)//10
+ chunk = dco.decompress(cb, max_length)
+ self.failIf(len(chunk) > max_length,
+ 'chunk too big (%d>%d)' % (len(chunk),max_length))
+ bufs.append(chunk)
+ cb = dco.unconsumed_tail
+ if flush:
+ bufs.append(dco.flush())
+ else:
+ while chunk:
+ chunk = dco.decompress('', max_length)
+ self.failIf(len(chunk) > max_length,
+ 'chunk too big (%d>%d)' % (len(chunk),max_length))
+ bufs.append(chunk)
+ self.assertEqual(data, ''.join(bufs), 'Wrong data retrieved')
+
+ def test_decompressmaxlenflush(self):
+ self.test_decompressmaxlen(flush=True)
+
+ def test_maxlenmisc(self):
+ # Misc tests of max_length
+ dco = zlib.decompressobj()
+ self.assertRaises(ValueError, dco.decompress, "", -1)
+ self.assertEqual('', dco.unconsumed_tail)
+
+ def test_flushes(self):
+ # Test flush() with the various options, using all the
+ # different levels in order to provide more variations.
+ sync_opt = ['Z_NO_FLUSH', 'Z_SYNC_FLUSH', 'Z_FULL_FLUSH']
+ sync_opt = [getattr(zlib, opt) for opt in sync_opt
+ if hasattr(zlib, opt)]
+ data = HAMLET_SCENE * 8
+
+ for sync in sync_opt:
+ for level in range(10):
+ obj = zlib.compressobj( level )
+ a = obj.compress( data[:3000] )
+ b = obj.flush( sync )
+ c = obj.compress( data[3000:] )
+ d = obj.flush()
+ self.assertEqual(zlib.decompress(''.join([a,b,c,d])),
+ data, ("Decompress failed: flush "
+ "mode=%i, level=%i") % (sync, level))
+ del obj
+
+ def test_odd_flush(self):
+ # Test for odd flushing bugs noted in 2.0, and hopefully fixed in 2.1
+ import random
+
+ if hasattr(zlib, 'Z_SYNC_FLUSH'):
+ # Testing on 17K of "random" data
+
+ # Create compressor and decompressor objects
+ co = zlib.compressobj(zlib.Z_BEST_COMPRESSION)
+ dco = zlib.decompressobj()
+
+ # Try 17K of data
+ # generate random data stream
+ try:
+ # In 2.3 and later, WichmannHill is the RNG of the bug report
+ gen = random.WichmannHill()
+ except AttributeError:
+ try:
+ # 2.2 called it Random
+ gen = random.Random()
+ except AttributeError:
+ # others might simply have a single RNG
+ gen = random
+ gen.seed(1)
+ data = genblock(1, 17 * 1024, generator=gen)
+
+ # compress, sync-flush, and decompress
+ first = co.compress(data)
+ second = co.flush(zlib.Z_SYNC_FLUSH)
+ expanded = dco.decompress(first + second)
+
+ # if decompressed data is different from the input data, choke.
+ self.assertEqual(expanded, data, "17K random source doesn't match")
+
+ def test_empty_flush(self):
+ # Test that calling .flush() on unused objects works.
+ # (Bug #1083110 -- calling .flush() on decompress objects
+ # caused a core dump.)
+
+ co = zlib.compressobj(zlib.Z_BEST_COMPRESSION)
+ self.failUnless(co.flush()) # Returns a zlib header
+ dco = zlib.decompressobj()
+ self.assertEqual(dco.flush(), "") # Returns nothing
+
+ if hasattr(zlib.compressobj(), "copy"):
+ def test_compresscopy(self):
+ # Test copying a compression object
+ data0 = HAMLET_SCENE
+ data1 = HAMLET_SCENE.swapcase()
+ c0 = zlib.compressobj(zlib.Z_BEST_COMPRESSION)
+ bufs0 = []
+ bufs0.append(c0.compress(data0))
+
+ c1 = c0.copy()
+ bufs1 = bufs0[:]
+
+ bufs0.append(c0.compress(data0))
+ bufs0.append(c0.flush())
+ s0 = ''.join(bufs0)
+
+ bufs1.append(c1.compress(data1))
+ bufs1.append(c1.flush())
+ s1 = ''.join(bufs1)
+
+ self.assertEqual(zlib.decompress(s0),data0+data0)
+ self.assertEqual(zlib.decompress(s1),data0+data1)
+
+ def test_badcompresscopy(self):
+ # Test copying a compression object in an inconsistent state
+ c = zlib.compressobj()
+ c.compress(HAMLET_SCENE)
+ c.flush()
+ self.assertRaises(ValueError, c.copy)
+
+ if hasattr(zlib.decompressobj(), "copy"):
+ def test_decompresscopy(self):
+ # Test copying a decompression object
+ data = HAMLET_SCENE
+ comp = zlib.compress(data)
+
+ d0 = zlib.decompressobj()
+ bufs0 = []
+ bufs0.append(d0.decompress(comp[:32]))
+
+ d1 = d0.copy()
+ bufs1 = bufs0[:]
+
+ bufs0.append(d0.decompress(comp[32:]))
+ s0 = ''.join(bufs0)
+
+ bufs1.append(d1.decompress(comp[32:]))
+ s1 = ''.join(bufs1)
+
+ self.assertEqual(s0,s1)
+ self.assertEqual(s0,data)
+
+ def test_baddecompresscopy(self):
+ # Test copying a compression object in an inconsistent state
+ data = zlib.compress(HAMLET_SCENE)
+ d = zlib.decompressobj()
+ d.decompress(data)
+ d.flush()
+ self.assertRaises(ValueError, d.copy)
+
+def genblock(seed, length, step=1024, generator=random):
+ """length-byte stream of random data from a seed (in step-byte blocks)."""
+ if seed is not None:
+ generator.seed(seed)
+ randint = generator.randint
+ if length < step or step < 2:
+ step = length
+ blocks = []
+ for i in range(0, length, step):
+ blocks.append(''.join([chr(randint(0,255))
+ for x in range(step)]))
+ return ''.join(blocks)[:length]
+
+
+
+def choose_lines(source, number, seed=None, generator=random):
+ """Return a list of number lines randomly chosen from the source"""
+ if seed is not None:
+ generator.seed(seed)
+ sources = source.split('\n')
+ return [generator.choice(sources) for n in range(number)]
+
+
+
+HAMLET_SCENE = """
+LAERTES
+
+ O, fear me not.
+ I stay too long: but here my father comes.
+
+ Enter POLONIUS
+
+ A double blessing is a double grace,
+ Occasion smiles upon a second leave.
+
+LORD POLONIUS
+
+ Yet here, Laertes! aboard, aboard, for shame!
+ The wind sits in the shoulder of your sail,
+ And you are stay'd for. There; my blessing with thee!
+ And these few precepts in thy memory
+ See thou character. Give thy thoughts no tongue,
+ Nor any unproportioned thought his act.
+ Be thou familiar, but by no means vulgar.
+ Those friends thou hast, and their adoption tried,
+ Grapple them to thy soul with hoops of steel;
+ But do not dull thy palm with entertainment
+ Of each new-hatch'd, unfledged comrade. Beware
+ Of entrance to a quarrel, but being in,
+ Bear't that the opposed may beware of thee.
+ Give every man thy ear, but few thy voice;
+ Take each man's censure, but reserve thy judgment.
+ Costly thy habit as thy purse can buy,
+ But not express'd in fancy; rich, not gaudy;
+ For the apparel oft proclaims the man,
+ And they in France of the best rank and station
+ Are of a most select and generous chief in that.
+ Neither a borrower nor a lender be;
+ For loan oft loses both itself and friend,
+ And borrowing dulls the edge of husbandry.
+ This above all: to thine ownself be true,
+ And it must follow, as the night the day,
+ Thou canst not then be false to any man.
+ Farewell: my blessing season this in thee!
+
+LAERTES
+
+ Most humbly do I take my leave, my lord.
+
+LORD POLONIUS
+
+ The time invites you; go; your servants tend.
+
+LAERTES
+
+ Farewell, Ophelia; and remember well
+ What I have said to you.
+
+OPHELIA
+
+ 'Tis in my memory lock'd,
+ And you yourself shall keep the key of it.
+
+LAERTES
+
+ Farewell.
+"""
+
+
+def test_main():
+ test_support.run_unittest(
+ ChecksumTestCase,
+ ExceptionTestCase,
+ CompressTestCase,
+ CompressObjectTestCase
+ )
+
+if __name__ == "__main__":
+ test_main()