def test_error_reporting(self):
"""Tests that StreamWriter records errors received correctly
and stores those values in the TransmissionError Thrown.
"""
expected_errors = [
'CRCMismatchError',
'CRCMismatchError',
'CRCMismatchError',
'GenericError',
'GenericError',
]
response_payload = bytearray()
response_payload.append(constants.response_code_dict['CRC_MISMATCH'])
for i in range(3):
self.outputstream.write(Encoder.encode_payload(response_payload))
response_payload = bytearray()
response_payload.append(constants.response_code_dict['GENERIC_PACKET_ERROR'])
for i in range(2):
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
payload = 'asdf'
try:
self.w.send_command(payload)
except errors.TransmissionError as e:
self.assertEqual(expected_errors, e.value)
def test_build_and_send_action_payload(self):
command = constants.host_action_command_dict['QUEUE_EXTENDED_POINT_NEW']
point = [1, 2, 3, 4, 5]
duration = 42
relativeAxes = 0
expected_payload = struct.pack(
'<BiiiiiIB',
command,
point[0], point[1], point[2], point[3], point[4],
duration,
relativeAxes
)
response_payload = bytearray()
response_payload.append(constants.response_code_dict['SUCCESS'])
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
payload = struct.pack(
'<BiiiiiIB',
command,
point[0], point[1], point[2], point[3], point[4],
duration,
relativeAxes,
)
self.w.send_action_payload(payload)
self.assertEquals(Encoder.encode_payload(expected_payload), self.inputstream.getvalue())
def test_unpack_response(self):
expected_data = [1,'a','b','c']
b = bytearray()
b.extend(Encoder.encode_uint32(1))
for data in expected_data[1:]:
b.append(data)
data = Encoder.unpack_response('<Iccc',b)
for i in range(0, len(expected_data)):
assert(data[i] == expected_data[i])
def test_unpack_response_with_string(self):
expected_data = [1, 'a', 'b', 'c', 'ABCDE\x00']
b = bytearray()
b.extend(Encoder.encode_uint32(1))
for data in expected_data[1:-1]:
b.append(data)
b.extend(expected_data[-1])
data = Encoder.unpack_response_with_string('<Iccc',b)
for expected, d in zip(expected_data, data):
self.assertEqual(expected, d)
def test_send_command(self):
"""
Passing case: Preload the buffer with a correctly formatted expected response, and verigy that it works correctly
"""
payload = 'abcde'
response_payload = bytearray()
response_payload.append(constants.response_code_dict['SUCCESS'])
response_payload.extend('12345')
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
self.assertEqual(response_payload, self.w.send_command(payload))
self.assertEqual(Encoder.encode_payload(payload), self.inputstream.getvalue())
def test_send_packet_timeout(self):
"""
Time out when no data is received. The input stream should have max_rety_count copies of the
payload packet in it.
"""
payload = 'abcde'
packet = Encoder.encode_payload(payload)
expected_packet = Encoder.encode_payload(payload)
self.assertRaises(errors.TransmissionError,self.w.send_packet, packet)
self.inputstream.seek(0)
for i in range (0, constants.max_retry_count):
for byte in expected_packet:
self.assertEquals(byte, ord(self.inputstream.read(1)))
def test_send_packet(self):
"""
Passing case: Preload the buffer with a correctly formatted expected response, and
verify that it works correctly.
"""
payload = "abcde"
packet = Encoder.encode_payload(payload)
response_payload = bytearray()
response_payload.append(constants.response_code_dict["SUCCESS"])
response_payload.extend("12345")
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
self.assertEquals(response_payload, self.w.send_packet(packet))
self.assertEquals(Encoder.encode_payload(payload), self.inputstream.getvalue())
def test_build_and_send_query_payload_with_null_terminated_string(self):
cmd = constants.host_query_command_dict["GET_NEXT_FILENAME"]
flag = 0x01
payload = struct.pack("<BB", cmd, flag)
filename = "asdf\x00"
response_payload = bytearray()
response_payload.append(constants.response_code_dict["SUCCESS"])
response_payload.append(constants.sd_error_dict["SUCCESS"])
response_payload.extend(filename)
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
payload = struct.pack("<bb", cmd, flag)
self.assertEqual(response_payload, self.w.send_query_payload(payload))
self.assertEqual(Encoder.encode_payload(payload), self.inputstream.getvalue())
def test_build_and_send_query_payload(self):
cmd = constants.host_query_command_dict["GET_VERSION"]
s3gVersion = 123
botVersion = 456
expected_payload = struct.pack("<bH", cmd, s3gVersion)
response_payload = bytearray()
response_payload.append(constants.response_code_dict["SUCCESS"])
response_payload.extend(Encoder.encode_uint16(botVersion))
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
payload = struct.pack("<bH", cmd, s3gVersion)
self.assertEquals(response_payload, self.w.send_query_payload(payload))
self.assertEquals(Encoder.encode_payload(expected_payload), self.inputstream.getvalue())
def test_unpack_response_with_string_no_format(self):
expected_string = 'abcde\x00'
b = bytearray()
b.extend(expected_string)
data = Encoder.unpack_response_with_string('',b)
assert(len(data) == 1)
assert data[0] == expected_string
def test_external_stop_works_precondition(self): response_payload = bytearray() response_payload.append(constants.response_code_dict['SUCCESS']) self.outputstream.write(Encoder.encode_payload(response_payload)) self.outputstream.seek(0) self.w.set_external_stop() self.assertRaises(errors.ExternalStopError, self.w.send_command, 'asdf')
def test_decode_uint16(self):
cases = [
[0, '\x00\x00'],
[32767, '\xFF\x7F'],
[65535, '\xFF\xFF'],
]
for case in cases:
self.assertEqual(Encoder.decode_uint16(case[1]), case[0])
def test_decode_int32_bytearray(self):
cases = [
[0, bytearray('\x00\x00\x00\x00')],
[-65536, '\x00\x00\xFF\xFF'],
[16, '\x10\x00\x00\x00'],
]
for case in cases:
self.assertEqual(case[0], Encoder.decode_int32(case[1]))
def test_encode_uint16(self):
cases = [
[0, '\x00\x00'],
[32767, '\xFF\x7F'],
[65535, '\xFF\xFF'],
]
for case in cases:
assert Encoder.encode_uint16(case[0]) == case[1]
def test_encode_uint32(self):
cases = [
[0, '\x00\x00\x00\x00'],
[2147483647, '\xFF\xFF\xFF\x7F'],
[4294967295, '\xFF\xFF\xFF\xFF'],
]
for case in cases:
assert Encoder.encode_uint32(case[0]) == case[1]
def test_encode_int32(self):
cases = [
[0, '\x00\x00\x00\x00'],
[-2147483648, '\x00\x00\x00\x80'],
[2147483647, '\xFF\xFF\xFF\x7F'],
]
for case in cases:
assert Encoder.encode_int32(case[0]) == case[1]
def test_decode_uint16_bytearray(self):
byteArrayCases = [
[0, bytearray('\x00\x00')],
[32767, bytearray('\xff\x7f')],
[65535, bytearray('\xff\xff')],
]
for case in byteArrayCases:
self.assertEqual(Encoder.decode_uint16(case[1]), case[0])
def test_decode_bitfield(self):
cases = [
[[True for i in range(8)], 255],
[[False for i in range(8)], 0],
[[True, False, True, False, True, False, True, False], 85],
]
for case in cases:
self.assertEqual(case[0], Encoder.decode_bitfield(case[1]))
def test_got_payload(self):
expected_payload = bytearray('abcde')
packet = bytearray()
packet.append(constants.header)
packet.append(len(expected_payload))
packet.extend(expected_payload)
packet.append(Encoder.CalculateCRC(expected_payload))
payload = Encoder.decode_packet(packet)
assert payload == expected_payload
def test_build_and_send_query_payload_with_null_terminated_string(self):
cmd = constants.host_query_command_dict['GET_NEXT_FILENAME']
flag = 0x01
payload = struct.pack('<BB', cmd, flag)
filename = 'asdf\x00'
response_payload = bytearray()
response_payload.append(constants.response_code_dict['SUCCESS'])
response_payload.append(constants.sd_error_dict['SUCCESS'])
response_payload.extend(filename)
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
payload = struct.pack(
'<bb',
cmd,
flag,
)
self.assertEqual(response_payload, self.w.send_query_payload(payload))
self.assertEqual(Encoder.encode_payload(payload),
self.inputstream.getvalue())
def test_build_and_send_query_payload(self):
cmd = constants.host_query_command_dict['GET_VERSION']
s3gVersion = 123
botVersion = 456
expected_payload = struct.pack('<bH', cmd, s3gVersion)
response_payload = bytearray()
response_payload.append(constants.response_code_dict['SUCCESS'])
response_payload.extend(Encoder.encode_uint16(botVersion))
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
payload = struct.pack(
'<bH',
cmd,
s3gVersion,
)
self.assertEquals(response_payload, self.w.send_query_payload(payload))
self.assertEquals(Encoder.encode_payload(expected_payload),
self.inputstream.getvalue())
def test_encode_axes(self):
cases = [
[['X', 'Y', 'Z', 'A', 'B'], 0x1F],
[['x','y','z','a','b'], 0x1F],
[['x'], 0x01],
[['y'], 0x02],
[['z'], 0x04],
[['a'], 0x08],
[['b'], 0x10],
[[], 0x00],
]
for case in cases:
assert Encoder.encode_axes(case[0]) == case[1]
def test_send_packet_many_bad_responses(self):
"""
Passing case: test that the transmission can recover from one less than the alloted
number of errors.
"""
payload = 'abcde'
packet = Encoder.encode_payload(payload)
expected_packet = Encoder.encode_payload(payload)
response_payload = bytearray()
response_payload.append(constants.response_code_dict['SUCCESS'])
response_payload.extend('12345')
for i in range (0, constants.max_retry_count - 1):
self.outputstream.write('a')
self.outputstream.write(Encoder.encode_payload(response_payload))
self.outputstream.seek(0)
self.assertEquals(response_payload, self.w.send_packet(packet))
self.inputstream.seek(0)
for i in range (0, constants.max_retry_count - 1):
for byte in expected_packet:
self.assertEquals(byte, ord(self.inputstream.read(1)))
def test_packet_crc(self): payload = 'abcd' packet = Encoder.encode_payload(payload) assert packet[6] == Encoder.CalculateCRC(payload);
def test_packet_length_field(self): payload = 'abcd' packet = Encoder.encode_payload(payload) assert packet[1] == len(payload)
def test_packet_header(self):
payload = 'abcd'
packet = Encoder.encode_payload(payload)
assert packet[0] == constants.header
def test_packet_length(self): payload = 'abcd' packet = Encoder.encode_payload(payload) assert len(packet) == len(payload) + 3
def test_unpack_response_with_string_empty_string(self):
expected_string = '\x00'
b = bytearray()
b.append(expected_string)
data = Encoder.unpack_response_with_string('', b)
self.assertEqual(expected_string, data[0])