def test_decode_aligned_int(self): sint = Int(1, 'foo', None, align='4') decoded = sint.decode(to_bin('0xb800 0000'), None) self.assertEquals(decoded.int, -72) self.assertEquals(decoded.hex, '0xb8') self.assertEquals(len(decoded), 4) self.assertEquals(decoded._raw, to_bin('0xb800 0000'))
def test_decode_little_endian_container(self): container = self._2_byte_container() decoded = container.decode(to_bin("0x0190"), little_endian=True) self.assertEqual(1, decoded.oneBit.int) self.assertEqual(1, decoded.threeBits.int) self.assertEqual(1, decoded.twelveBits.int) self.assertEquals(decoded._raw, to_bin("0x0190"))
def test_decode_aligned(self): struct = get_struct_with_length_and_alignment() decoded = struct.decode(to_bin('0x00010200'), {}) self.assertEqual(decoded.first.int, 1) self.assertEqual(decoded.second.int, 2) self.assertEqual(len(decoded), 4) self.assertEqual(decoded._raw, to_bin('0x00010200'))
def test_decode_aligned_uint(self): uint = UInt(1, 'foo', None, align='4') decoded = uint.decode(to_bin('0xff00 0000'), None) self.assertEquals(decoded.int, 255) self.assertEquals(decoded.hex, '0xff') self.assertEquals(len(decoded), 4) self.assertEquals(decoded._raw, to_bin('0xff00 0000'))
def test_little_endian_struct_encode(self): pair = _get_pair() encoded = pair.encode({}, little_endian=True) self.assertEquals(encoded.first.hex, '0x0001') self.assertEquals(encoded.first._raw, to_bin('0x0100')) self.assertEquals(encoded.second.hex, '0x0002') self.assertEquals(encoded.second._raw, to_bin('0x0200'))
def test_little_endian_list_encode(self): struct_list = _get_struct_list() encoded = struct_list.encode({}, None, little_endian=True) self.assertEquals(encoded[0].first.hex, '0x0001') self.assertEquals(encoded[0].first._raw, to_bin('0x0100')) self.assertEquals(encoded[0].second.hex, '0x0002') self.assertEquals(encoded[0].second._raw, to_bin('0x0200'))
def _assert_align(self, value, length, raw): field = Field('uint', 'name', to_bin(value), aligned_len=length) self.assertEquals(field.int, int(value, 16)) self.assertEquals(field.hex, value) self.assertEquals(field._raw, to_bin(raw)) self.assertEquals(field.bytes, to_bin(value)) if length: self.assertEquals(len(field), length)
def test_decode_little_endian_header(self): byte_stream = MockStream(to_bin('0x0500 0800 cafe babe')) self._msg_stream = MessageStream(byte_stream, self._protocol, threading.RLock()) decoded = self._msg_stream.get(self.tmp) self.assertEquals(decoded._header.msgId.hex, '0x0005') self.assertEquals(decoded._header.msgId._raw, to_bin('0x0500')) self.assertEquals(decoded.field_1.hex, '0xcafe') self.assertEquals(decoded.field_1._raw, to_bin('0xcafe')) self.assertEquals(decoded.field_2.hex, '0xbabe') self.assertEquals(decoded.field_2._raw, to_bin('0xbabe'))
def test_validate_int(self): field = Field('int', 'field', to_bin('0xffb8')) self._should_pass(Int(2, 'field', -72).validate({'field': field}, {})) self._should_pass(Int(2, 'field', '-72').validate({'field': field}, {})) self._should_pass(Int(2, 'field', '-0x48').validate({'field': field}, {})) self._should_pass(Int(2, 'field', '-0x0048').validate({'field': field}, {})) self._should_pass(Int(2, 'field', '(0|-72)').validate({'field': field}, {}))
def test_encode_aligned_int(self): sint = Int(1, 'foo', '-72', align='4') encoded = sint.encode({}, {}, None) self.assertEquals(encoded.int, -72) self.assertEquals(encoded.hex, '0xb8') self.assertEquals(len(encoded), 4) self.assertEquals(encoded._raw, to_bin('0xb800 0000'))
def test_encode_aligned_uint(self): uint = UInt(1, 'foo', '0xff', align='4') encoded = uint.encode({}, {}, None) self.assertEquals(encoded.int, 255) self.assertEquals(encoded.hex, '0xff') self.assertEquals(len(encoded), 4) self.assertEquals(encoded._raw, to_bin('0xff00 0000'))
def test_decode_message(self): list = ListTemplate('5', 'five', parent=None) list.add(UInt(4, None, 3)) decoded = list.decode(to_bin('0x' + ('00000003' * 5)), {}) self.assertEquals(len(decoded[4]), 4) self.assertEquals(len(decoded), 20) self.assertEquals(decoded[0].int, 3)
def test_encode_little_endian_container(self): container = self._2_byte_container() encoded = container.encode({'foo.threeBits': 1, 'foo.twelveBits': 1}, little_endian=True) self.assertEqual(1, encoded.oneBit.int) self.assertEqual(1, encoded.threeBits.int) self.assertEqual(1, encoded.twelveBits.int) self.assertEquals(encoded._raw, to_bin("0x0190"))
def test_validate_uint(self): field = Field('uint', 'field', to_bin('0x0004')) self._should_pass(UInt(2, 'field', 4).validate({'field': field}, {})) self._should_pass(UInt(2, 'field', '4').validate({'field': field}, {})) self._should_pass(UInt(2, 'field', '0x04').validate({'field': field}, {})) self._should_pass(UInt(2, 'field', '0x0004').validate({'field': field}, {})) self._should_pass(UInt(2, 'field', '(0|4)').validate({'field': field}, {}))
def test_decode_raw_bytes_with_star_length(self): container = TBCDContainerTemplate('tbcd', None) container.add(TBCD('3', 'first', '123')) container.add(TBCD('*', 'second', '6100000000001')) decoded = container.decode(to_bin("0b0010000101100011000000010000000000000000000000000000000000010000")) self.assertEquals('123', decoded.first.tbcd) self.assertEquals('6100000000001', decoded.second.tbcd)
def test_conversions(self): field = Field('unit', 'name', to_bin('0x00616200')) self.assertEquals(field.int, 0x00616200) self.assertEquals(field.hex, '0x00616200') self.assertEquals(field.ascii, 'ab') self.assertEquals(field.bytes, '\x00\x61\x62\x00') self.assertEquals(field.chars, 'ab') self.assertEquals(field.bin, '0b00000000' + '01100001' + '01100010' + '00000000')
def test_conversions(self): field = Field("unit", "name", to_bin("0x00616200")) self.assertEquals(field.int, 0x00616200) self.assertEquals(field.hex, "0x00616200") self.assertEquals(field.ascii, "ab") self.assertEquals(field.bytes, "\x00\x61\x62\x00") self.assertEquals(field.chars, "ab") self.assertEquals(field.bin, "0b00000000" + "01100001" + "01100010" + "00000000")
def _matches(self, header, fields, header_filter): if header_filter: if header_filter not in fields: raise AssertionError('Trying to filter messages by header field %s, but no value has been set for %s' % (header_filter, header_filter)) if header[header_filter].bytes != to_bin(fields[header_filter]): return False return True
def test_encode_perfectly_aligned(self): struct = get_struct_with_length_and_alignment() struct.add(UInt(5, 'third', 3)) encoded = struct.encode({}, {}) self.assertEqual(encoded.first.int, 1) self.assertEqual(encoded.second.int, 2) self.assertEqual(encoded.third.int, 3) self.assertEqual(len(encoded), 8) self.assertEqual(encoded._raw, to_bin('0x00010200 00000003'))
def _matches(self, header, fields, header_filter): # FIXME: Matching should not be assuming matching string presentation if header_filter: if header_filter not in fields: raise AssertionError('Trying to filter messages by header field %s, but no value has been set for %s' % (header_filter, header_filter)) if header[header_filter].bytes != to_bin(fields[header_filter]): return False return True
def test_pretty_print_primitive_list(self): decoded = _get_list_of_three().decode(to_bin('0x' + ('0003' * 3)), {}) self.assertEquals('\n' + repr(decoded), """ uint topthree[] 0 = 3 (0x0003) 1 = 3 (0x0003) 2 = 3 (0x0003) """)
def test_decode_dynamic_list(self): tmp = MessageTemplate('Dymagic', self._protocol, {}) tmp.add(UInt(2, 'len', None)) lst = ListTemplate('len', 'foo', parent=None) lst.add(UInt(1, 'bar', None)) tmp.add(lst) decoded = tmp.decode(to_bin('0x 00 04 6162 6364')) self.assertEquals(decoded.len.int, 4) self.assertEquals(decoded.foo[0].hex, '0x61')
def test_binary_to_bin(self): self.assertEquals(to_bin("0b0"), "\x00") self.assertEquals(to_bin("0b1"), "\x01") self.assertEquals(to_bin("0b1111 1111"), "\xff") self.assertEquals(to_bin("0b1 0000 0000"), "\x01\x00") self.assertEquals(to_bin("0b01 0b01 0b01"), "\x15") self.assertEquals(to_bin("0b11" * 32), "\xff\xff\xff\xff\xff\xff\xff\xff") self.assertEquals(to_bin("0b11" * 1024), "\xff\xff\xff\xff\xff\xff\xff\xff" * 32)
def test_decode_dynamic_primitive(self): tmp = MessageTemplate('Dymagic', self._protocol, {}) tmp.add(UInt(1, 'len', None)) tmp.add(Char('len', 'chars', None)) tmp.add(UInt(1, 'len2', None)) tmp.add(Char('len2', 'chars2', None)) decoded = tmp.decode(to_bin('0x 04 6162 6364 02 6566')) self.assertEquals(decoded.len.int, 4) self.assertEquals(decoded.chars.ascii, 'abcd') self.assertEquals(decoded.chars2.ascii, 'ef')
def setUp(self): self._protocol = Protocol("Test") self._protocol.add(UInt(1, "id", 1)) self._protocol.add(UInt(2, "length", None)) self._protocol.add(PDU("length-2")) self._msg = MessageTemplate("FooRequest", self._protocol, {"id": "0xaa"}) self._msg.add(UInt(1, "field_1", None)) self._msg.add(UInt(1, "field_2", None)) byte_stream = MockStream(to_bin("0xff0004cafe aa0004dead dd0004beef")) self._msg_stream = MessageStream(byte_stream, self._protocol, threading.RLock())
def setUp(self): self._protocol = Protocol('Test') self._protocol.add(UInt(1, 'id', 1)) self._protocol.add(UInt(2, 'length', None)) self._protocol.add(PDU('length-2')) self._msg = MessageTemplate('FooRequest', self._protocol, {'id': '0xaa'}) self._msg.add(UInt(1, 'field_1', None)) self._msg.add(UInt(1, 'field_2', None)) byte_stream = MockStream(to_bin('0xff0004cafe aa0004dead dd0004beef')) self._msg_stream = MessageStream(byte_stream, self._protocol)
def test_pretty_print_list_list(self): decoded = _get_list_list().decode(to_bin('0x' + ('0003' * 4)), {}) self.assertEquals('\n' + repr(decoded), """ List listlist[] uint 0[] 0 = 3 (0x0003) 1 = 3 (0x0003) uint 1[] 0 = 3 (0x0003) 1 = 3 (0x0003) """)
def test_hex_to_bin(self): self.assertEquals(to_bin("0x0"), "\x00") self.assertEquals(to_bin("0x00"), "\x00") self.assertEquals(to_bin("0x5"), "\x05") self.assertEquals(to_bin("0xff"), "\xff") self.assertEquals(to_bin("0x100"), "\x01\x00") self.assertEquals(to_bin("0x01 0x02 0x03"), "\x01\x02\x03")
def test_to_tbcd_binary(self): self.assertEquals(to_bin("0b11110001"), to_tbcd_binary("1")) self.assertEquals(to_bin("0b00010001"), to_tbcd_binary("11")) self.assertEquals(to_bin("0b11110010"), to_tbcd_binary("2")) self.assertEquals(to_bin("0b00110010"), to_tbcd_binary("23")) self.assertEquals(to_bin("0b0010000111110011"), to_tbcd_binary("123")) self.assertEquals( to_bin("0b0110001000010010000000100000000000000000000000000000000011110001"), to_tbcd_binary("262120000000001"), )
def _matches(self, header, fields, header_filter): if header_filter: if header_filter not in fields: raise AssertionError('Trying to filter messages by header field %s, but no value has been set for %s' % (header_filter, header_filter)) field = header[header_filter] if field._type == 'chars': if fields[header_filter].startswith('REGEXP:'): try: regexp = fields[header_filter].split(':')[1].strip() return bool(re.match(regexp, field.ascii)) except re.error as e: raise Exception("Invalid RegEx Error : " + str(e)) return field.ascii == fields[header_filter] if field._type == 'uint': return field.uint == to_int(fields[header_filter]) if header[header_filter].bytes != to_bin(fields[header_filter]): return False return True
def test_validate_union(self): union = self._get_foo_union() decoded = union.decode(to_bin('0xcafebabe')) self._should_pass(union.validate({'foo': decoded}, {'foo.small': '', 'foo.medium': ''})) self._should_fail(union.validate({'foo': decoded}, {'foo.small': '0xff', 'foo.medium': ''}), 1)
def test_validate_struct_union(self): struct = get_pair() union = self._get_foo_union() struct.add(union) decoded = struct.decode(to_bin('0xcafebabe f00dd00d')) self._should_fail(struct.validate({'pair': decoded}, {}), 3)
def test_not_enough_data(self): template = get_list_of_three() self.assertRaises(Exception, template.decode, to_bin('0x00010002'))
def test_decode_union(self): union = self._get_foo_union() decoded = union.decode(to_bin('0xcafebabe')) self.assertEquals(decoded.small.hex, '0xca') self.assertEquals(decoded.medium.hex, '0xcafe') self.assertEquals(decoded.large.hex, '0xcafebabe')
def test_conversions(self): self.assertEqual(self.cont.seven.int, 42) self.assertEqual(self.cont.seven.bytes, to_bin(42)) self.assertEqual(self.cont.seven.ascii, '*')
def test_little_endian_with_align(self): field = Field('uint', 'name', to_bin('0x0100'), aligned_len=5, little_endian=True) self.assertEquals(field._raw, to_bin('0x0100000000')) self.assertEquals(field.int, 1) self.assertEquals(field.bytes, to_bin('0x0001')) self.assertEquals(field.hex, '0x0001')
def test_decode_several_structs(self): str_list = get_struct_list() decoded = str_list.decode(to_bin('0xcafebabe d00df00d'), {}) self.assertEquals(decoded[0].first.hex, '0xcafe') self.assertEquals(decoded[1].second.hex, '0xf00d')
def test_encode_union_with_param(self): union = self._get_foo_union() encoded = union.encode({'foo': 'small', 'foo.small': '0xff'}, {}) self.assertEquals(encoded._raw, to_bin('0xff00 0000'))
def test_get_bytes_from_decoded_union(self): union = self._get_foo_union() decoded = union.decode(to_bin('0xcafebabe')) self.assertEquals(decoded._raw, to_bin('0xcafebabe'))
def test_fail_validating_uint(self): template = UInt(2, 'field', 4) field = Field('uint', 'field', to_bin('0x0004')) self._should_fail(template.validate({'field': field}, {'field': '42'}), 1)
def _bin_container(self, little_endian=False): cont = BinaryContainer('foo', little_endian=little_endian) cont['three'] = BinaryField(3, 'three', to_bin('0b101')) cont['six'] = BinaryField(6, 'six', to_bin('0b101010')) cont['seven'] = BinaryField(7, 'seven', to_bin('0b0101010')) return cont
def test_little_endian_int_encode(self): template = Int(2, 'field', -72) field = template.encode({}, {}, None, little_endian=True) self.assertEquals(field._raw, to_bin('0xb8ff')) self.assertEquals(field.int, -72) self.assertEquals(field.bytes, to_bin('0xffb8'))
def test_little_endian_uint_encode(self): template = UInt(2, 'field', 1) field = template.encode({}, {}, None, little_endian=True) self.assertEquals(field._raw, to_bin('0x0100')) self.assertEquals(field.int, 1) self.assertEquals(field.bytes, to_bin('0x0001'))
def _binary_substring(self, bin_str, data_index, field): return to_bin("0b" + bin_str[data_index:data_index + field.length.value])
def test_little_endian_bin_container(self): little = self._bin_container(little_endian=True) self.assertEqual(little.three.bin, '0b101') self.assertEqual(little.six.bin, '0b101010') self.assertEqual(little.seven.bin, '0b0101010') self.assertEqual(little._raw, to_bin('0b0010 1010 1011 0101'))
def test_binary_to_bin(self): print(to_bin('0b0')) print(to_bin('0b1')) print(to_bin('0b1111 1111')) print(to_bin('0b1 0000 0000')) print(to_bin('0b01 0b01 0b01')) self.assertEqual(to_bin('0b0'), b'\x00') self.assertEqual(to_bin('0b1'), b'\x01') self.assertEqual(to_bin('0b1111 1111'), b'\xff') self.assertEqual(to_bin('0b1 0000 0000'), b'\x01\x00') self.assertEqual(to_bin('0b01 0b01 0b01'), b'\x15') self.assertEqual(to_bin('0b11' * 32), b'\xff\xff\xff\xff\xff\xff\xff\xff') self.assertEqual(to_bin('0b11' * 1024), b'\xff\xff\xff\xff\xff\xff\xff\xff' * 32)
def test_encode_union(self): union = self._get_foo_union() encoded = union.encode({'foo': 'medium'}, {}) self.assertEquals(encoded._raw, to_bin('0xf00d 0000'))
def test_little_endian(self): field = Field('uint', 'name', to_bin('0x0100'), little_endian=True) self.assertEqual(field._raw, to_bin('0x0100')) self.assertEqual(field.int, 1) self.assertEqual(field.bytes, to_bin('0x0001')) self.assertEqual(field.hex, '0x0001')
def __init__(self, length, name, default_value=None, terminator=None): _TemplateField.__init__(self, name, default_value) self._terminator = to_bin(terminator) self.length = Length(length)
def test_read_header_and_pdu(self): stream = MockStream(to_bin('0xff0004cafe')) header, data = self._protocol.read(stream) self.assertEquals(header.id.hex, '0xff') self.assertEquals(data, b'\xca\xfe')
def test_decode_struct(self): pair = get_pair() decoded = pair.decode(to_bin('0xcafebabe'), {}) self.assertEquals(decoded.first.hex, '0xcafe') self.assertEquals(decoded.second.hex, '0xbabe')
def test_conditional_decode_has_element(self): cond = self._get_conditional() decoded = cond.decode(to_bin('0x0001 000a 0043')) self.assertEquals(decoded.mycondition.exists, True) self.assertEquals(decoded.mycondition.myvalue.int, 10)
def test_union_length(self): union = self._get_foo_union() decoded = union.decode(to_bin('0xcafebabe')) self.assertEquals(4, len(decoded))
def test_conditional_decode(self): cond = self._get_conditional() decoded = cond.decode(to_bin('0x00004242')) self.assertEquals(decoded.mycondition.exists, False)
def test_empty_values_to_bin(self): self.assertEqual('', to_bin(None)) self.assertEqual('', to_bin(''))
def uint_field(value='0x00'): return Field('uint', 'name', to_bin(value))
def test_hex_larger_than_8_bytes_works(self): self.assertEqual(to_bin('0xcafebabe f00dd00d deadbeef'), '\xca\xfe\xba\xbe\xf0\x0d\xd0\x0d\xde\xad\xbe\xef')
def test_integer_larger_than_8_bytes_works(self): self.assertEqual(to_bin('18446744073709551616'), '\x01\x00\x00\x00\x00\x00\x00\x00\x00')
def test_get_binary_container_bytes(self): self.assertEqual(self.cont._raw, to_bin('0b1011 0101 0010 1010'))
def test_to_tbcd_value(self): self.assertEqual('1', to_tbcd_value(to_bin('0b11110001'))) self.assertEqual('11', to_tbcd_value(to_bin('0b00010001'))) self.assertEqual('2', to_tbcd_value(to_bin('0b11110010'))) self.assertEqual('23', to_tbcd_value(to_bin('0b00110010'))) self.assertEqual('123', to_tbcd_value(to_bin('0b0010000111110011')))