def test_encode_resp_version(self):
"""Test the process of encoding a version response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
resPacket = VersionCommand(Packet.MESSAGE_MODE_RESPONSE,
unknown1=254,
firmware=275,
hardware=0)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_PRINTER_VERSION,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
# Verify Payload
self.assertEqual(decodedPacket.payload['unknown1'], 254)
self.assertEqual(decodedPacket.payload['firmware'], '01.13')
self.assertEqual(decodedPacket.payload['hardware'], '00.00')
def test_encode_resp_send(self):
"""Test encoding a Send Image Response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
sequenceNumber = 5
resPacket = SendImageCommand(Packet.MESSAGE_MODE_RESPONSE,
sequenceNumber=sequenceNumber)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_SEND_IMAGE,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
# Verify Payload
self.assertEqual(decodedPacket.payload['sequenceNumber'],
sequenceNumber)
def test_premade_resp_prep(self):
"""Test Decoding a Prep Response."""
msg = bytearray.fromhex('2451 001c 9b60 d511 0457'
' 0000 1000 0015 f900 0000'
' 0000 0000 fc14 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_encode_resp_prep(self):
"""Test encoding a Prep Image Response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
maxLen = 60000
resPacket = PrepImageCommand(Packet.MESSAGE_MODE_RESPONSE,
maxLen=maxLen)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_PREP_IMAGE,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
# Verify Payload
self.assertEqual(decodedPacket.payload['maxLen'], maxLen)
def test_encode_resp_prePrint(self):
"""Test the process of encoding a pre print response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
cmdNumber = 8
respNumber = 1
resPacket = PrePrintCommand(Packet.MESSAGE_MODE_RESPONSE,
cmdNumber=cmdNumber,
respNumber=respNumber)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_PRE_PRINT,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
# Verify Payload
self.assertEqual(decodedPacket.payload['cmdNumber'], cmdNumber)
self.assertEqual(decodedPacket.payload['respNumber'], respNumber)
def test_encode_cmd_prep(self):
"""Test encoding a Prep Image Command."""
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
format = 16
options = 128
imgLength = 1440000
cmdPacket = PrepImageCommand(Packet.MESSAGE_MODE_COMMAND,
format=format,
options=options,
imgLength=imgLength)
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_PREP_IMAGE,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
# Verify Payload
self.assertEqual(decodedPacket.payload['format'], format)
self.assertEqual(decodedPacket.payload['options'], options)
self.assertEqual(decodedPacket.payload['imgLength'], imgLength)
def test_encode_resp_modelName(self):
"""Test the process of encoding a model name response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
modelName = 'SP-2'
resPacket = ModelNameCommand(Packet.MESSAGE_MODE_RESPONSE,
modelName=modelName)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_MODEL_NAME,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
# Verify Payload
self.assertEqual(decodedPacket.payload['modelName'], modelName)
def test_encode_resp_lock_state(self):
"""Test encoding a lock state Response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
unknownFourByteInt = 100
resPacket = LockStateCommand(Packet.MESSAGE_MODE_RESPONSE,
unknownFourByteInt=unknownFourByteInt)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_SET_LOCK_STATE,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
# Verify Payload
self.assertEqual(decodedPacket.payload['unknownFourByteInt'],
unknownFourByteInt)
def test_premade_resp_printCount(self):
"""Test Decoding a Print Count Response with an existing payload."""
msg = bytearray.fromhex('2ac1 0024 e759 eede 0000'
' 0000 0000 0027 0000 0003'
' 00f3 c048 0000 1645 001e'
' 0000 f946 0d0a')
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(msg)
self.assertEqual(decodedPacket.payload['printHistory'], 3)
def test_premade_resp_version(self):
"""Test Decoding a Version Response with an existing payload."""
msg = bytearray.fromhex('2ac0 001c e759 eede 0000'
' 0000 0000 0027 0101 0113'
' 0000 0000 fbb0 0d0a')
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(msg)
self.assertEqual(decodedPacket.payload['unknown1'], 257)
self.assertEqual(decodedPacket.payload['firmware'], '01.13')
self.assertEqual(decodedPacket.payload['hardware'], '00.00')
def test_premade_resp_specifications(self):
"""Test Decoding a Specifications Response with an existing payload."""
msg = bytearray.fromhex('2a4f 0030 e759 eede 0000 0000 0000 0027 0258'
' 0320 0100 000a 0000 0000 ea60 1000 0000 0000'
' 0000 0000 0000 0000 fa41 0d0a')
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(msg)
self.assertEqual(decodedPacket.payload['maxHeight'], 800)
self.assertEqual(decodedPacket.payload['maxWidth'], 600)
self.assertEqual(decodedPacket.payload['maxColours'], 256)
self.assertEqual(decodedPacket.payload['unknown1'], 10)
self.assertEqual(decodedPacket.payload['maxMsgSize'], 60000)
self.assertEqual(decodedPacket.payload['unknown2'], 16)
self.assertEqual(decodedPacket.payload['unknown3'], 0)
def test_encode_cmd_195(self):
"""Test encoding a Type 195 Command."""
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
cmdPacket = Type195Command(Packet.MESSAGE_MODE_COMMAND)
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_195,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
def test_encode_cmd_lock_state(self):
"""Test encoding a lock state Command."""
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
cmdPacket = LockStateCommand(Packet.MESSAGE_MODE_COMMAND)
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_SET_LOCK_STATE,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
def test_encode_cmd_modelName(self):
"""Test the process of encoding a model name command."""
# Create Model Name Command Packet
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
cmdPacket = ModelNameCommand(Packet.MESSAGE_MODE_COMMAND)
# Encodde the command to raw byte array
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
# Decode the command back into a packet object
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_MODEL_NAME,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
def test_encode_cmd_specifications(self):
"""Test the process of encoding a spcecifications command."""
# Create Specifications Command Packet
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
cmdPacket = SpecificationsCommand(Packet.MESSAGE_MODE_COMMAND)
# Encode the command to raw byte array
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
# Decode the command back into a packet object
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_SPECIFICATIONS,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
def test_encode_cmd_lock(self):
"""Test encoding a Lock Printer Command."""
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
lockState = 1
cmdPacket = PrinterLockCommand(Packet.MESSAGE_MODE_COMMAND,
lockState=lockState)
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_LOCK_DEVICE,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
# Verify Payload
self.assertEqual(decodedPacket.payload['lockState'], lockState)
def test_process_log(self):
"""Import a json log and replay the messages."""
filename = "priming.json"
json_data = open(filename)
data = json.load(json_data)
json_data.close()
print()
decodedPacketList = []
for packet in data:
readBytes = bytearray.fromhex(packet['bytes'])
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(readBytes)
# decodedPacket.printDebug()
packetObj = decodedPacket.getPacketObject()
decodedPacketList.append(packetObj)
pprint(decodedPacketList)
with open('log2.json', 'w') as outfile:
json.dump(decodedPacketList, outfile, indent=4)
def test_encode_resp_specifications(self):
"""Test the process of encoding a specifications response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
resPacket = SpecificationsCommand(Packet.MESSAGE_MODE_RESPONSE,
maxHeight=800,
maxWidth=600,
maxColours=256,
unknown1=10,
maxMsgSize=60000,
unknown2=16,
unknown3=0)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_SPECIFICATIONS,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
# Verify Payload
# print(decodedPacket.payload)
self.assertEqual(decodedPacket.payload['maxHeight'], 800)
self.assertEqual(decodedPacket.payload['maxWidth'], 600)
self.assertEqual(decodedPacket.payload['maxColours'], 256)
self.assertEqual(decodedPacket.payload['unknown1'], 10)
self.assertEqual(decodedPacket.payload['maxMsgSize'], 60000)
self.assertEqual(decodedPacket.payload['unknown2'], 16)
self.assertEqual(decodedPacket.payload['unknown3'], 0)
def test_encode_cmd_prePrint(self):
"""Test the process of encoding a prePrint command."""
# Create Model Name Command Packet
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
cmdNumber = 8
cmdPacket = PrePrintCommand(Packet.MESSAGE_MODE_COMMAND,
cmdNumber=cmdNumber)
# Encodde the command to raw byte array
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
# Decodee the command back into a packet object
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_PRE_PRINT,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
# Verify Payload
self.assertEqual(decodedPacket.payload['cmdNumber'], cmdNumber)
def test_encode_cmd_send(self):
"""Test encoding a Send Image Command."""
sessionTime = int(round(time.time() * 1000))
pinCode = 1111
sequenceNumber = 5
payloadBytes = bytearray(10)
cmdPacket = SendImageCommand(Packet.MESSAGE_MODE_COMMAND,
sequenceNumber=sequenceNumber,
payloadBytes=payloadBytes)
encodedCommand = cmdPacket.encodeCommand(sessionTime, pinCode)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedCommand)
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_COMMAND,
Packet.MESSAGE_TYPE_SEND_IMAGE,
len(encodedCommand),
cmdPacket.encodedSessionTime,
pinCode)
# Verify Payload
self.assertEqual(decodedPacket.payload['sequenceNumber'],
sequenceNumber)
self.assertEqual(decodedPacket.payload['payloadBytes'], payloadBytes)
def test_encode_resp_195(self):
"""Test encoding a Type 195 Response."""
sessionTime = int(round(time.time() * 1000))
returnCode = Packet.RTN_E_RCV_FRAME
ejecting = 0
battery = 2
printCount = 7
resPacket = Type195Command(Packet.MESSAGE_MODE_RESPONSE)
encodedResponse = resPacket.encodeResponse(sessionTime, returnCode,
ejecting, battery,
printCount)
packetFactory = PacketFactory()
decodedPacket = packetFactory.decode(encodedResponse)
# decodedPacket.printDebug()
postHeader = decodedPacket.header
self.helper_verify_header(postHeader,
Packet.MESSAGE_MODE_RESPONSE,
Packet.MESSAGE_TYPE_195,
len(encodedResponse),
resPacket.encodedSessionTime,
returnCode=returnCode,
ejecting=ejecting,
battery=battery,
printCount=printCount)
def test_premade_resp_lock(self):
"""Test Decoding a Lock Response."""
msg = bytearray.fromhex('2ab3 0014 75b8 bd8e 0000'
' 0000 0000 003a fc5c 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_cmd_lock(self):
"""Test Decoding a Lock Command."""
msg = bytearray.fromhex('24b3 0014 9619 02df 0457'
' 0000 0100 0000 fd28 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_cmd_prePrint(self):
"""Test Decoding a Pre Print Command."""
msg = bytearray.fromhex('24c4 0014 4e40 684c 0457'
' 0000 0000 0008 fd5e 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_cmd_modelName(self):
"""Test Decoding a Model Name Command."""
msg = bytearray.fromhex('24c2 0010 0b8d c2b4 0457 0000 fca0 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_resp_195_last(self):
"""Test decoding a 195 last response."""
msg = bytearray.fromhex('2ac3 0014 f130 d7cc 0000 0000'
' 0000 0035 fc05 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_resp_195_first(self):
"""Test decoding a 195 first response."""
msg = bytearray.fromhex('2ac3 0014 f130 d7cc 0000 0000'
' 7f00 0436 fb81 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_cmd_195(self):
"""Test decoding a 195 command."""
msg = bytearray.fromhex('24c3 0010 f130 d7cc 0457 0000 fbe9 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_resp_lock_state(self):
"""Test decoding a Lock state response."""
msg = bytearray.fromhex('2ab0 0018 f130 d7cc 0000 0000'
' 0000 0036 0000 0064 fbaf 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)
def test_premade_cmd_lock_state(self):
"""Test decoding a Lock state command."""
msg = bytearray.fromhex('24b0 0010 f776 ecbe 0457 0000 fba9 0d0a')
packetFactory = PacketFactory()
packetFactory.decode(msg)