def test_hidden_entries(self):
sequence = seq.Sequence("bob", [
fld.Field("cat:", 8, fld.Field.INTEGER),
fld.Field("dog", 24, fld.Field.TEXT)])
data = inst.decode(sequence, dt.Data.from_hex('6e7a6970'))
self.assertTrue('cat' not in "".join(dir(data)))
self.assertEqual("zip", data.dog)
def test_sequence(self):
sequence = seq.Sequence("bob", [
fld.Field("cat", 8, fld.Field.INTEGER),
fld.Field("dog", 24, fld.Field.TEXT)])
data = inst.decode(sequence, dt.Data.from_hex('6e7a6970'))
self.assertEqual(110, data.cat)
self.assertEqual("zip", data.dog)
def decode(self, input_file):
# Encode aivdm data back into binary
fragments = []
payload = self._aivdm[1][0]
data = Data(input_file)
while data:
try:
calculated_crc = self._get_crc(data)
packet = decode(self._aivdm[0], data)
if packet.checksum != calculated_crc:
sys.stderr.write('Crc mismatch; expected %02X, but '
'calculated %02X. Skipping packet.\n' %
(packet.checksum, calculated_crc))
continue
bits = encode(payload, list(ord(c.character) for c in packet.payload))
bits = bits.pop(len(bits) - packet.num_fill_bits)
if len(fragments) == packet.fragment_number - 1:
fragments.append(bits)
if len(fragments) == packet.fragment_count:
self._decode_ais(reduce(operator.add, fragments))
fragments = []
else:
sys.stderr.write('Expected fragment number %i, got %i (of %i)\n' % (
len(fragments) + 1, packet.fragment_number, packet.fragment_count))
fragments = []
except DecodeError, ex:
filename, line_number, column_number = self._aivdm[2][ex.entry]
sys.stderr.write('%s[%i] - %s\n' % (filename, line_number, ex))
fragments = []
# Read to the next newline
while data and data.pop(8).text('ascii') != '\n':
pass
def test_sequenceof(self):
sequenceof = sof.SequenceOf("bob",
fld.Field("cat", 8, fld.Field.INTEGER),
4)
data = inst.decode(sequenceof, dt.Data.from_hex('6e7a6970'))
self.assertTrue(isinstance(data, list))
self.assertEqual(4, len(data))
self.assertEqual(0x6e, int(data[0]))
self.assertEqual(0x7a, int(data[1]))
self.assertEqual(0x69, int(data[2]))
self.assertEqual(0x70, int(data[3]))
def _encode(self, protocol, value):
"""
Wrapper around inst.encode.
Also validates that we can decode the encoded data, and get the
same data back again.
"""
data = inst.encode(protocol, value)
# Now validate that we can decode that data...
re_decoded = inst.decode(protocol, data.copy())
self.assertEqual(data, inst.encode(protocol, re_decoded))
return data.bytes()
def test_delayed_referenced_common_elements_are_independant(self):
# Here we test that so called 'delayed referenced' objects are
# independant (ie: that an embedded referenced object doesn't
# affect an outer object).
text = """
<protocol>
<common>
<field name="integer" length="8" min="48" max="57" type="text" />
<sequence name="array">
<field name="opener" length="8" value="0x5b" />
<sequenceof name="values">
<choice name="entry">
<field name="closer" length="8" value="0x5d"><end-sequenceof /></field>
<reference name="object" />
</choice>
</sequenceof>
</sequence>
<choice name="object">
<reference name="integer" />
<reference name="array" />
</choice>
</common>
<reference name="object" />
</protocol>
"""
protocol = loads(text)[0]
data = dt.Data("[12[34[56]7]8]unused")
result = inst.decode(protocol, data)
self.assertEqual("1", result.array.values[0].object.integer)
self.assertEqual("2", result.array.values[1].object.integer)
self.assertEqual("3", result.array.values[2].object.array.values[0].object.integer)
self.assertEqual("4", result.array.values[2].object.array.values[1].object.integer)
self.assertEqual("5", result.array.values[2].object.array.values[2].object.array.values[0].object.integer)
self.assertEqual("6", result.array.values[2].object.array.values[2].object.array.values[1].object.integer)
self.assertEqual("7", result.array.values[2].object.array.values[3].object.integer)
self.assertEqual("8", result.array.values[3].object.integer)
self.assertEqual("unused", data.bytes())
def test_field(self):
field = fld.Field("bob", 8, fld.Field.INTEGER)
data = inst.decode(field, dt.Data.from_hex('6e'))
self.assertEqual(110, data)
def test_sequence_with_hidden_field_to_string(self):
a = seq.Sequence('a', [fld.Field('length:', 8), fld.Field('b', format=fld.Field.TEXT, length=parse('${length:} * 8'))])
data = inst.decode(a, dt.Data('\x03cat'))
self.assertEqual(u"{'b': u'cat'}", unicode(data))
def test_sequence_to_string(self):
a = seq.Sequence('a', [fld.Field('b', 8, format=fld.Field.INTEGER)])
data = inst.decode(a, dt.Data('\x09'))
self.assertEqual("{'b': 9}", str(data))
def test_exception_when_seequence_is_not_an_int(self):
a = seq.Sequence('a', [])
data = inst.decode(a, dt.Data())
self.assertRaises(TypeError, int, data)
def test_sequence_with_children_and_value(self):
a = seq.Sequence('a', [fld.Field('b', length=8, format=fld.Field.INTEGER)], value=parse('7'))
data = inst.decode(a, dt.Data('\x33'))
self.assertEqual(0x33, data.b)
self.assertEqual(7, int(data))
def test_sequence_value(self):
a = seq.Sequence('a', [seq.Sequence('hidden:', [])], value=parse('5'))
data = inst.decode(a, dt.Data())
self.assertEqual(5, data)
def test_reference_name(self):
a = fld.Field('a', 8)
b = seq.Sequence('b', [Child('c', a)])
data = inst.decode(b, dt.Data('\x33'))
self.assertEqual(0x33, int(data.c))
from bdec.data import Data
from bdec import DecodeError
from bdec.spec.xmlspec import load
from bdec.spec import load_specs
from bdec.output.instance import decode
from bdec.spec.references import References
references = References()
def get_pb_line(fpath):
with open(fpath) as f:
for line in f:
yield line
count = 0
with open('playback.xml', 'r') as xml_f:
spec = load_specs(["playback.xml"])[0]
for line in get_pb_line(sys.argv[1]):
try:
values = decode(spec, Data(line))
except DecodeError, err:
print 'Oh oh...', err
raise
count += 0
print(values)
#import pdb
#pdb.set_trace()
#print(2)
print("done", count)
def test_children_of_hidden_entries_are_not_visible(self):
sequence = seq.Sequence("bob:", [fld.Field("cat", 8, fld.Field.INTEGER), fld.Field("dog", 8, fld.Field.INTEGER)])
data = inst.decode(sequence, dt.Data("\x38\x7a"))
assert data is None
from bdec.data import Data
from bdec import DecodeError
from bdec.spec.xmlspec import load
from bdec.spec import load_specs
from bdec.output.instance import decode
from bdec.spec.references import References
references = References()
import sys
with open(sys.argv[1], 'r') as pb:
data = pb.read()
spec = load_specs(["playback_faster.xml"])[0]
try:
values = decode(spec, Data(data))
except DecodeError, err:
print 'Oh oh...', err
raise
for value in values:
print(value)
break
print("done")
def test_sequenceof_to_string(self):
a = sof.SequenceOf('a', fld.Field('b', 8, format=fld.Field.INTEGER), count=parse('3'))
data = inst.decode(a, dt.Data('\x09\x01\x0a'))
self.assertEqual("[9, 1, 10]", str(data))
