def setUp(self):
self._context_ft = bt2.StructureFieldType()
self._context_ft.append_field('allo', bt2.StringFieldType())
self._context_ft.append_field('zola', bt2.IntegerFieldType(18))
self._payload_ft = bt2.StructureFieldType()
self._payload_ft.append_field('zoom', bt2.StringFieldType())
self._ec = bt2.EventClass('my_event')
self._ec.id = 18
self._ec.context_field_type = self._context_ft
self._ec.payload_field_type = self._payload_ft
def _create_event_classes(self):
context_ft = bt2.StructureFieldType()
context_ft.append_field('allo', bt2.StringFieldType())
context_ft.append_field('zola', bt2.IntegerFieldType(18))
payload_ft = bt2.StructureFieldType()
payload_ft.append_field('zoom', bt2.StringFieldType())
ec1 = bt2.EventClass('event23', id=23, context_field_type=context_ft,
payload_field_type=payload_ft)
ec2 = bt2.EventClass('event17', id=17, context_field_type=payload_ft,
payload_field_type=context_ft)
return ec1, ec2
def setUp(self):
self._packet_context_ft = bt2.StructureFieldType()
self._packet_context_ft.append_field('menu', bt2.FloatingPointNumberFieldType())
self._packet_context_ft.append_field('sticker', bt2.StringFieldType())
self._event_header_ft = bt2.StructureFieldType()
self._event_header_ft.append_field('id', bt2.IntegerFieldType(19))
self._event_context_ft = bt2.StructureFieldType()
self._event_context_ft.append_field('msg', bt2.StringFieldType())
self._ec1, self._ec2 = self._create_event_classes()
self._sc = bt2.StreamClass(name='my_stream_class', id=12,
packet_context_field_type=self._packet_context_ft,
event_header_field_type=self._event_header_ft,
event_context_field_type=self._event_context_ft,
event_classes=(self._ec1, self._ec2))
def _create_stream_class(self, name, id):
ec1, ec2 = self._create_event_classes()
packet_context_ft = bt2.StructureFieldType()
packet_context_ft.append_field('menu',
bt2.FloatingPointNumberFieldType())
packet_context_ft.append_field('sticker', bt2.StringFieldType())
event_header_ft = bt2.StructureFieldType()
event_header_ft.append_field('id', bt2.IntegerFieldType(19))
event_context_ft = bt2.StructureFieldType()
event_context_ft.append_field('msg', bt2.StringFieldType())
return bt2.StreamClass(name=name,
id=id,
packet_context_field_type=packet_context_ft,
event_header_field_type=event_header_ft,
event_context_field_type=event_context_ft,
event_classes=(ec1, ec2))
def test_at_index(self):
a_ft = bt2.IntegerFieldType(32)
b_ft = bt2.StringFieldType()
c_ft = bt2.FloatingPointNumberFieldType()
self._ft.append_field('c', c_ft)
self._ft.append_field('a', a_ft)
self._ft.append_field('b', b_ft)
self.assertEqual(self._ft.at_index(1), a_ft)
def test_iter(self):
a_ft = bt2.IntegerFieldType(32)
b_ft = bt2.StringFieldType()
c_ft = bt2.FloatingPointNumberFieldType()
fields = (
('a', a_ft),
('b', b_ft),
('c', c_ft),
)
for field in fields:
self._ft.append_field(*field)
for (name, ft_field_type), field in zip(self._ft.items(), fields):
self.assertEqual(name, field[0])
self.assertEqual(ft_field_type, field[1])
def test_iadd(self):
struct_ft = bt2.StructureFieldType()
c_field_type = bt2.StringFieldType()
d_field_type = bt2.EnumerationFieldType(size=32)
e_field_type = bt2.StructureFieldType()
struct_ft.append_field('c_string', c_field_type)
struct_ft.append_field('d_enum', d_field_type)
struct_ft.append_field('e_struct', e_field_type)
a_field_type = bt2.FloatingPointNumberFieldType()
b_field_type = bt2.IntegerFieldType(17)
self._ft.append_field('a_float', a_field_type)
self._ft.append_field('b_int', b_field_type)
self._ft += struct_ft
self.assertEqual(self._ft['a_float'], a_field_type)
self.assertEqual(self._ft['b_int'], b_field_type)
self.assertEqual(self._ft['c_string'], c_field_type)
self.assertEqual(self._ft['d_enum'], d_field_type)
self.assertEqual(self._ft['e_struct'], e_field_type)
def _create_ec():
# clock class
cc = bt2.ClockClass('salut_clock')
# event header
eh = bt2.StructureFieldType()
eh += OrderedDict((
('id', bt2.IntegerFieldType(8)),
('ts', bt2.IntegerFieldType(32, mapped_clock_class=cc)),
))
# packet context
pc = bt2.StructureFieldType()
pc += OrderedDict((('something', bt2.IntegerFieldType(8)), ))
# stream class
sc = bt2.StreamClass()
sc.packet_context_field_type = pc
sc.event_header_field_type = eh
sc.event_context_field_type = None
# event payload
ep = bt2.StructureFieldType()
ep += OrderedDict((('mosquito', bt2.StringFieldType()), ))
# event class
event_class = bt2.EventClass('ec', id=0)
event_class.context_field_type = None
event_class.payload_field_type = ep
sc.add_event_class(event_class)
# packet header
ph = bt2.StructureFieldType()
ph += OrderedDict((
('magic', bt2.IntegerFieldType(32)),
('stream_id', bt2.IntegerFieldType(16)),
))
# trace
trace = bt2.Trace()
trace.packet_header_field_type = ph
trace.add_clock_class(cc)
trace.add_stream_class(sc)
return event_class
def test_type(self):
int_ft = bt2.IntegerFieldType(32)
enum_ft = bt2.EnumerationFieldType(int_ft)
enum_ft.append_mapping('corner', 23)
enum_ft.append_mapping('zoom', 17, 20)
enum_ft.append_mapping('mellotron', 1001)
enum_ft.append_mapping('giorgio', 2000, 3000)
array_ft = bt2.ArrayFieldType(int_ft, 5)
seq_ft = bt2.SequenceFieldType(int_ft, 'the_len_field')
float_ft = bt2.FloatingPointNumberFieldType()
struct_ft = bt2.StructureFieldType()
struct_ft.append_field('a', int_ft)
struct_ft.append_field('b', int_ft)
struct_ft.append_field('c', int_ft)
_string_ft = bt2.StringFieldType()
variant_ft = bt2.VariantFieldType('tag', enum_ft)
variant_ft.append_field('corner', int_ft)
variant_ft.append_field('zoom', array_ft)
variant_ft.append_field('mellotron', float_ft)
variant_ft.append_field('giorgio', struct_ft)
expected_types = {
babeltrace.CTFTypeId.INTEGER: int_ft,
babeltrace.CTFTypeId.FLOAT: float_ft,
babeltrace.CTFTypeId.ENUM: enum_ft,
babeltrace.CTFTypeId.STRING: _string_ft,
babeltrace.CTFTypeId.STRUCT: struct_ft,
babeltrace.CTFTypeId.VARIANT: variant_ft,
babeltrace.CTFTypeId.ARRAY: array_ft,
babeltrace.CTFTypeId.SEQUENCE: seq_ft,
}
for type_id, ft in expected_types.items():
declaration = self._get_declaration(ft)
self.assertIsNotNone(declaration)
self.assertEqual(declaration.type, type_id)
def test_ne_packet_header_field_type(self):
cc1, cc2, sc1, sc2, header_ft = self._test_eq_create_objects()
tc1 = bt2.Trace(name='my name',
native_byte_order=bt2.ByteOrder.LITTLE_ENDIAN,
env={
'the_string': 'value',
'the_int': 23
},
packet_header_field_type=header_ft,
clock_classes=(cc1, cc2),
stream_classes=(sc1, sc2))
cc1, cc2, sc1, sc2, header_ft = self._test_eq_create_objects()
header_ft.append_field('yes', bt2.StringFieldType())
tc2 = bt2.Trace(name='my name',
native_byte_order=bt2.ByteOrder.LITTLE_ENDIAN,
env={
'the_string': 'value',
'the_int': 23
},
packet_header_field_type=header_ft,
clock_classes=(cc1, cc2),
stream_classes=(sc1, sc2))
self.assertNotEqual(tc1, tc2)
def setUp(self):
self._ft = bt2.StringFieldType()
def test_contains(self):
self.assertFalse('a' in self._ft)
self._ft.append_field('a', bt2.StringFieldType())
self.assertTrue('a' in self._ft)
def test_len(self):
ft = bt2.StringFieldType()
self._ft.append_field('a', ft)
self._ft.append_field('b', ft)
self._ft.append_field('c', ft)
self.assertEqual(len(self._ft), 3)
def test_bool_op(self):
self.assertFalse(self._ft)
self._ft.append_field('a', bt2.StringFieldType())
self.assertTrue(self._ft)
def test_create_invalid_length_type(self):
with self.assertRaises(TypeError):
self._ft = bt2.SequenceFieldType(bt2.StringFieldType(), 17)
def test_create_invalid_length(self):
with self.assertRaises(ValueError):
self._ft = bt2.ArrayFieldType(bt2.StringFieldType(), -17)
def _create_packet(self, with_ph=True, with_pc=True):
# event header
eh = bt2.StructureFieldType()
eh += OrderedDict((
('id', bt2.IntegerFieldType(8)),
('ts', bt2.IntegerFieldType(32)),
))
# stream event context
sec = bt2.StructureFieldType()
sec += OrderedDict((
('cpu_id', bt2.IntegerFieldType(8)),
('stuff', bt2.FloatingPointNumberFieldType()),
))
# packet context
if with_pc:
pc = bt2.StructureFieldType()
pc += OrderedDict((
('something', bt2.IntegerFieldType(8)),
('something_else', bt2.FloatingPointNumberFieldType()),
))
else:
pc = None
# stream class
sc = bt2.StreamClass()
sc.packet_context_field_type = pc
sc.event_header_field_type = eh
sc.event_context_field_type = sec
# event context
ec = bt2.StructureFieldType()
ec += OrderedDict((
('ant', bt2.IntegerFieldType(16, is_signed=True)),
('msg', bt2.StringFieldType()),
))
# event payload
ep = bt2.StructureFieldType()
ep += OrderedDict((
('giraffe', bt2.IntegerFieldType(32)),
('gnu', bt2.IntegerFieldType(8)),
('mosquito', bt2.IntegerFieldType(8)),
))
# event class
event_class = bt2.EventClass('ec')
event_class.context_field_type = ec
event_class.payload_field_type = ep
sc.add_event_class(event_class)
# packet header
if with_ph:
ph = bt2.StructureFieldType()
ph += OrderedDict((
('magic', bt2.IntegerFieldType(32)),
('stream_id', bt2.IntegerFieldType(16)),
))
else:
ph = None
# trace c;ass
tc = bt2.Trace()
tc.packet_header_field_type = ph
tc.add_stream_class(sc)
# stream
stream = sc()
# packet
return stream.create_packet()
def test_create_invalid_length_type(self):
with self.assertRaises(TypeError):
self._ft = bt2.ArrayFieldType(bt2.StringFieldType(), 'the length')
def test_create_full(self):
ft = bt2.StringFieldType(encoding=bt2.Encoding.UTF8)
self.assertEqual(ft.encoding, bt2.Encoding.UTF8)
def setUp(self):
self._values = {
'ph_field_1': 42,
'ph_field_2': 'bla bla',
'spc_field': 'some string',
'seh_field': 'another string',
'sec_field': 68752,
'ec_field': 89,
'ef_field': 8476,
}
self._int_ft = bt2.IntegerFieldType(32)
self._str_ft = bt2.StringFieldType()
self._trace = bt2.Trace()
self._trace.packet_header_field_type = bt2.StructureFieldType()
self._trace.packet_header_field_type += collections.OrderedDict([
('ph_field_1', self._int_ft),
('ph_field_2', self._str_ft),
])
self._sc = bt2.StreamClass()
self._sc.packet_context_field_type = bt2.StructureFieldType()
self._sc.packet_context_field_type += collections.OrderedDict([
('spc_field', self._str_ft),
])
self._sc.event_header_field_type = bt2.StructureFieldType()
self._sc.event_header_field_type += collections.OrderedDict([
('seh_field', self._str_ft),
])
self._sc.event_context_field_type = bt2.StructureFieldType()
self._sc.event_context_field_type += collections.OrderedDict([
('sec_field', self._int_ft),
])
self._clock_class = bt2.ClockClass('allo', 1000)
self._trace.add_clock_class(self._clock_class)
self._ec = bt2.EventClass('event_class_name')
self._ec.context_field_type = bt2.StructureFieldType()
self._ec.context_field_type += collections.OrderedDict([
('ec_field', self._int_ft),
])
self._ec.payload_field_type = bt2.StructureFieldType()
self._ec.payload_field_type += collections.OrderedDict([
('ef_field', self._int_ft),
])
self._sc.add_event_class(self._ec)
self._trace.add_stream_class(self._sc)
self._cc_prio_map = bt2.ClockClassPriorityMap()
self._cc_prio_map[self._clock_class] = 231
self._stream = self._sc()
self._packet = self._stream.create_packet()
self._packet.header_field['ph_field_1'] = self._values['ph_field_1']
self._packet.header_field['ph_field_2'] = self._values['ph_field_2']
self._packet.context_field['spc_field'] = self._values['spc_field']
self._event = self._ec()
self._event.add_clock_value(self._clock_class(1772))
self._event.header_field['seh_field'] = self._values['seh_field']
self._event.stream_event_context_field['sec_field'] = self._values[
'sec_field']
self._event.context_field['ec_field'] = self._values['ec_field']
self._event.payload_field['ef_field'] = self._values['ef_field']
self._event.packet = self._packet
def test_append_field_invalid_name(self):
with self.assertRaises(TypeError):
self._ft.append_field(23, bt2.StringFieldType())
