def test_choice_encode(self):
a = fld.Field('a', 8, constraints=[Equals(dt.Data('a'))])
b = fld.Field('b', 8, constraints=[Equals(dt.Data('b'))])
choice = chc.Choice('blah', [a, b])
text = "<b />"
data = xml.encode(choice, text)
self.assertEqual("b", data.bytes())
def test_sequenceof_choice(self):
a = sof.SequenceOf('a', chc.Choice('b', [
fld.Field('b1', length=8, constraints=[Equals(3)]),
fld.Field('b2', length=8, constraints=[Equals(5)]),
fld.Field('b3', length=8, constraints=[Equals(7)]),
]), count=3)
self.assertEqual('\x03\x05\x07', xml.encode(a, '<a><b1/><b2/><b3/></a>').bytes())
def test_verbose(self):
sequence = seq.Sequence("bob", [
fld.Field("cat:", 8, fld.Field.INTEGER),
fld.Field("dog", 24, fld.Field.TEXT)])
text = xml.to_string(sequence, dt.Data.from_hex('6d7a6970'), verbose=True)
expected = """<bob>
<cat_>109<!-- hex (1 bytes): 6d --></cat_>
<dog>zip<!-- hex (3 bytes): 7a6970 --></dog>
</bob>
"""
self.assertEqual(expected, text)
# Now test that we can re-encode verbose generated xml...
data = xml.encode(sequence, text)
self.assertEqual("mzip", data.bytes())
def test_re_encoding_of_whitespace(self):
spec = fld.Field('blah', 64, fld.Field.TEXT)
text = xml.to_string(spec, dt.Data(' bob '))
data = xml.encode(spec, text)
self.assertEqual(" bob ", data.bytes())
def test_encode_sequenceof(self):
spec = sof.SequenceOf('cat', fld.Field('dog', 8, fld.Field.TEXT), 4)
text = "<cat> <dog>a</dog> <dog>b</dog> <dog>c</dog> <dog>d</dog> </cat>"
data = xml.encode(spec, text)
self.assertEqual("abcd", data.bytes())
def test_xml_encode(self):
text = "<blah><cat>5</cat><dog>18</dog></blah>"
sequence = seq.Sequence("blah", [
fld.Field("cat", 8, fld.Field.INTEGER),
fld.Field("dog", 8, fld.Field.INTEGER)])
self.assertEqual("\x05\x12", xml.encode(sequence, text).bytes())
def test_sequence_with_children_and_value(self):
a = seq.Sequence('a',
[fld.Field('b', length=8, format=fld.Field.INTEGER)],
value=parse('${b}'))
self.assertEqual('\x05', xml.encode(a, '<a><b>5</b>5</a>').bytes())
def test_text_field_with_expected_value(self):
a = fld.Field('a', length=32, format=fld.Field.TEXT, constraints=[Equals('abcd')])
self.assertEqual('abcd', xml.encode(a, '<a/>').bytes())
def test_integer_field_with_expected_value(self):
a = fld.Field('a', length=16, format=fld.Field.INTEGER,
encoding=fld.Field.LITTLE_ENDIAN, constraints=[Equals(7)])
self.assertEqual('\x07\x00', xml.encode(a, '<a/>').bytes())
def test_sequence_with_expected_value(self):
text = '<a><c/></a>'
a = seq.Sequence('a', [
fld.Field('b:', 8),
seq.Sequence('c', [], value=parse('${b:}'), constraints=[Equals(5)])])
self.assertEqual('\x05', xml.encode(a, text).bytes())
options, args = parser.parse_args()
if not args:
sys.exit("No specifications listed! See '%s -h' for more info." % sys.argv[0])
try:
protocol, common, lookup = load_specs(
[(spec, None, None) for spec in args], options.main, options.remove_unused
)
except bdec.spec.LoadError, ex:
sys.exit(str(ex))
if options.filename:
xml = file(options.filename, "rb").read()
else:
xml = sys.stdin.read()
try:
binary = xmlout.encode(protocol, xml).bytes()
except bdec.DecodeError, ex:
try:
(filename, line_number, column_number) = lookup[ex.entry]
except KeyError:
(filename, line_number, column_number) = ("unknown", 0, 0)
sys.exit("%s[%i]: %s" % (filename, line_number, str(ex)))
sys.stdout.write(binary)
if __name__ == "__main__":
main()
