def getreader(self):
return codec_v1.Reader(self.iface)
def make_reader(self) -> codec_v1.Reader:
return codec_v1.Reader(self.iface)
def test_reader():
rep_len = 64
interface_num = 0xdeadbeef
message_type = 0x4321
message_len = 250
interface = MockHID(interface_num)
reader = codec_v1.Reader(interface)
message = bytearray(range(message_len))
report_header = bytearray(unhexlify('3f23234321000000fa'))
# open, expected one read
first_report = report_header + message[:rep_len - len(report_header)]
assert_async(reader.aopen(), [
(None, select(io.POLL_READ | interface_num)),
(first_report, StopIteration()),
])
assert_eq(reader.type, message_type)
assert_eq(reader.size, message_len)
# empty read
empty_buffer = bytearray()
assert_async(reader.areadinto(empty_buffer), [
(None, StopIteration()),
])
assert_eq(len(empty_buffer), 0)
assert_eq(reader.size, message_len)
# short read, expected no read
short_buffer = bytearray(32)
assert_async(reader.areadinto(short_buffer), [
(None, StopIteration()),
])
assert_eq(len(short_buffer), 32)
assert_eq(short_buffer, message[:len(short_buffer)])
assert_eq(reader.size, message_len - len(short_buffer))
# aligned read, expected no read
aligned_buffer = bytearray(rep_len - len(report_header) -
len(short_buffer))
assert_async(reader.areadinto(aligned_buffer), [
(None, StopIteration()),
])
assert_eq(aligned_buffer,
message[len(short_buffer):][:len(aligned_buffer)])
assert_eq(reader.size,
message_len - len(short_buffer) - len(aligned_buffer))
# one byte read, expected one read
next_report_header = bytearray(unhexlify('3f'))
next_report = next_report_header + message[
rep_len - len(report_header):][:rep_len - len(next_report_header)]
onebyte_buffer = bytearray(1)
assert_async(reader.areadinto(onebyte_buffer), [
(None, select(io.POLL_READ | interface_num)),
(next_report, StopIteration()),
])
assert_eq(
onebyte_buffer, message[len(short_buffer):][len(aligned_buffer):]
[:len(onebyte_buffer)])
assert_eq(
reader.size, message_len - len(short_buffer) - len(aligned_buffer) -
len(onebyte_buffer))
# too long read, raises eof
assert_async(reader.areadinto(bytearray(reader.size + 1)), [
(None, EOFError()),
])
# long read, expect multiple reads
start_size = reader.size
long_buffer = bytearray(start_size)
report_payload = message[rep_len - len(report_header) + rep_len -
len(next_report_header):]
report_payload_head = report_payload[:rep_len - len(next_report_header) -
len(onebyte_buffer)]
report_payload_rest = report_payload[len(report_payload_head):]
report_payload_rest = list(
chunks(report_payload_rest, rep_len - len(next_report_header)))
report_payloads = [report_payload_head] + report_payload_rest
next_reports = [next_report_header + r for r in report_payloads]
expected_syscalls = []
for i, _ in enumerate(next_reports):
prev_report = next_reports[i - 1] if i > 0 else None
expected_syscalls.append(
(prev_report, select(io.POLL_READ | interface_num)))
expected_syscalls.append((next_reports[-1], StopIteration()))
assert_async(reader.areadinto(long_buffer), expected_syscalls)
assert_eq(long_buffer, message[-start_size:])
assert_eq(reader.size, 0)
# one byte read, raises eof
assert_async(reader.areadinto(onebyte_buffer), [
(None, EOFError()),
])
