def test_correct_type_nested_array():
unpacker = Unpacker()
unpacker.feed(packb({"a": ["b", "c", "d"]}))
try:
unpacker.read_array_header()
assert 0, "should raise exception"
except UnexpectedTypeException:
assert 1, "okay"
def mpdecode(iterable):
unpacker = Unpacker(encoding='utf8')
for chunk in iterable:
unpacker.feed(chunk)
# Each chunk can have none or many objects,
# so here we dispatch any object ready
for obj in unpacker:
yield obj
def test_incorrect_type_array():
unpacker = Unpacker()
unpacker.feed(packb(1))
try:
unpacker.read_array_header()
assert 0, "should raise exception"
except UnexpectedTypeException:
assert 1, "okay"
def test_incorrect_type_nested_map():
unpacker = Unpacker()
unpacker.feed(packb([{'a': 'b'}]))
try:
unpacker.read_map_header()
assert 0, 'should raise exception'
except UnexpectedTypeException:
assert 1, 'okay'
def test_correct_type_nested_array():
unpacker = Unpacker()
unpacker.feed(packb({'a': ['b', 'c', 'd']}))
try:
unpacker.read_array_header()
assert 0, 'should raise exception'
except UnexpectedTypeException:
assert 1, 'okay'
def test_incorrect_type_nested_map():
unpacker = Unpacker()
unpacker.feed(packb([{"a": "b"}]))
try:
unpacker.read_map_header()
assert 0, "should raise exception"
except UnexpectedTypeException:
assert 1, "okay"
def test_write_bytes_multi_buffer():
long_val = (5) * 100
expected = packb(long_val)
unpacker = Unpacker(six.BytesIO(expected), read_size=3, max_buffer_size=3)
f = six.BytesIO()
unpacked = unpacker.unpack(f.write)
assert unpacked == long_val
assert f.getvalue() == expected
def setUp(self):
address = 0xFA1AFE1
device = "LivewareProblem"
raw_packet = encode_erase_flash_page(address, device)
unpacker = Unpacker()
unpacker.feed(raw_packet)
self.command = list(unpacker)[1:]
def test_auto_max_array_len():
packed = b'\xde\x00\x06zz'
with pytest.raises(UnpackValueError):
unpackb(packed, raw=False)
unpacker = Unpacker(max_buffer_size=5, raw=False)
unpacker.feed(packed)
with pytest.raises(UnpackValueError):
unpacker.unpack()
def testPackUnicode():
test_data = ["", "abcd", ["defgh"], "Русский текст"]
for td in test_data:
re = unpackb(packb(td), use_list=1, raw=False)
assert re == td
packer = Packer()
data = packer.pack(td)
re = Unpacker(BytesIO(data), raw=False, use_list=1).unpack()
assert re == td
def unpack_gen(file, size):
u = Unpacker()
while True:
data = file.read(size)
if not data:
break
u.feed(data)
for o in u:
yield o
def test_unpack_array_header_from_file():
f = BytesIO(packb([1, 2, 3, 4]))
unpacker = Unpacker(f)
assert unpacker.read_array_header() == 4
assert unpacker.unpack() == 1
assert unpacker.unpack() == 2
assert unpacker.unpack() == 3
assert unpacker.unpack() == 4
with raises(OutOfData):
unpacker.unpack()
def _decode_bytes_as_tuple(buf):
unpacker = Unpacker(None, **_unpacker_args)
unpacker.feed(buf)
n = unpacker.read_array_header()
def extract(unpacker=unpacker, n=n):
for i in range(n):
yield unpacker.unpack()
return tuple(extract())
def get_edge(self, filenum, offset):
if filenum in self.open_file_cache:
fileobj = self.open_file_cache[filenum]
else:
filename = 'part_%02d.msgpack' % filenum
fileobj = open(os.path.join(self.edge_dir, filename), 'rb')
self.open_file_cache[filename] = fileobj
fileobj.seek(offset)
unpacker = Unpacker(fileobj, encoding=encoding)
return unpacker.unpack()
def test_auto_max_map_len():
# len(packed) == 6 -> max_map_len == 3
packed = b'\xde\x00\x04zzz'
with pytest.raises(UnpackValueError):
unpackb(packed, raw=False)
unpacker = Unpacker(max_buffer_size=6, raw=False)
unpacker.feed(packed)
with pytest.raises(UnpackValueError):
unpacker.unpack()
def testPackUnicode():
test_data = ["", "abcd", ["defgh"], "Русский текст"]
for td in test_data:
re = unpackb(packb(td, encoding='utf-8'), use_list=1, encoding='utf-8')
assert re == td
packer = Packer(encoding='utf-8')
data = packer.pack(td)
re = Unpacker(BytesIO(data), encoding=str('utf-8'),
use_list=1).unpack()
assert re == td
def __init__(self, fmt, stream):
"""Create MessagePack decoder.
:param stream: Stream
:type stream: file or io.IOBase
"""
self.format = fmt
self.stream = stream
self.unpacker = Unpacker(self.stream, encoding='utf-8')
def testPackUnicode():
test_data = [
six.u(""), six.u("abcd"), (six.u("defgh"),), six.u("Русский текст"),
]
for td in test_data:
re = unpackb(packb(td, encoding='utf-8'), encoding='utf-8')
assert_equal(re, td)
packer = Packer(encoding='utf-8')
data = packer.pack(td)
re = Unpacker(BytesIO(data), encoding='utf-8').unpack()
assert_equal(re, td)
def handle(self):
packer = Packer(use_bin_type=True)
unpacker = Unpacker(raw=False, max_buffer_size=10 * 1024 * 1024)
while True:
buf = self.cli_sock.recv(1024)
if not buf:
break
unpacker.feed(buf)
for request in unpacker:
response = self.process(request)
self.cli_sock.sendall(packer.pack(response))
def test_foobar_skip():
unpacker = Unpacker(read_size=3, use_list=1)
unpacker.feed(b'foobar')
assert unpacker.unpack() == ord(b'f')
unpacker.skip()
assert unpacker.unpack() == ord(b'o')
unpacker.skip()
assert unpacker.unpack() == ord(b'a')
unpacker.skip()
with raises(OutOfData):
unpacker.unpack()
def test_issue124():
unpacker = Unpacker()
unpacker.feed(b'\xa1?\xa1!')
assert tuple(unpacker) == (b'?', b'!')
assert tuple(unpacker) == ()
unpacker.feed(b"\xa1?\xa1")
assert tuple(unpacker) == (b'?', )
assert tuple(unpacker) == ()
unpacker.feed(b"!")
assert tuple(unpacker) == (b'!', )
assert tuple(unpacker) == ()
def testPackUnicode():
test_data = [
six.u(""), six.u("abcd"), [six.u("defgh")], six.u("Русский текст"),
]
for td in test_data:
re = unpackb(packb(td, encoding='utf-8'), use_list=1, encoding='utf-8')
assert re == td
packer = Packer(encoding='utf-8')
data = packer.pack(td)
re = Unpacker(BytesIO(data), encoding='utf-8', use_list=1).unpack()
assert re == td
def test_issue124():
unpacker = Unpacker()
unpacker.feed(b"\xa1?\xa1!")
assert tuple(unpacker) == ("?", "!")
assert tuple(unpacker) == ()
unpacker.feed(b"\xa1?\xa1")
assert tuple(unpacker) == ("?", )
assert tuple(unpacker) == ()
unpacker.feed(b"!")
assert tuple(unpacker) == ("!", )
assert tuple(unpacker) == ()
def test_has_correct_protocol_version(self):
"""
Checks that the command encoding function works corectly.
"""
raw_packet = encode_command(command_code=10)
unpacker = Unpacker()
unpacker.feed(raw_packet)
version, *_ = list(unpacker)
self.assertEqual(2, version)
def test_read_map_header():
unpacker = Unpacker()
unpacker.feed(packb({"a": "A"}))
assert unpacker.read_map_header() == 1
assert unpacker.unpack() == "a"
assert unpacker.unpack() == "A"
try:
unpacker.unpack()
assert 0, "should raise exception"
except OutOfData:
assert 1, "okay"
def test_read_map_header():
unpacker = Unpacker()
unpacker.feed(packb({'a': 'A'}))
assert unpacker.read_map_header() == 1
assert unpacker.unpack() == B'a'
assert unpacker.unpack() == B'A'
try:
unpacker.unpack()
assert 0, 'should raise exception'
except StopIteration:
assert 1, 'okay'
def test_foobar_skip():
unpacker = Unpacker(read_size=3, use_list=1)
unpacker.feed(b"foobar")
assert unpacker.unpack() == ord(b"f")
unpacker.skip()
assert unpacker.unpack() == ord(b"o")
unpacker.skip()
assert unpacker.unpack() == ord(b"a")
unpacker.skip()
with raises(OutOfData):
unpacker.unpack()
def setUp(self):
address = 0xDEADBEEF
data = bytes(range(4))
device = "dummy"
raw_packet = encode_write_flash(data, address, device)
unpacker = Unpacker()
unpacker.feed(raw_packet)
# Discards command set version
self.command = list(unpacker)[1:]
def testArraySize(sizes=[0, 5, 50, 1000]):
bio = BytesIO()
packer = Packer()
for size in sizes:
bio.write(packer.pack_array_header(size))
for i in range(size):
bio.write(packer.pack(i))
bio.seek(0)
unpacker = Unpacker(bio, use_list=1)
for size in sizes:
assert unpacker.unpack() == list(range(size))
def delta_status(self):
"""
Loop thread function that collects and updates delta's status and command's output
"""
recv_until = -1
unpacker = Unpacker()
while True:
if self.killthread:
self.udp_sock.close()
return
else:
buf = self.udp_sock.recv(4096)
payload = unpackb(buf)
# print(payload)
if payload[0] == 0:
if payload[2] - 1 - payload[
3] > recv_until: # finish_index = next_index - 1 - command_in_queue
for i in range(recv_until + 1,
payload[2] - 1 - payload[3] + 1):
if self.command_output[i]:
ret = self.control_sock.recv(4096)
unpacker.feed(ret)
ret = unpacker.__next__()
self.lock.acquire()
self.command_output[i] = self.command_output[
i](ret)
self.lock.release()
elif self.command_output[i] is False:
self.lock.acquire()
self.command_output[i] = None
self.lock.release()
else:
print(' --->>>no way!!',
self.command_output[i],
self.command_output)
recv_until = payload[2] - 1 - payload[3]
self.atomic_status((payload[2], payload[3]))
elif payload[0] == 1:
# print(payload)
self.lock.acquire()
self.head_status = payload[1:]
self.head_error = payload[3]
if self.head_error > 0:
if self.headerror_callback:
self.headerror_callback(self.head_error)
self.send_command([CMD_CLHE])
self.lock.release()
elif payload[0] == 2:
self.lock.acquire()
self.serial_status = payload[1:]
self.lock.release()
