def test_create_full(self):
ft = bt2.EnumerationFieldType(size=24, alignment=16,
byte_order=bt2.ByteOrder.BIG_ENDIAN,
is_signed=True, base=bt2.Base.OCTAL,
encoding=bt2.Encoding.NONE,
mapped_clock_class=None)
self.assertEqual(ft.size, 24)
self.assertEqual(ft.alignment, 16)
self.assertEqual(ft.byte_order, bt2.ByteOrder.BIG_ENDIAN)
self.assertTrue(ft.is_signed)
self.assertEqual(ft.base, bt2.Base.OCTAL)
self.assertEqual(ft.encoding, bt2.Encoding.NONE)
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 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_iadd(self):
enum_ft = bt2.EnumerationFieldType(size=16)
enum_ft.append_mapping('c', 4, 5)
enum_ft.append_mapping('d', 6, 18)
enum_ft.append_mapping('e', 20, 27)
self._ft.append_mapping('a', 0, 2)
self._ft.append_mapping('b', 3)
self._ft += enum_ft
self.assertEqual(self._ft[0].name, 'a')
self.assertEqual(self._ft[0].lower, 0)
self.assertEqual(self._ft[0].upper, 2)
self.assertEqual(self._ft[1].name, 'b')
self.assertEqual(self._ft[1].lower, 3)
self.assertEqual(self._ft[1].upper, 3)
self.assertEqual(self._ft[2].name, 'c')
self.assertEqual(self._ft[2].lower, 4)
self.assertEqual(self._ft[2].upper, 5)
self.assertEqual(self._ft[3].name, 'd')
self.assertEqual(self._ft[3].lower, 6)
self.assertEqual(self._ft[3].upper, 18)
self.assertEqual(self._ft[4].name, 'e')
self.assertEqual(self._ft[4].lower, 20)
self.assertEqual(self._ft[4].upper, 27)
def test_find_by_value_unsigned(self):
self._test_find_by_value(bt2.EnumerationFieldType(size=8))
def test_find_by_value_signed(self):
self._test_find_by_value(bt2.EnumerationFieldType(size=8, is_signed=True))
def test_mapping_eq_invalid(self):
enum1 = bt2.EnumerationFieldType(size=32)
enum1.append_mapping('b', 1, 3)
self.assertNotEqual(enum1[0], 23)
def test_mapping_eq(self):
enum1 = bt2.EnumerationFieldType(size=32)
enum2 = bt2.EnumerationFieldType(size=16)
enum1.append_mapping('b', 1, 3)
enum2.append_mapping('b', 1, 3)
self.assertEqual(enum1[0], enum2[0])
def test_integer_field_type_prop(self):
int_ft = bt2.IntegerFieldType(23)
enum_ft = bt2.EnumerationFieldType(int_ft)
self.assertEqual(enum_ft.integer_field_type.addr, int_ft.addr)
def test_create_from_invalid_ft(self):
with self.assertRaises(TypeError):
ft = bt2.FloatingPointNumberFieldType()
self._ft = bt2.EnumerationFieldType(ft)
def test_create_from_invalid_type(self):
with self.assertRaises(TypeError):
self._ft = bt2.EnumerationFieldType('coucou')
def test_create_from_int_ft(self):
int_ft = bt2.IntegerFieldType(23)
self._ft = bt2.EnumerationFieldType(int_ft)
def setUp(self):
self._ft = bt2.EnumerationFieldType(size=35)
