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_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_fail_on_dynamic_length(self):
union = UnionTemplate('NotLegal', 'dymagic', parent=None)
union.add(UInt(2, 'bar', None))
struct = StructTemplate('Foo', 'foo', parent=None)
struct.add(UInt(1, 'len', 22))
struct.add(Char('len', 'dymagic', 'foo'))
self.assertRaises(Exception, union.add, struct)
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_uint_static_field(self):
field = UInt(5, "field", 8)
self.assertTrue(field.length.static)
self.assertEquals(field.name, "field")
self.assertEquals(field.default_value, '8')
self.assertEquals(field.type, 'uint')
self.assertEquals(field.encode({}, {}, None).hex, '0x0000000008')
def test_uint_static_field(self):
field = UInt(5, "field", 8)
self.assertTrue(field.length.static)
self.assertEquals(field.name, "field")
self.assertEquals(field.default_value, '8')
self.assertEquals(field.type, 'uint')
self.assertEquals(field.encode({}, {}, None).hex, '0x0000000008')
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_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 setUp(self):
self._protocol = Protocol('TestProtocol')
self._protocol.add(UInt(2, 'msgId', 5))
self._protocol.add(UInt(2, 'length', None))
self._protocol.add(PDU('length-4'))
self.tmp = MessageTemplate('FooRequest', self._protocol, {})
self.tmp.add(UInt(2, 'field_1', 1))
self.tmp.add(UInt(2, 'field_2', 2))
def setUp(self):
self._protocol = Protocol('TestProtocol', little_endian=True)
self._protocol.add(UInt(2, 'msgId', 5))
self._protocol.add(UInt(2, 'length', None))
self._protocol.add(PDU('length-4'))
self.tmp = MessageTemplate('FooRequest', self._protocol, {})
self.tmp.add(UInt(2, 'field_1', '0xcafe'))
self.tmp.add(UInt(2, 'field_2', '0xbabe'))
def test_encode_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', 1))
tmp.add(lst)
encoded = tmp.encode({'len': 6}, {})
self.assertEqual(len(encoded.foo), 6)
def _get_conditional(self):
struct = StructTemplate('Foo', 'foo', parent=None)
struct.add(UInt(2, 'condition', 1))
condition = ConditionalTemplate('condition==1', 'mycondition', None)
condition.add(UInt(2, 'myvalue', 42))
struct.add(condition)
struct.add(UInt(2, 'second', 2))
return struct
def setUp(self):
self._protocol = Protocol('TestProtocol')
self._protocol.add(UInt(2, 'msgId', 5))
self._protocol.add(UInt(2, 'length', None))
self._protocol.add(PDU('length-4'))
self.tmp = MessageTemplate('FooRequest', self._protocol, {})
self.tmp.add(UInt(2, 'field_1', '0xcafe'))
self.tmp.add(UInt(2, 'field_2', '0xbabe'))
self.example = self.tmp.encode({}, {})
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.assertEqual(decoded.len.int, 4)
self.assertEqual(decoded.foo[0].hex, '0x61')
def test_access_struct(self):
self._protocol = Protocol('TestProtocol')
self._protocol.add(UInt(2, 'msgId', 5))
self._protocol.add(UInt(2, 'length', None))
self._protocol.add(PDU('length-4'))
self.tmp = MessageTemplate('StructuredRequest', self._protocol, {})
struct = get_pair()
self.tmp.add(struct)
msg = self.tmp.encode({}, {})
self.assertEquals(msg.pair.first.int, 1)
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.assertEqual(decoded.len.int, 4)
self.assertEqual(decoded.chars.ascii, 'abcd')
self.assertEqual(decoded.chars2.ascii, 'ef')
def test_encode_dynamic_primitive_with_defined_value(self):
tmp = MessageTemplate('Dymagic', self._protocol, {})
tmp.add(UInt(4, 'len', '4'))
tmp.add(Char('len', 'chars', 'abcd'))
tmp.add(UInt(4, 'len2', None))
tmp.add(Char('len2', 'chars2', 'ef'))
encoded = tmp.encode({'len2': '6'}, {})
self.assertEqual(encoded.chars.ascii, 'abcd')
self.assertEqual(len(encoded.chars), 4)
self.assertEqual(encoded.chars2.ascii, 'ef')
self.assertEqual(len(encoded.chars2), 6)
def test_union_primitive_length(self):
self._check_length(2, UInt(1, 'a', 1), UInt(2, 'b', 1))
self._check_length(1, UInt(1, 'a', 1), UInt(1, 'b', 1))
self._check_length(4, UInt(4, 'a', 4), UInt(1, 'b', 1),
UInt(2, 'c', 1))
self._check_length(16, UInt(1, 'a', 1), Char(16, 'b', 1))
self._check_length(10, Char(10, 'a', None), Char(10, 'b', None))
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.assertEqual(len(decoded[4]), 4)
self.assertEqual(len(decoded), 20)
self.assertEqual(decoded[0].int, 3)
def test_encode_dynamic_primitive_automatically(self):
tmp = MessageTemplate('Dymagic', self._protocol, {})
tmp.add(UInt(4, 'len', None))
tmp.add(Char('len', 'chars', 'abcd'))
encoded = tmp.encode({}, {})
self.assertEqual(encoded.chars.ascii, 'abcd')
self.assertEqual(encoded.len.int, 4)
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 test_dynamic_field_validation(self):
struct = StructTemplate('Foo', 'foo', parent=None)
struct.add(UInt(2, 'len', None))
struct.add(Char('len', 'text', None))
encoded = struct.encode({'foo.len': 6, 'foo.text': 'fobba'})
self._should_pass(
struct.validate({'foo': encoded}, {'foo.text': 'fobba'}))
self._should_fail(
struct.validate({'foo': encoded}, {'foo.text': 'fob'}), 1)
def test_verify_calculated_length(self):
self._protocol.add(UInt(1, 'name1', 1))
self._protocol.add(UInt(2, 'length', None))
self._protocol.add(PDU('length-8'))
self.assertEqual(self._protocol.header_length(), 3)
def test_encoding_illegal_value_fails(self):
field = UInt(2, 'foo', '(1|2)')
self.assertRaises(Exception, field.encode, {}, {})
field = UInt(2, 'foo', 'poplpdsf')
self.assertRaises(Exception, field.encode, {}, {})
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 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 test_decode_uint(self):
field_template = UInt(2, 'field', 6)
decoded = field_template.decode(to_bin('0xcafe'), {})
self.assertEquals(decoded.hex, '0xcafe')
def test_verify_only_tbcd_number_passes(self):
container = TBCDContainerTemplate('tbcd', None)
container.add(TBCD('4', 'first', None))
self.assertRaises(AssertionError, container.add, UInt(2, 'not allowed', None))
def test_decode_returns_used_length(self):
field_template = UInt(2, 'field', 6)
data = to_bin('0xcafebabeff00ff00')
decoded = field_template.decode(data, {})
self.assertEquals(decoded.hex, '0xcafe')
self.assertEquals(len(decoded), 2)
def test_decode_uint(self):
field_template = UInt(2, 'field', 6)
decoded = field_template.decode(to_bin('0xcafe'), {})
self.assertEquals(decoded.hex, '0xcafe')
def test_verify_undefined_length(self):
self._protocol.add(UInt(1, 'name1', None))
self._protocol.add(UInt(2, 'name2', 5))
self.assertRaises(Exception, self._protocol.add, PDU('length'))
def test_header_length_with_pdu(self):
self._protocol.add(UInt(1, 'name1', None))
self._protocol.add(UInt(2, 'name2', 5))
self._protocol.add(UInt(2, 'length', None))
self._protocol.add(PDU('length'))
self.assertEqual(self._protocol.header_length(), 5)
def test_decode_returns_used_length(self):
field_template = UInt(2, 'field', 6)
data = to_bin('0xcafebabeff00ff00')
decoded = field_template.decode(data, {})
self.assertEquals(decoded.hex, '0xcafe')
self.assertEquals(len(decoded), 2)
def test_container_union_length(self):
self._check_length(4, get_pair(), UInt(2, 'b', 1))
self._check_length(4, UInt(1, 'a', 1), get_recursive_struct())
self._check_length(6, get_pair(), get_list_of_three())
def test_header_length(self):
self._protocol.add(UInt(1, 'name1', None))
self.assertEqual(self._protocol.header_length(), 1)
def _get_foo_union(self):
union = UnionTemplate('Foo', 'foo', parent=None)
union.add(UInt(1, 'small', '0xff'))
union.add(UInt(2, 'medium', '0xf00d'))
union.add(UInt(4, 'large', None))
return union
def test_encoding_missing_value_fails(self):
field = UInt(2, 'foo', None)
self.assertRaises(Exception, field.encode, {}, {})
field = UInt(2, 'foo', '')
self.assertRaises(Exception, field.encode, {}, {})
