def test_get_version_crc_response_error(self):
request = Packet().push_u16(Protocol.COMMAND_GET_VERSION).add_crc()
response = Packet().push_u16(Protocol.COMMAND_GET_VERSION).push_u16(
self.VERSION).push_u8(0)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*response"):
self.protocol.get_version()
def test_recv_all_types(self):
request = Packet().push_u16(0).add_crc()
response = Packet().push_u16(0).push_u8(0).push_u16(1).push_u32(2).push_u64(3). \
push_data(bytes([0, 1, 2, 3])).add_crc()
self.expect_transaction(request, response)
result = self.protocol.do_transaction(0, {}, {
"u8": {
"type": Protocol.TYPE_U8
},
"u16": {
"type": Protocol.TYPE_U16
},
"u32": {
"type": Protocol.TYPE_U32
},
"u64": {
"type": Protocol.TYPE_U64
},
"data": {
"type": Protocol.TYPE_DATA,
"length": 4
},
})
self.assertEqual(result["u8"], 0)
self.assertEqual(result["u16"], 1)
self.assertEqual(result["u32"], 2)
self.assertEqual(result["u64"], 3)
self.assertEqual(result["data"], bytes([0, 1, 2, 3]))
def test_memory_write(self):
request = Packet().push_u16(Protocol.COMMAND_MEMORY_WRITE).push_u64(self.ADDR). \
push_u32(len(self.DATA)).push_data(self.DATA).add_crc()
response = Packet().push_u16(Protocol.COMMAND_MEMORY_WRITE).push_u64(self.ADDR). \
push_u32(len(self.DATA)).add_crc()
self.expect_transaction(request, response)
self.protocol.memory_write(self.ADDR, self.DATA)
def test_register_write(self):
request = Packet().push_u16(Protocol.COMMAND_REGISTER_WRITE).push_u64(self.ADDR). \
push_u32(self.REGISTER_DATA).add_crc()
response = Packet().push_u16(Protocol.COMMAND_REGISTER_WRITE).push_u64(self.ADDR). \
push_u32(self.REGISTER_DATA).add_crc()
self.expect_transaction(request, response)
self.protocol.register_write(self.ADDR, self.REGISTER_DATA)
def test_get_version(self):
request = Packet().push_u16(Protocol.COMMAND_GET_VERSION).add_crc()
response = Packet().push_u16(Protocol.COMMAND_GET_VERSION).push_u16(
self.VERSION).add_crc()
self.expect_transaction(request, response)
self.assertEqual(self.protocol.get_version(), self.VERSION,
"Invalid version")
def test_send_all_types(self):
request = Packet().push_u16(0).push_u8(0).push_u16(1).push_u32(2).push_u64(3). \
push_data(bytes([0, 1, 2, 3])).add_crc()
response = Packet().push_u16(0).add_crc()
self.expect_transaction(request, response)
self.protocol.do_transaction(
0, {
"u8": {
"type": Protocol.TYPE_U8,
"value": 0
},
"u16": {
"type": Protocol.TYPE_U16,
"value": 1
},
"u32": {
"type": Protocol.TYPE_U32,
"value": 2
},
"u64": {
"type": Protocol.TYPE_U64,
"value": 3
},
"data": {
"type": Protocol.TYPE_DATA,
"value": bytes([0, 1, 2, 3])
},
}, {})
def test_memory_read(self):
request = Packet().push_u16(Protocol.COMMAND_MEMORY_READ).push_u64(self.ADDR). \
push_u32(len(self.DATA)).add_crc()
response = Packet().push_u16(Protocol.COMMAND_MEMORY_READ).push_u64(self.ADDR). \
push_u32(len(self.DATA)).push_data(self.DATA).add_crc()
self.expect_transaction(request, response)
self.assertEqual(self.protocol.memory_read(self.ADDR, len(self.DATA)),
self.DATA, "Invalid data")
def test_register_write_different_data(self):
request = Packet().push_u16(Protocol.COMMAND_REGISTER_WRITE).push_u64(self.ADDR). \
push_u32(self.REGISTER_DATA).add_crc()
response = Packet().push_u16(Protocol.COMMAND_REGISTER_WRITE).push_u64(self.ADDR). \
push_u32(self.REGISTER_DATA + 1).add_crc()
self.expect_transaction(request, response)
with self.expect_protocol_error("Different.*data"):
self.protocol.register_write(self.ADDR, self.REGISTER_DATA)
def test_register_read_different_address(self):
request = Packet().push_u16(Protocol.COMMAND_REGISTER_READ).push_u64(self.ADDR). \
add_crc()
response = Packet().push_u16(Protocol.COMMAND_REGISTER_READ).push_u64(self.ADDR + 1). \
push_u32(self.REGISTER_DATA).add_crc()
self.expect_transaction(request, response)
with self.expect_protocol_error("Different.*address"):
self.protocol.register_read(self.ADDR)
def test_register_read_crc_error(self):
request = Packet().push_u16(Protocol.COMMAND_REGISTER_READ).push_u64(self.ADDR). \
add_crc()
response = Packet().push_u16(Protocol.COMMAND_REGISTER_READ).push_u64(self.ADDR). \
push_u32(self.REGISTER_DATA).push_u8(0)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*response"):
self.protocol.register_read(self.ADDR)
def test_get_base_address_crc_response_error(self):
request = Packet().push_u16(
Protocol.COMMAND_GET_BASE_ADDRESS).add_crc()
response = Packet().push_u16(Protocol.COMMAND_GET_BASE_ADDRESS).push_u64(self.BASE). \
push_u8(0)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*response"):
self.protocol.get_base_address()
def test_get_base_address(self):
request = Packet().push_u16(
Protocol.COMMAND_GET_BASE_ADDRESS).add_crc()
response = Packet().push_u16(Protocol.COMMAND_GET_BASE_ADDRESS).push_u64(self.BASE). \
add_crc()
self.expect_transaction(request, response)
self.assertEqual(self.protocol.get_base_address(), self.BASE,
"Invalid base address")
def test_memory_read_different_address(self):
request = Packet().push_u16(Protocol.COMMAND_MEMORY_READ).push_u64(self.ADDR). \
push_u32(len(self.DATA)).add_crc()
response = Packet().push_u16(Protocol.COMMAND_MEMORY_READ).push_u64(self.ADDR + 1). \
push_u32(len(self.DATA)).push_data(self.DATA).add_crc()
self.expect_transaction(request, response)
with self.expect_protocol_error("Different.*address"):
self.protocol.memory_read(self.ADDR, len(self.DATA))
def test_memory_read_crc_error(self):
request = Packet().push_u16(Protocol.COMMAND_MEMORY_READ).push_u64(self.ADDR). \
push_u32(len(self.DATA)).add_crc()
response = Packet().push_u16(Protocol.COMMAND_MEMORY_READ).push_u64(self.ADDR). \
push_u32(len(self.DATA)).push_data(self.DATA).push_u8(0)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*response"):
self.protocol.memory_read(self.ADDR, len(self.DATA))
def test_memory_write_different_length(self):
request = Packet().push_u16(Protocol.COMMAND_MEMORY_WRITE).push_u64(self.ADDR). \
push_u32(len(self.DATA)).push_data(self.DATA).add_crc()
response = Packet().push_u16(Protocol.COMMAND_MEMORY_WRITE).push_u64(self.ADDR). \
push_u32(len(self.DATA) + 1).add_crc()
self.expect_transaction(request, response)
with self.expect_protocol_error("Different.*length"):
self.protocol.memory_write(self.ADDR, self.DATA)
def test_execute_different_address(self):
request = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(
self.ADDR).add_crc()
response = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(self.ADDR + 1). \
push_u64(self.RESULT).add_crc()
self.expect_transaction(request, response)
with self.expect_protocol_error("Different.*address"):
self.protocol.execute(self.ADDR)
def test_execute_crc_error(self):
request = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(
self.ADDR).add_crc()
response = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(self.ADDR). \
push_u64(self.RESULT).push_u8(0)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*response"):
self.protocol.execute(self.ADDR)
def test_execute(self):
request = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(
self.ADDR).add_crc()
response = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(self.ADDR). \
push_u64(self.RESULT).add_crc()
self.expect_transaction(request, response)
self.assertEqual(self.protocol.execute(self.ADDR), self.RESULT,
"Invalid result")
def test_register_read(self):
request = Packet().push_u16(Protocol.COMMAND_REGISTER_READ).push_u64(self.ADDR). \
add_crc()
response = Packet().push_u16(Protocol.COMMAND_REGISTER_READ).push_u64(self.ADDR). \
push_u32(self.REGISTER_DATA).add_crc()
self.expect_transaction(request, response)
self.assertEqual(self.REGISTER_DATA,
self.protocol.register_read(self.ADDR),
"Invalid register data")
def test_invalid_recv_type(self):
request = Packet().push_u16(0).add_crc()
response = Packet().push_u16(0).add_crc()
self.expect_transaction(request, response)
with self.expect_protocol_error("Invalid.*type"):
self.protocol.do_transaction(
0, {}, {"test": {
"type": 0xffff,
"value": 1
}})
def test_invalid_command(self):
request = Packet().push_u16(0).add_crc()
response = TestProtocol.create_error_packet(
Protocol.ERRORCODE_INVALID_COMMAND)
self.expect_transaction(request, response)
with self.expect_protocol_error("Invalid.*command.*target"):
self.protocol.do_transaction(0, {}, {})
def test_register_read_crc_target_error(self):
request = Packet().push_u16(Protocol.COMMAND_REGISTER_READ).push_u64(self.ADDR). \
add_crc()
response = self.create_error_packet(Protocol.ERRORCODE_INVALID_CRC)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*target"):
self.protocol.register_read(self.ADDR)
def recv_response(self, command, response):
""" Receives a response packet of the calculated length. """
response_payload_length = Protocol.calculate_response_length(response)
try:
packet = Packet()
packet.push_data(self.connection.recv(2)) # Command bytes
response_command = packet.peek_u16()
if command != response_command:
if Protocol.COMMAND_ERROR == response_command:
packet.push_data(self.connection.recv(5))
if not packet.check_crc():
raise self.ProtocolException(
"Invalid CRC in error response")
self.process_error_packet(packet)
raise self.ProtocolException(
"Invalid response command: 0x%04X" % response_command)
packet.push_data(self.connection.recv(response_payload_length))
if not packet.check_crc():
raise self.ProtocolException("Invalid CRC in response")
except Connection.ConnectionException as exception:
raise self.ProtocolException(exception)
return packet
def test_register_write_invalid_arg_error(self):
request = Packet().push_u16(Protocol.COMMAND_REGISTER_WRITE).push_u64(self.ADDR). \
push_u32(self.REGISTER_DATA).add_crc()
response = self.create_error_packet(Protocol.ERRORCODE_INVALID_ARG)
self.expect_transaction(request, response)
with self.expect_protocol_error("Invalid.*argument"):
self.protocol.register_write(self.ADDR, self.REGISTER_DATA)
def test_get_version_invalid_arg_error(self):
request = Packet().push_u16(Protocol.COMMAND_GET_VERSION).add_crc()
response = TestProtocol.create_error_packet(
Protocol.ERRORCODE_INVALID_ARG)
self.expect_transaction(request, response)
with self.expect_protocol_error("Invalid.*argument"):
self.protocol.get_version()
def send_request(self, command, request):
""" Builds a request packet and sends it. """
packet = Packet()
packet.push_u16(command)
for request_key in request:
element = request[request_key]
if element["type"] == Protocol.TYPE_U8:
packet.push_u8(element["value"])
elif element["type"] == Protocol.TYPE_U16:
packet.push_u16(element["value"])
elif element["type"] == Protocol.TYPE_U32:
packet.push_u32(element["value"])
elif element["type"] == Protocol.TYPE_U64:
packet.push_u64(element["value"])
elif element["type"] == Protocol.TYPE_DATA:
packet.push_data(element["value"])
else:
raise self.ProtocolException("Invalid data type: " +
str(element["type"]))
packet.add_crc()
try:
self.connection.send(packet.get_raw_data())
except Connection.ConnectionException as exception:
raise self.ProtocolException(exception)
def test_get_version_crc_target_error(self):
request = Packet().push_u16(Protocol.COMMAND_GET_VERSION).add_crc()
response = TestProtocol.create_error_packet(
Protocol.ERRORCODE_INVALID_CRC)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*target"):
self.protocol.get_version()
def test_execute_crc_target_error(self):
request = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(
self.ADDR).add_crc()
response = TestProtocol.create_error_packet(
Protocol.ERRORCODE_INVALID_CRC)
self.expect_transaction(request, response)
with self.expect_protocol_error("CRC.*target"):
self.protocol.execute(self.ADDR)
def test_memory_write_invalid_arg_error(self):
request = Packet().push_u16(Protocol.COMMAND_MEMORY_WRITE).push_u64(self.ADDR). \
push_u32(len(self.DATA)).push_data(self.DATA).add_crc()
response = TestProtocol.create_error_packet(
Protocol.ERRORCODE_INVALID_ARG)
self.expect_transaction(request, response)
with self.expect_protocol_error("Invalid.*argument"):
self.protocol.memory_write(self.ADDR, self.DATA)
def test_execute_invalid_arg_error(self):
request = Packet().push_u16(Protocol.COMMAND_EXECUTE).push_u64(
self.ADDR).add_crc()
response = TestProtocol.create_error_packet(
Protocol.ERRORCODE_INVALID_ARG)
self.expect_transaction(request, response)
with self.expect_protocol_error("Invalid.*argument"):
self.protocol.execute(self.ADDR)
