def getwriter(self):
return codec_v1.Writer(self.iface)
def make_writer(self) -> codec_v1.Writer:
return codec_v1.Writer(self.iface)
def test_writer():
rep_len = 64
interface_num = 0xdeadbeef
message_type = 0x87654321
message_len = 1024
interface = MockHID(interface_num)
writer = codec_v1.Writer(interface)
writer.setheader(message_type, message_len)
# init header corresponding to the data above
report_header = bytearray(unhexlify('3f2323432100000400'))
assert_eq(writer.data,
report_header + bytearray(rep_len - len(report_header)))
# empty write
start_size = writer.size
assert_async(writer.awrite(bytearray()), [
(None, StopIteration()),
])
assert_eq(writer.data,
report_header + bytearray(rep_len - len(report_header)))
assert_eq(writer.size, start_size)
# short write, expected no report
start_size = writer.size
short_payload = bytearray(range(4))
assert_async(writer.awrite(short_payload), [
(None, StopIteration()),
])
assert_eq(writer.size, start_size - len(short_payload))
assert_eq(
writer.data, report_header + short_payload +
bytearray(rep_len - len(report_header) - len(short_payload)))
# aligned write, expected one report
start_size = writer.size
aligned_payload = bytearray(
range(rep_len - len(report_header) - len(short_payload)))
assert_async(writer.awrite(aligned_payload), [
(None, select(io.POLL_WRITE | interface_num)),
(None, StopIteration()),
])
assert_eq(interface.data, [
report_header + short_payload + aligned_payload +
bytearray(rep_len - len(report_header) - len(short_payload) -
len(aligned_payload)),
])
assert_eq(writer.size, start_size - len(aligned_payload))
interface.data.clear()
# short write, expected no report, but data starts with correct seq and cont marker
report_header = bytearray(unhexlify('3f'))
start_size = writer.size
assert_async(writer.awrite(short_payload), [
(None, StopIteration()),
])
assert_eq(writer.size, start_size - len(short_payload))
assert_eq(writer.data[:len(report_header) + len(short_payload)],
report_header + short_payload)
# long write, expected multiple reports
start_size = writer.size
long_payload_head = bytearray(
range(rep_len - len(report_header) - len(short_payload)))
long_payload_rest = bytearray(range(start_size - len(long_payload_head)))
long_payload = long_payload_head + long_payload_rest
expected_payloads = [short_payload + long_payload_head] + list(
chunks(long_payload_rest, rep_len - len(report_header)))
expected_reports = [report_header + r for r in expected_payloads]
expected_reports[-1] += bytearray(
bytes(1) * (rep_len - len(expected_reports[-1])))
# test write
expected_write_reports = expected_reports[:-1]
assert_async(
writer.awrite(long_payload),
len(expected_write_reports) *
[(None, select(io.POLL_WRITE | interface_num))] +
[(None, StopIteration())])
assert_eq(interface.data, expected_write_reports)
assert_eq(writer.size, start_size - len(long_payload))
interface.data.clear()
# test write raises eof
assert_async(writer.awrite(bytearray(1)), [(None, EOFError())])
assert_eq(interface.data, [])
# test close
expected_close_reports = expected_reports[-1:]
assert_async(
writer.aclose(),
len(expected_close_reports) *
[(None, select(io.POLL_WRITE | interface_num))] +
[(None, StopIteration())])
assert_eq(interface.data, expected_close_reports)
assert_eq(writer.size, 0)