def _afc_length_prefixed(self, file_handle, approx_block_size,
length_prefixed):
records = []
this_block_size = 0
for record in read_length_prefixed(file_handle, length_prefixed):
records.append(record)
this_block_size += len(record)
if this_block_size >= approx_block_size:
self.add_data_block(records)
records = []
this_block_size = 0
if records:
self.add_data_block(records)
def check_letters_zs(z, codec_shorthand):
assert isinstance(z.root_index_offset, integer_types)
assert isinstance(z.root_index_length, integer_types)
assert isinstance(z.total_file_length, integer_types)
assert z.codec == codec_shorthands[codec_shorthand]
assert z.data_sha256 == letters_sha256
assert z.metadata == {
u"test-data": u"letters",
u"build-info": {
u"user": u"test-user",
u"host": u"test-host",
u"time": u"2000-01-01T00:00:00.000000Z",
u"version": u"zs test",
},
}
assert isinstance(z.root_index_level, integer_types)
assert list(z) == letters_records
assert list(z.search()) == letters_records
if "ZS_QUICK_TEST" in os.environ:
chars = "m"
else:
chars = "abcdefghijklmnopqrstuvwxyz"
for char in chars:
byte = char.encode("ascii")
for (start, stop, prefix) in [
(None, None, None),
(byte, None, None),
(None, byte, None),
(None, None, byte),
(byte, byte, None),
(byte, int2byte(byte2int(byte) + 1), None),
(byte, int2byte(byte2int(byte) + 2), None),
(byte, int2byte(byte2int(byte) + 3), None),
(byte, b"q", None),
(None, 2 * byte, byte),
(b"m", b"s", byte),
]:
print("start=%r, stop=%r, prefix=%r" % (start, stop, prefix))
expected = letters_records
if start is not None:
expected = [r for r in expected if r >= start]
if stop is not None:
expected = [r for r in expected if not r >= stop]
if prefix is not None:
expected = [r for r in expected if r.startswith(prefix)]
assert list(z.search(start=start, stop=stop, prefix=prefix)
) == expected
map_blocks = list(z.block_map(
_check_map_helper,
# test args and kwargs argument passing
args=(1,), kwargs={"arg2": 2},
start=start, stop=stop, prefix=prefix))
assert sum(map_blocks, []) == expected
for term in [b"\n", b"\x00"]:
expected_dump = term.join(expected + [b""])
out = BytesIO()
z.dump(out, start=start, stop=stop, prefix=prefix,
terminator=term)
assert out.getvalue() == expected_dump
out = BytesIO()
z.dump(out, start=start, stop=stop, prefix=prefix,
length_prefixed="uleb128")
assert (list(read_length_prefixed(BytesIO(out.getvalue()), "uleb128"))
== expected)
out = BytesIO()
z.dump(out, start=start, stop=stop, prefix=prefix,
length_prefixed="u64le")
assert (list(read_length_prefixed(BytesIO(out.getvalue()), "u64le"))
== expected)
assert list(z.search(stop=b"bb", prefix=b"b")) == [b"b"]
assert_raises(ValueError, list,
z.block_map(_check_raise_helper, args=(ValueError,)))
assert_raises(ValueError, z.block_exec,
_check_raise_helper, args=(ValueError,))
z.validate()
