Esempio n. 1
0
    def test_decompress_reader(self):
        for close_on_deletion in range(2):
            for with_size in range(2):
                for ds in self.data_sizes:
                    cdata = make_bytes(ds, randomize=False)

                    # zdata = zipped actual data
                    # cdata = original content data

                    # create reader
                    if with_size:
                        # need object data
                        zdata = zlib.compress(make_object(
                            str_blob_type, cdata))
                        type, size, reader = DecompressMemMapReader.new(
                            zdata, close_on_deletion)
                        assert size == len(cdata)
                        assert type == str_blob_type

                        # even if we don't set the size, it will be set automatically on first read
                        test_reader = DecompressMemMapReader(
                            zdata, close_on_deletion=False)
                        assert test_reader._s == len(cdata)
                    else:
                        # here we need content data
                        zdata = zlib.compress(cdata)
                        reader = DecompressMemMapReader(
                            zdata, close_on_deletion, len(cdata))
                        assert reader._s == len(cdata)
                    # END get reader

                    self._assert_stream_reader(reader, cdata,
                                               lambda r: r.seek(0))

                    # put in a dummy stream for closing
                    dummy = DummyStream()
                    reader._m = dummy

                    assert not dummy.closed
                    del (reader)
                    assert dummy.closed == close_on_deletion
Esempio n. 2
0
    def test_streams(self):
        # test info
        sha = NULL_BIN_SHA
        s = 20
        blob_id = 3

        info = OInfo(sha, str_blob_type, s)
        assert info.binsha == sha
        assert info.type == str_blob_type
        assert info.type_id == blob_id
        assert info.size == s

        # test pack info
        # provides type_id
        pinfo = OPackInfo(0, blob_id, s)
        assert pinfo.type == str_blob_type
        assert pinfo.type_id == blob_id
        assert pinfo.pack_offset == 0

        dpinfo = ODeltaPackInfo(0, blob_id, s, sha)
        assert dpinfo.type == str_blob_type
        assert dpinfo.type_id == blob_id
        assert dpinfo.delta_info == sha
        assert dpinfo.pack_offset == 0

        # test ostream
        stream = DummyStream()
        ostream = OStream(*(info + (stream, )))
        assert ostream.stream is stream
        ostream.read(15)
        stream._assert()
        assert stream.bytes == 15
        ostream.read(20)
        assert stream.bytes == 20

        # test packstream
        postream = OPackStream(*(pinfo + (stream, )))
        assert postream.stream is stream
        postream.read(10)
        stream._assert()
        assert stream.bytes == 10

        # test deltapackstream
        dpostream = ODeltaPackStream(*(dpinfo + (stream, )))
        dpostream.stream is stream
        dpostream.read(5)
        stream._assert()
        assert stream.bytes == 5

        # derive with own args
        DeriveTest(sha, str_blob_type, s, stream, 'mine', myarg=3)._assert()

        # test istream
        istream = IStream(str_blob_type, s, stream)
        assert istream.binsha == None
        istream.binsha = sha
        assert istream.binsha == sha

        assert len(istream.binsha) == 20
        assert len(istream.hexsha) == 40

        assert istream.size == s
        istream.size = s * 2
        istream.size == s * 2
        assert istream.type == str_blob_type
        istream.type = "something"
        assert istream.type == "something"
        assert istream.stream is stream
        istream.stream = None
        assert istream.stream is None

        assert istream.error is None
        istream.error = Exception()
        assert isinstance(istream.error, Exception)
Esempio n. 3
0
	def test_streams(self):
		# test info
		sha = NULL_BIN_SHA
		s = 20
		blob_id = 3
		
		info = OInfo(sha, str_blob_type, s)
		assert info.binsha == sha
		assert info.type == str_blob_type
		assert info.type_id == blob_id
		assert info.size == s
		
		# test pack info
		# provides type_id
		pinfo = OPackInfo(0, blob_id, s)
		assert pinfo.type == str_blob_type
		assert pinfo.type_id == blob_id
		assert pinfo.pack_offset == 0
		
		dpinfo = ODeltaPackInfo(0, blob_id, s, sha)
		assert dpinfo.type == str_blob_type
		assert dpinfo.type_id == blob_id
		assert dpinfo.delta_info == sha
		assert dpinfo.pack_offset == 0
		
		
		# test ostream
		stream = DummyStream()
		ostream = OStream(*(info + (stream, )))
		assert ostream.stream is stream
		ostream.read(15)
		stream._assert()
		assert stream.bytes == 15
		ostream.read(20)
		assert stream.bytes == 20
		
		# test packstream
		postream = OPackStream(*(pinfo + (stream, )))
		assert postream.stream is stream
		postream.read(10)
		stream._assert()
		assert stream.bytes == 10
		
		# test deltapackstream
		dpostream = ODeltaPackStream(*(dpinfo + (stream, )))
		dpostream.stream is stream
		dpostream.read(5)
		stream._assert()
		assert stream.bytes == 5
		
		# derive with own args
		DeriveTest(sha, str_blob_type, s, stream, 'mine',myarg = 3)._assert()
		
		# test istream
		istream = IStream(str_blob_type, s, stream)
		assert istream.binsha == None
		istream.binsha = sha
		assert istream.binsha == sha
		
		assert len(istream.binsha) == 20
		assert len(istream.hexsha) == 40
		
		assert istream.size == s
		istream.size = s * 2
		istream.size == s * 2
		assert istream.type == str_blob_type
		istream.type = "something"
		assert istream.type == "something"
		assert istream.stream is stream
		istream.stream = None
		assert istream.stream is None
		
		assert istream.error is None
		istream.error = Exception()
		assert isinstance(istream.error, Exception)