import numbers
import math
import copy
+import itertools
import bt2
comp_value = rhs
if isinstance(rhs, (bt2.fields._IntegerField, bt2.fields._FloatingPointNumberField)):
- comp_value = rhs.value
+ comp_value = copy.copy(rhs)
try:
r = op(self._def, rhs)
self.assertEqual(self._def.addr, addr_before)
def _test_unaryop_value_same(self, op):
- value_before = self._def.value
+ value_before = copy.copy(self._def_value)
self._unaryop(op)
- self.assertEqual(self._def.value, value_before)
+ self.assertEqual(self._def, value_before)
def _test_binop_type(self, op, rhs):
r, rv = self._binop(op, rhs)
self.assertEqual(self._def.addr, addr_before)
def _test_binop_lhs_value_same(self, op, rhs):
- value_before = self._def.value
+ value_before = copy.copy(self._def)
r, rv = self._binop(op, rhs)
- self.assertEqual(self._def.value, value_before)
+ self.assertEqual(self._def, value_before)
def _test_binop_invalid_unknown(self, op):
if op in _COMP_BINOPS:
def test_ne_none(self):
self.assertTrue(self._def != None)
+ def test_is_set(self):
+ raw = self._def_value
+ field = self._ft()
+ self.assertFalse(field.is_set)
+ field.value = raw
+ self.assertTrue(field.is_set)
+
+ def test_reset(self):
+ raw = self._def_value
+ field = self._ft()
+ field.value = raw
+ self.assertTrue(field.is_set)
+ field.reset()
+ self.assertFalse(field.is_set)
+ other = self._ft()
+ self.assertEqual(other, field)
+
_BINOPS = (
('lt', operator.lt),
# inject testing methods for each binary operation
for name, binop in _BINOPS:
-
setattr(cls, test_binop_name('invalid_unknown'), partialmethod(_TestNumericField._test_binop_invalid_unknown, op=binop))
setattr(cls, test_binop_name('invalid_none'), partialmethod(_TestNumericField._test_binop_invalid_none, op=binop))
setattr(cls, test_binop_name('type_true'), partialmethod(_TestNumericField._test_binop_type_true, op=binop))
raw = True
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_false(self):
raw = False
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_pos_int(self):
raw = 477
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_neg_int(self):
raw = -13
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_int_field(self):
raw = 999
field.value = raw
self._def.value = field
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_float(self):
raw = 123.456
self._def.value = raw
self.assertEqual(self._def, int(raw))
- self.assertEqual(self._def.value, int(raw))
def test_assign_invalid_type(self):
with self.assertRaises(TypeError):
raw = 1777
field.value = 1777
self.assertEqual(field, raw)
- self.assertEqual(field.value, raw)
def test_assign_uint_invalid_neg(self):
ft = bt2.IntegerFieldType(size=32, is_signed=False)
with self.assertRaises(ValueError):
field.value = -23
+ def test_str_op(self):
+ self.assertEqual(str(self._def), str(self._def_value))
+
+ def test_str_op_unset(self):
+ self.assertEqual(str(self._ft()), 'Unset')
+
_inject_numeric_testing_methods(_TestIntegerFieldCommon)
self._def_value = 17
self._def_new_value = -101
+ def tearDown(self):
+ del self._ft
+ del self._field
+ del self._def
+
class EnumerationFieldTestCase(_TestIntegerFieldCommon, unittest.TestCase):
def setUp(self):
self._ft = bt2.EnumerationFieldType(size=32, is_signed=True)
self._ft.append_mapping('whole range', -(2 ** 31), (2 ** 31) - 1)
+ self._ft.append_mapping('something', 17)
+ self._ft.append_mapping('speaker', 12, 16)
+ self._ft.append_mapping('can', 18, 2540)
+ self._ft.append_mapping('zip', -45, 1001)
self._def = self._ft()
self._def.value = 17
self._def_value = 17
self._def_new_value = -101
+ def tearDown(self):
+ del self._ft
+ del self._def
+
+ def test_mappings(self):
+ mappings = (
+ ('whole range', -(2 ** 31), (2 ** 31) - 1),
+ ('something', 17, 17),
+ ('zip', -45, 1001),
+ )
+
+ total = 0
+ index_set = set()
+
+ for fm in self._def.mappings:
+ total += 1
+ for index, mapping in enumerate(mappings):
+ if fm.name == mapping[0] and fm.lower == mapping[1] and fm.upper == mapping[2]:
+ index_set.add(index)
+
+ self.assertEqual(total, 3)
+ self.assertTrue(0 in index_set and 1 in index_set and 2 in index_set)
+
+ def test_str_op(self):
+ expected_string_found = False
+ s = str(self._def)
+
+ # Establish all permutations of the three expected matches since
+ # the order in which mappings are enumerated is not explicitly part of
+ # the API.
+ for p in itertools.permutations(["'whole range'", "'something'",
+ "'zip'"]):
+ candidate = '{} ({})'.format(self._def_value, ', '.join(p))
+ if candidate == s:
+ expected_string_found = True
+ break
+
+ self.assertTrue(expected_string_found)
+
+ def test_str_op_unset(self):
+ self.assertEqual(str(self._ft()), 'Unset')
+
class FloatingPointNumberFieldTestCase(_TestNumericField, unittest.TestCase):
def setUp(self):
self._def_value = 52.7
self._def_new_value = -17.164857
+ def tearDown(self):
+ del self._ft
+ del self._field
+ del self._def
+
def _test_invalid_op(self, cb):
with self.assertRaises(TypeError):
cb()
def test_assign_true(self):
self._def.value = True
self.assertTrue(self._def)
- self.assertTrue(self._def.value)
def test_assign_false(self):
self._def.value = False
self.assertFalse(self._def)
- self.assertFalse(self._def.value)
def test_assign_pos_int(self):
raw = 477
self._def.value = raw
self.assertEqual(self._def, float(raw))
- self.assertEqual(self._def.value, float(raw))
def test_assign_neg_int(self):
raw = -13
self._def.value = raw
self.assertEqual(self._def, float(raw))
- self.assertEqual(self._def.value, float(raw))
def test_assign_int_field(self):
ft = bt2.IntegerFieldType(32)
field.value = raw
self._def.value = field
self.assertEqual(self._def, float(raw))
- self.assertEqual(self._def.value, float(raw))
def test_assign_float(self):
raw = -19.23
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_float_field(self):
ft = bt2.FloatingPointNumberFieldType(32)
field.value = raw
self._def.value = field
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_invalid_type(self):
with self.assertRaises(TypeError):
def test_invalid_invert(self):
self._test_invalid_op(lambda: ~self._def)
+ def test_str_op(self):
+ self.assertEqual(str(self._def), str(self._def_value))
+
+ def test_str_op_unset(self):
+ self.assertEqual(str(self._ft()), 'Unset')
_inject_numeric_testing_methods(FloatingPointNumberFieldTestCase)
self._def.value = self._def_value
self._def_new_value = 'Yes!'
+ def tearDown(self):
+ del self._ft
+ del self._def
+
def test_assign_int(self):
with self.assertRaises(TypeError):
self._def.value = 283
- def test_assign_str(self):
- raw = 'zorg'
- self._def = raw
- self.assertEqual(self._def, raw)
-
def test_assign_string_field(self):
ft = bt2.StringFieldType()
field = ft()
def test_str_op(self):
self.assertEqual(str(self._def), str(self._def_value))
+ def test_str_op_unset(self):
+ self.assertEqual(str(self._ft()), 'Unset')
+
def test_len(self):
self.assertEqual(len(self._def), len(self._def_value))
self._def_value += to_append
self.assertEqual(self._def, self._def_value)
+ def test_is_set(self):
+ raw = self._def_value
+ field = self._ft()
+ self.assertFalse(field.is_set)
+ field.value = raw
+ self.assertTrue(field.is_set)
+
+ def test_reset(self):
+ raw = self._def_value
+ field = self._ft()
+ field.value = raw
+ self.assertTrue(field.is_set)
+ field.reset()
+ self.assertFalse(field.is_set)
+ other = self._ft()
+ self.assertEqual(other, field)
+
class _TestArraySequenceFieldCommon(_TestCopySimple):
def _modify_def(self):
for field, value in zip(self._def, (45, 1847, 1948754)):
self.assertEqual(field, value)
+ def test_value_int_field(self):
+ values = [45646, 145, 12145]
+ self._def.value = values
+ self.assertEqual(values, self._def)
+
+ def test_value_unset(self):
+ values = [45646, None, 12145]
+ self._def.value = values
+ self.assertFalse(self._def[1].is_set)
+
+ def test_value_rollback(self):
+ values = [45, 1847, 1948754]
+ # value is out of range, should not affect those we set previously
+ with self.assertRaises(bt2.Error):
+ self._def[2].value = 2**60
+ self.assertEqual(values, self._def)
+
+ def test_value_check_sequence(self):
+ values = 42
+ with self.assertRaises(TypeError):
+ self._def.value = values
+
+ def test_value_wrong_type_in_sequence(self):
+ values = [32, 'hello', 11]
+ with self.assertRaises(TypeError):
+ self._def.value = values
+
+ def test_value_complex_type(self):
+ struct_ft = bt2.StructureFieldType()
+ int_ft = bt2.IntegerFieldType(32)
+ str_ft = bt2.StringFieldType()
+ struct_ft.append_field(field_type=int_ft, name='an_int')
+ struct_ft.append_field(field_type=str_ft, name='a_string')
+ struct_ft.append_field(field_type=int_ft, name='another_int')
+ array_ft = bt2.ArrayFieldType(struct_ft, 3)
+ values = [
+ {
+ 'an_int': 42,
+ 'a_string': 'hello',
+ 'another_int': 66
+ },
+ {
+ 'an_int': 1,
+ 'a_string': 'goodbye',
+ 'another_int': 488
+ },
+ {
+ 'an_int': 156,
+ 'a_string': 'or not',
+ 'another_int': 4648
+ },
+ ]
+
+ array = array_ft()
+ array.value = values
+ self.assertEqual(values, array)
+ values[0]['an_int'] = 'a string'
+ with self.assertRaises(TypeError):
+ array.value = values
+
+ def test_is_set(self):
+ raw = self._def_value
+ field = self._ft()
+ self.assertFalse(field.is_set)
+ field.value = raw
+ self.assertTrue(field.is_set)
+
+ def test_reset(self):
+ raw = self._def_value
+ field = self._ft()
+ field.value = raw
+ self.assertTrue(field.is_set)
+ field.reset()
+ self.assertFalse(field.is_set)
+ other = self._ft()
+ self.assertEqual(other, field)
+
+ def test_str_op(self):
+ s = str(self._def)
+ expected_string = '[{}]'.format(', '.join(
+ [repr(v) for v in self._def_value]))
+ self.assertEqual(expected_string, s)
+
+ def test_str_op_unset(self):
+ self.assertEqual(str(self._ft()), 'Unset')
+
class ArrayFieldTestCase(_TestArraySequenceFieldCommon, unittest.TestCase):
def setUp(self):
self._def[0] = 45
self._def[1] = 1847
self._def[2] = 1948754
+ self._def_value = [45, 1847, 1948754]
+
+ def tearDown(self):
+ del self._elem_ft
+ del self._ft
+ del self._def
+
+ def test_value_wrong_len(self):
+ values = [45, 1847]
+ with self.assertRaises(ValueError):
+ self._def.value = values
class SequenceFieldTestCase(_TestArraySequenceFieldCommon, unittest.TestCase):
self._def[0] = 45
self._def[1] = 1847
self._def[2] = 1948754
+ self._def_value = [45, 1847, 1948754]
+
+ def tearDown(self):
+ del self._elem_ft
+ del self._ft
+ del self._def
+ del self._length_field
+
+ def test_value_resize(self):
+ new_values = [1, 2, 3, 4]
+ self._def.value = new_values
+ self.assertCountEqual(self._def, new_values)
+
+ def test_value_resize_rollback(self):
+ with self.assertRaises(TypeError):
+ self._def.value = [1, 2, 3, 'unexpected string']
+ self.assertEqual(self._def, self._def_value)
+
+ self._def.reset()
+ with self.assertRaises(TypeError):
+ self._def.value = [1, 2, 3, 'unexpected string']
+ self.assertFalse(self._def.is_set)
class StructureFieldTestCase(_TestCopySimple, unittest.TestCase):
self._def['B'] = 'salut'
self._def['C'] = 17.5
self._def['D'] = 16497
+ self._def_value = {
+ 'A': -1872,
+ 'B': 'salut',
+ 'C': 17.5,
+ 'D': 16497
+ }
+
+ def tearDown(self):
+ del self._ft0
+ del self._ft1
+ del self._ft2
+ del self._ft3
+ del self._ft
+ del self._def
def _modify_def(self):
self._def['B'] = 'hola'
self.assertIs(type(field), bt2.fields._IntegerField)
self.assertEqual(field, -1872)
+ def test_at_index_out_of_bounds_after(self):
+ with self.assertRaises(IndexError):
+ self._def.at_index(len(self._ft))
+
def test_eq(self):
ft = bt2.StructureFieldType()
ft.append_field('A', self._ft0)
struct_ft.append_field('A', elem_ft)
struct_field = struct_ft()
- with self.assertRaises(TypeError):
+ # Will fail on access to .items() of the value
+ with self.assertRaises(AttributeError):
struct_field['A'] = 23
def test_setitem_none(self):
for vkey, vval in self._def.items():
val = orig_values[vkey]
self.assertEqual(vval, val)
+
+ def test_value(self):
+ orig_values = {
+ 'A': -1872,
+ 'B': 'salut',
+ 'C': 17.5,
+ 'D': 16497,
+ }
+ self.assertEqual(self._def, orig_values)
+
+ def test_set_value(self):
+ int_ft = bt2.IntegerFieldType(32)
+ str_ft = bt2.StringFieldType()
+ struct_ft = bt2.StructureFieldType()
+ struct_ft.append_field(field_type=int_ft, name='an_int')
+ struct_ft.append_field(field_type=str_ft, name='a_string')
+ struct_ft.append_field(field_type=int_ft, name='another_int')
+ values = {
+ 'an_int': 42,
+ 'a_string': 'hello',
+ 'another_int': 66
+ }
+
+ struct = struct_ft()
+ struct.value = values
+ self.assertEqual(values, struct)
+
+ bad_type_values = copy.deepcopy(values)
+ bad_type_values['an_int'] = 'a string'
+ with self.assertRaises(TypeError):
+ struct.value = bad_type_values
+
+ unknown_key_values = copy.deepcopy(values)
+ unknown_key_values['unknown_key'] = 16546
+ with self.assertRaises(KeyError):
+ struct.value = unknown_key_values
+
+ def test_value_rollback(self):
+ int_ft = bt2.IntegerFieldType(32)
+ str_ft = bt2.StringFieldType()
+ struct_ft = bt2.StructureFieldType()
+ struct_ft.append_field(field_type=int_ft, name='an_int')
+ struct_ft.append_field(field_type=str_ft, name='a_string')
+ struct_ft.append_field(field_type=int_ft, name='another_int')
+ values = {
+ 'an_int': 42,
+ 'a_string': 'hello',
+ 'another_int': 66
+ }
+
+ def test_is_set(self):
+ values = {
+ 'an_int': 42,
+ 'a_string': 'hello',
+ 'another_int': 66
+ }
+
+ int_ft = bt2.IntegerFieldType(32)
+ str_ft = bt2.StringFieldType()
+ struct_ft = bt2.StructureFieldType()
+ struct_ft.append_field(field_type=int_ft, name='an_int')
+ struct_ft.append_field(field_type=str_ft, name='a_string')
+ struct_ft.append_field(field_type=int_ft, name='another_int')
+
+ struct = struct_ft()
+ self.assertFalse(struct.is_set)
+ struct.value = values
+ self.assertTrue(struct.is_set)
+
+ struct = struct_ft()
+ struct['an_int'].value = 42
+ self.assertFalse(struct.is_set)
+
+ def test_reset(self):
+ values = {
+ 'an_int': 42,
+ 'a_string': 'hello',
+ 'another_int': 66
+ }
+
+ int_ft = bt2.IntegerFieldType(32)
+ str_ft = bt2.StringFieldType()
+ struct_ft = bt2.StructureFieldType()
+ struct_ft.append_field(field_type=int_ft, name='an_int')
+ struct_ft.append_field(field_type=str_ft, name='a_string')
+ struct_ft.append_field(field_type=int_ft, name='another_int')
+
+ struct = struct_ft()
+ struct.value = values
+ self.assertTrue(struct.is_set)
+ struct.reset()
+ self.assertEqual(struct_ft(), struct)
+
+ def test_str_op(self):
+ expected_string_found = False
+ s = str(self._def)
+ # Establish all permutations of the three expected matches since
+ # the order in which mappings are enumerated is not explicitly part of
+ # the API.
+ for p in itertools.permutations([(k, v) for k, v in self._def.items()]):
+ items = ['{}: {}'.format(repr(k), repr(v)) for k, v in p]
+ candidate = '{{{}}}'.format(', '.join(items))
+ if candidate == s:
+ expected_string_found = True
+ break
+
+ self.assertTrue(expected_string_found)
+
+ def test_str_op_unset(self):
+ self.assertEqual(str(self._ft()), 'Unset')
+
+
+class VariantFieldTestCase(_TestCopySimple, unittest.TestCase):
+ def setUp(self):
+ self._tag_ft = bt2.EnumerationFieldType(size=32)
+ self._tag_ft.append_mapping('corner', 23)
+ self._tag_ft.append_mapping('zoom', 17, 20)
+ self._tag_ft.append_mapping('mellotron', 1001)
+ self._tag_ft.append_mapping('giorgio', 2000, 3000)
+ self._ft0 = bt2.IntegerFieldType(32, is_signed=True)
+ self._ft1 = bt2.StringFieldType()
+ self._ft2 = bt2.FloatingPointNumberFieldType()
+ self._ft3 = bt2.IntegerFieldType(17)
+ self._ft = bt2.VariantFieldType('salut', self._tag_ft)
+ self._ft.append_field('corner', self._ft0)
+ self._ft.append_field('zoom', self._ft1)
+ self._ft.append_field('mellotron', self._ft2)
+ self._ft.append_field('giorgio', self._ft3)
+ self._def = self._ft()
+
+ def tearDown(self):
+ del self._tag_ft
+ del self._ft0
+ del self._ft1
+ del self._ft2
+ del self._ft3
+ del self._ft
+ del self._def
+
+ def test_bool_op_true(self):
+ tag_field = self._tag_ft(1001)
+ self._def.field(tag_field).value = -17.34
+ self.assertTrue(self._def)
+
+ def test_bool_op_false(self):
+ self.assertFalse(self._def)
+
+ def test_tag_field_none(self):
+ self.assertIsNone(self._def.tag_field)
+
+ def test_tag_field(self):
+ tag_field = self._tag_ft(2800)
+ self._def.field(tag_field).value = 1847
+ self.assertEqual(self._def.tag_field, tag_field)
+ self.assertEqual(self._def.tag_field.addr, tag_field.addr)
+
+ def test_selected_field_none(self):
+ self.assertIsNone(self._def.selected_field)
+
+ def test_selected_field(self):
+ var_field1 = self._ft()
+ tag_field1 = self._tag_ft(1001)
+ var_field1.field(tag_field1).value = -17.34
+ self.assertEqual(var_field1.field(), -17.34)
+ self.assertEqual(var_field1.selected_field, -17.34)
+ var_field2 = self._ft()
+ tag_field2 = self._tag_ft(2500)
+ var_field2.field(tag_field2).value = 1921
+ self.assertEqual(var_field2.field(), 1921)
+ self.assertEqual(var_field2.selected_field, 1921)
+
+ def test_eq(self):
+ tag_ft = bt2.EnumerationFieldType(size=32)
+ tag_ft.append_mapping('corner', 23)
+ tag_ft.append_mapping('zoom', 17, 20)
+ tag_ft.append_mapping('mellotron', 1001)
+ tag_ft.append_mapping('giorgio', 2000, 3000)
+ ft0 = bt2.IntegerFieldType(32, is_signed=True)
+ ft1 = bt2.StringFieldType()
+ ft2 = bt2.FloatingPointNumberFieldType()
+ ft3 = bt2.IntegerFieldType(17)
+ ft = bt2.VariantFieldType('salut', tag_ft)
+ ft.append_field('corner', ft0)
+ ft.append_field('zoom', ft1)
+ ft.append_field('mellotron', ft2)
+ ft.append_field('giorgio', ft3)
+ field = ft()
+ field_tag = tag_ft(23)
+ def_tag = self._tag_ft(23)
+ field.field(field_tag).value = 1774
+ self._def.field(def_tag).value = 1774
+ self.assertEqual(self._def, field)
+
+ def test_eq_invalid_type(self):
+ self.assertNotEqual(self._def, 23)
+
+ def test_is_set(self):
+ self.assertFalse(self._def.is_set)
+ tag_field = self._tag_ft(2800)
+ self._def.field(tag_field).value = 684
+ self.assertTrue(self._def.is_set)
+
+ def test_reset(self):
+ tag_field = self._tag_ft(2800)
+ self._def.field(tag_field).value = 684
+ self._def.reset()
+ self.assertFalse(self._def.is_set)
+ self.assertIsNone(self._def.selected_field)
+ self.assertIsNone(self._def.tag_field)
+
+ def test_str_op_int(self):
+ v = self._ft()
+ v.field(self._tag_ft(23)).value = 42
+ f = self._ft0(42)
+ self.assertEqual(str(f), str(v))
+
+ def test_str_op_str(self):
+ v = self._ft()
+ v.field(self._tag_ft(18)).value = 'some test string'
+ f = self._ft1('some test string')
+ self.assertEqual(str(f), str(v))
+
+ def test_str_op_flt(self):
+ v = self._ft()
+ v.field(self._tag_ft(1001)).value = 14.4245
+ f = self._ft2(14.4245)
+ self.assertEqual(str(f), str(v))
+
+ def test_str_op_unset(self):
+ self.assertEqual(str(self._ft()), 'Unset')
projects / babeltrace.git / blobdiff