def read(self, sz):
assert sz == 1
v = byte_int(self.file.read(1, szhint=self.szhint)[0])
self.szhint -= 1
ret = bytes_from_uint(v ^ self.vuint_cs[self.offs])
self.offs += 1
assert self.offs < len(self.vuint_cs)
return ret
def test_valid_save_name():
valid = helpers.valid_save_name
WVPASS(valid(b'x'))
WVPASS(valid(b'x@'))
WVFAIL(valid(b'@'))
WVFAIL(valid(b'/'))
WVFAIL(valid(b'/foo'))
WVFAIL(valid(b'foo/'))
WVFAIL(valid(b'/foo/'))
WVFAIL(valid(b'foo//bar'))
WVFAIL(valid(b'.'))
WVFAIL(valid(b'bar.'))
WVFAIL(valid(b'foo@{'))
for x in b' ~^:?*[\\':
WVFAIL(valid(b'foo' + bytes_from_byte(x)))
for i in range(20):
WVFAIL(valid(b'foo' + bytes_from_uint(i)))
WVFAIL(valid(b'foo' + bytes_from_uint(0x7f)))
WVFAIL(valid(b'foo..bar'))
WVFAIL(valid(b'bar.lock/baz'))
WVFAIL(valid(b'foo/bar.lock/baz'))
WVFAIL(valid(b'.bar/baz'))
WVFAIL(valid(b'foo/.bar/baz'))
def test_fanout_behaviour():
# Drop in replacement for bupsplit, but splitting if the int value of a
# byte >= BUP_BLOBBITS
basebits = _helpers.blobbits()
def splitbuf(buf):
ofs = 0
for b in buf:
b = byte_int(b)
ofs += 1
if b >= basebits:
return ofs, b
return 0, 0
with no_lingering_errors():
old_splitbuf = _helpers.splitbuf
_helpers.splitbuf = splitbuf
old_BLOB_MAX = hashsplit.BLOB_MAX
hashsplit.BLOB_MAX = 4
old_BLOB_READ_SIZE = hashsplit.BLOB_READ_SIZE
hashsplit.BLOB_READ_SIZE = 10
old_fanout = hashsplit.fanout
hashsplit.fanout = 2
levels = lambda f: [
(len(b), l) for b, l in hashsplit.hashsplit_iter([f], True, None)
]
# Return a string of n null bytes
z = lambda n: b'\x00' * n
# Return a byte which will be split with a level of n
sb = lambda n: bytes_from_uint(basebits + n)
split_never = BytesIO(z(16))
split_first = BytesIO(z(1) + sb(3) + z(14))
split_end = BytesIO(z(13) + sb(1) + z(2))
split_many = BytesIO(
sb(1) + z(3) + sb(2) + z(4) + sb(0) + z(4) + sb(5) + z(1))
WVPASSEQ(levels(split_never), [(4, 0), (4, 0), (4, 0), (4, 0)])
WVPASSEQ(levels(split_first), [(2, 3), (4, 0), (4, 0), (4, 0), (2, 0)])
WVPASSEQ(levels(split_end), [(4, 0), (4, 0), (4, 0), (2, 1), (2, 0)])
WVPASSEQ(levels(split_many), [(1, 1), (4, 2), (4, 0), (1, 0), (4, 0),
(1, 5), (1, 0)])
_helpers.splitbuf = old_splitbuf
hashsplit.BLOB_MAX = old_BLOB_MAX
hashsplit.BLOB_READ_SIZE = old_BLOB_READ_SIZE
hashsplit.fanout = old_fanout
def _encode_packobj(type, content, compression_level=1):
if compression_level not in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9):
raise ValueError('invalid compression level %s' % compression_level)
szout = b''
sz = len(content)
szbits = (sz & 0x0f) | (_typemap[type] << 4)
sz >>= 4
while 1:
if sz: szbits |= 0x80
szout += bytes_from_uint(szbits)
if not sz:
break
szbits = sz & 0x7f
sz >>= 7
z = zlib.compressobj(compression_level)
yield szout
yield z.compress(content)
yield z.flush()
def randbytes(sz):
s = b''
for i in range(sz):
s += bytes_from_uint(random.randrange(0, 256))
return s
def randblock(n):
return b''.join(
bytes_from_uint(random.randrange(0, 256)) for i in range(n))
