def test_deflate_set_dictionary(): text = 'abcabc' zdict = 'abc' stream = rzlib.deflateInit() rzlib.deflateSetDictionary(stream, zdict) bytes = rzlib.compress(stream, text, rzlib.Z_FINISH) rzlib.deflateEnd(stream) stream2 = rzlib.inflateInit() from rpython.rtyper.lltypesystem import lltype, rffi, rstr from rpython.rtyper.annlowlevel import llstr from rpython.rlib.rstring import StringBuilder with lltype.scoped_alloc(rffi.CCHARP.TO, len(bytes)) as inbuf: rstr.copy_string_to_raw(llstr(bytes), inbuf, 0, len(bytes)) stream2.c_next_in = rffi.cast(rzlib.Bytefp, inbuf) rffi.setintfield(stream2, 'c_avail_in', len(bytes)) with lltype.scoped_alloc(rffi.CCHARP.TO, 100) as outbuf: stream2.c_next_out = rffi.cast(rzlib.Bytefp, outbuf) bufsize = 100 rffi.setintfield(stream2, 'c_avail_out', bufsize) err = rzlib._inflate(stream2, rzlib.Z_SYNC_FLUSH) assert err == rzlib.Z_NEED_DICT rzlib.inflateSetDictionary(stream2, zdict) rzlib._inflate(stream2, rzlib.Z_SYNC_FLUSH) avail_out = rffi.cast(lltype.Signed, stream2.c_avail_out) result = StringBuilder() result.append_charpsize(outbuf, bufsize - avail_out) rzlib.inflateEnd(stream2) assert result.build() == text
def test_compress_copy(): """ inflateCopy produces an independent copy of a stream. """ stream = rzlib.deflateInit() bytes1 = rzlib.compress(stream, expanded[:10]) assert bytes1 copied = rzlib.deflateCopy(stream) bytes_stream = rzlib.compress( stream, expanded[10:], rzlib.Z_FINISH, ) assert bytes1 + bytes_stream == compressed rzlib.deflateEnd(stream) bytes_copy = rzlib.compress( copied, expanded[10:], rzlib.Z_FINISH, ) rzlib.deflateEnd(copied) assert bytes1 + bytes_copy == compressed
def flush(self, space, mode=rzlib.Z_FINISH): """ flush( [mode] ) -- Return a string containing any remaining compressed data. mode can be one of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH; the default value used when mode is not specified is Z_FINISH. If mode == Z_FINISH, the compressor object can no longer be used after calling the flush() method. Otherwise, more data can still be compressed. """ try: self.lock() try: if not self.stream: raise zlib_error(space, "compressor object already flushed") result = rzlib.compress(self.stream, '', mode) if mode == rzlib.Z_FINISH: # release the data structures now rzlib.deflateEnd(self.stream) self.stream = rzlib.null_stream self.may_unregister_rpython_finalizer(space) finally: self.unlock() except rzlib.RZlibError as e: raise zlib_error(space, e.msg) return space.newbytes(result)
def flush(self, space, mode=rzlib.Z_FINISH): """ flush( [mode] ) -- Return a string containing any remaining compressed data. mode can be one of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH; the default value used when mode is not specified is Z_FINISH. If mode == Z_FINISH, the compressor object can no longer be used after calling the flush() method. Otherwise, more data can still be compressed. """ try: self.lock() try: if not self.stream: raise zlib_error(space, "compressor object already flushed") result = rzlib.compress(self.stream, '', mode) if mode == rzlib.Z_FINISH: # release the data structures now rzlib.deflateEnd(self.stream) self.stream = rzlib.null_stream finally: self.unlock() except rzlib.RZlibError, e: raise zlib_error(space, e.msg)
def test_compression(): """ Once we have got a deflate stream, rzlib.compress() should allow us to compress bytes. """ stream = rzlib.deflateInit() bytes = rzlib.compress(stream, expanded) bytes += rzlib.compress(stream, "", rzlib.Z_FINISH) rzlib.deflateEnd(stream) assert bytes == compressed
def test_compression_lots_of_data(): """ Test compression of more data that fits in a single internal output buffer. """ expanded = repr(range(20000)) compressed = zlib.compress(expanded) print len(expanded), '=>', len(compressed) stream = rzlib.deflateInit() bytes = rzlib.compress(stream, expanded, rzlib.Z_FINISH) rzlib.deflateEnd(stream) assert bytes == compressed
def Compress_finish(self, mode): mode = rzlib.Z_FINISH if mode is None else mode.value try: # lock result = rzlib.compress(self.stream, '', rzlib.Z_FINISH) if mode == rzlib.Z_FINISH: rzlib.deflateEnd(self.stream) self.stream = rzlib.null_stream # unlock except rzlib.RZlibError as e: raise zlib_error(e.msg) return to_uint8array(result)
def f(i, check): bytes = "s" * i if check == 1: for j in range(3): stream = rzlib.deflateInit() bytes = rzlib.compress(stream, bytes, rzlib.Z_FINISH) rzlib.deflateEnd(stream) return bytes if check == 2: return str(rzlib.adler32(bytes)) if check == 3: return str(rzlib.crc32(bytes)) return '?'
def test_decompress_max_length(): """ Test the max_length argument of decompress(). """ stream = rzlib.inflateInit() data1, finished1, unused1 = rzlib.decompress(stream, compressed, max_length = 17) assert data1 == expanded[:17] assert finished1 is False assert unused1 > 0 data2, finished2, unused2 = rzlib.decompress(stream, compressed[-unused1:]) assert data2 == expanded[17:] assert finished2 is True assert unused2 == 0 rzlib.deflateEnd(stream)
def compress(space, string, level=rzlib.Z_DEFAULT_COMPRESSION): """ compress(string[, level]) -- Returned compressed string. Optional arg level is the compression level, in 1-9. """ try: try: stream = rzlib.deflateInit(level) except ValueError: raise zlib_error(space, "Bad compression level") try: result = rzlib.compress(stream, string, rzlib.Z_FINISH) finally: rzlib.deflateEnd(stream) except rzlib.RZlibError, e: raise zlib_error(space, e.msg)
def test_unsuccessful_compress_copy(): """ Errors during unsuccesful deflateCopy operations raise RZlibErrors. """ stream = rzlib.deflateInit() # From zlib.h: # # "deflateCopy returns [...] Z_STREAM_ERROR if the source stream # state was inconsistent (such as zalloc being Z_NULL)" from rpython.rtyper.lltypesystem import rffi, lltype stream.c_zalloc = rffi.cast(lltype.typeOf(stream.c_zalloc), rzlib.Z_NULL) exc = py.test.raises(rzlib.RZlibError, rzlib.deflateCopy, stream) msg = "Error -2 while copying compression object: inconsistent stream state" assert str(exc.value) == msg rzlib.deflateEnd(stream)
def test_decompression_too_much_input(): """ Check the case where we feed extra data to decompress(). """ stream = rzlib.inflateInit() data1, finished1, unused1 = rzlib.decompress(stream, compressed[:-5]) assert finished1 is False assert unused1 == 0 data2, finished2, unused2 = rzlib.decompress(stream, compressed[-5:] + 'garbage') assert finished2 is True assert unused2 == len('garbage') assert data1 + data2 == expanded data3, finished3, unused3 = rzlib.decompress(stream, 'more_garbage') assert finished3 is True assert unused3 == len('more_garbage') assert data3 == '' rzlib.deflateEnd(stream)
def test_cornercases(): """ Test degenerate arguments. """ stream = rzlib.deflateInit() bytes = rzlib.compress(stream, "") bytes += rzlib.compress(stream, "") bytes += rzlib.compress(stream, "", rzlib.Z_FINISH) assert zlib.decompress(bytes) == "" rzlib.deflateEnd(stream) stream = rzlib.inflateInit() data, finished, unused = rzlib.decompress(stream, "") assert data == "" assert finished is False assert unused == 0 buf = compressed for i in range(10): data, finished, unused = rzlib.decompress(stream, buf, max_length=0) assert data == "" assert finished is False assert unused > 0 buf = buf[-unused:] rzlib.deflateEnd(stream)
def __del__(self): """Automatically free the resources used by the stream.""" if self.stream: rzlib.deflateEnd(self.stream) self.stream = rzlib.null_stream
def _encode(data, level, encoding): stream = rzlib.deflateInit(level=level, wbits=encoding) bytes = rzlib.compress(stream, data) bytes += rzlib.compress(stream, "", rzlib.Z_FINISH) rzlib.deflateEnd(stream) return bytes
def _finalize_(self): """Automatically free the resources used by the stream.""" if self.stream: rzlib.deflateEnd(self.stream) self.stream = rzlib.null_stream
def test_deflate_init_end(): """ deflateInit() followed by deflateEnd() should work and do nothing. """ stream = rzlib.deflateInit() rzlib.deflateEnd(stream)
def __del__(self): if self.stream: rzlib.deflateEnd(self.stream) self.stream = rzlib.null_stream