Exemplo n.º 1
0
    def _test_zlib_streams_combined(self, gen_bytes):

        sizes = [2 ** x + y for x in range(1, 18) for y in (-1, 0, 1)]
        for size in sizes:

            original_bytes = gen_bytes(size)

            # Read the whole thing
            original_stream = six.BytesIO(original_bytes)
            compressed_stream = utils.ZlibCompressedStream(original_stream)
            uncompressed_stream = utils.ZlibUncompressedStream(compressed_stream)
            b = uncompressed_stream.read()
            self.assertEqual(size, len(b))
            self.assertEqual(original_bytes, b)

            # There's nothing left now to read
            for x in range(10):
                self.assertEqual(0, len(uncompressed_stream.read(100)))

            # Read with given number of bytes
            for n in (1, len(original_bytes) // 2, len(original_bytes)):

                these_bytes = original_bytes[0:n]

                original_stream = six.BytesIO(these_bytes)
                compressed_stream = utils.ZlibCompressedStream(original_stream)
                uncompressed_stream = utils.ZlibUncompressedStream(compressed_stream)

                b = uncompressed_stream.read(n)
                self.assertEqual(n, len(b))
                self.assertEqual(these_bytes, b)

                # There's nothing left now to read
                for x in range(10):
                    self.assertEqual(0, len(uncompressed_stream.read(100)))
Exemplo n.º 2
0
    def test_zlib_uncompressed_stream(self):

        fname = tempfile.mktemp()
        with open(fname, 'wb') as f:
            f.write(zlib.compress(b'abc'))

        # Read parts from the beginning
        for b, n in ((b'abc', 3), (b'ab', 2), (b'a', 1)):
            with open(fname, 'rb') as f:
                s = utils.ZlibUncompressedStream(f)
                self.assertEqual(b, s.read(n))

        # Read whole contents by successive calls
        with open(fname, 'rb') as f:
            s = utils.ZlibUncompressedStream(f)
            self.assertEqual(b'a', s.read(1))
            self.assertEqual(b'b', s.read(1))
            self.assertEqual(b'c', s.read(1))
            self.assertEqual(0, s.buflen)

        os.remove(fname)

        # Try now with bigger data sizes
        for size in [2**x + y for x in range(3, 18) for y in (-1, 0, 1)]:

            original_bytes = os.urandom(size)
            compressed_bytes = zlib.compress(original_bytes)

            # Try first with whole reads
            compressed_stream = six.BytesIO(compressed_bytes)
            uncompressed_stream = utils.ZlibUncompressedStream(
                compressed_stream)
            b = uncompressed_stream.read()
            self.assertEqual(size, len(b))
            self.assertEqual(original_bytes, b)

            # Now read little by little
            read_size = min(size // 4, 1024)
            b = b''
            compressed_stream = six.BytesIO(compressed_bytes)
            uncompressed_stream = utils.ZlibUncompressedStream(
                compressed_stream)
            for u in iter(
                    functools.partial(uncompressed_stream.read, read_size),
                    b''):
                b += u
            self.assertEqual(size, len(b))
            self.assertEqual(original_bytes, b)