tests/bindings/python/bt2/test_field_types.py

   1 import bt2.fields
   2 import unittest
   3 import copy
   4 import bt2
   5
   6
   7 class _TestCopySimple:
   8     def _test_copy(self, cpy):
   9         self.assertIsNot(cpy, self._ft)
  10         self.assertNotEqual(cpy.addr, self._ft.addr)
  11         self.assertEqual(cpy, self._ft)
  12
  13     def test_copy(self):
  14         cpy = copy.copy(self._ft)
  15         self._test_copy(cpy)
  16
  17     def test_deepcopy(self):
  18         cpy = copy.deepcopy(self._ft)
  19         self._test_copy(cpy)
  20
  21
  22 class _TestAlignmentProp:
  23     def test_assign_alignment(self):
  24         self._ft.alignment = 32
  25         self.assertEqual(self._ft.alignment, 32)
  26
  27     def test_assign_invalid_alignment(self):
  28         with self.assertRaises(ValueError):
  29             self._ft.alignment = 23
  30
  31
  32 class _TestByteOrderProp:
  33     def test_assign_byte_order(self):
  34         self._ft.byte_order = bt2.ByteOrder.LITTLE_ENDIAN
  35         self.assertEqual(self._ft.byte_order, bt2.ByteOrder.LITTLE_ENDIAN)
  36
  37     def test_assign_invalid_byte_order(self):
  38         with self.assertRaises(TypeError):
  39             self._ft.byte_order = 'hey'
  40
  41
  42 class _TestInvalidEq:
  43     def test_eq_invalid(self):
  44         self.assertFalse(self._ft == 23)
  45
  46
  47 class _TestIntegerFieldTypeProps:
  48     def test_size_prop(self):
  49         self.assertEqual(self._ft.size, 35)
  50
  51     def test_assign_signed(self):
  52         self._ft.is_signed = True
  53         self.assertTrue(self._ft.is_signed)
  54
  55     def test_assign_invalid_signed(self):
  56         with self.assertRaises(TypeError):
  57             self._ft.is_signed = 23
  58
  59     def test_assign_base(self):
  60         self._ft.base = bt2.Base.HEXADECIMAL
  61         self.assertEqual(self._ft.base, bt2.Base.HEXADECIMAL)
  62
  63     def test_assign_invalid_base(self):
  64         with self.assertRaises(TypeError):
  65             self._ft.base = 'hey'
  66
  67     def test_assign_encoding(self):
  68         self._ft.encoding = bt2.Encoding.UTF8
  69         self.assertEqual(self._ft.encoding, bt2.Encoding.UTF8)
  70
  71     def test_assign_invalid_encoding(self):
  72         with self.assertRaises(TypeError):
  73             self._ft.encoding = 'hey'
  74
  75     def test_assign_mapped_clock_class(self):
  76         cc = bt2.ClockClass('name', 1000)
  77         self._ft.mapped_clock_class = cc
  78         self.assertEqual(self._ft.mapped_clock_class, cc)
  79
  80     def test_assign_invalid_mapped_clock_class(self):
  81         with self.assertRaises(TypeError):
  82             self._ft.mapped_clock_class = object()
  83
  84
  85 class IntegerFieldTypeTestCase(_TestIntegerFieldTypeProps, _TestCopySimple,
  86                                _TestAlignmentProp, _TestByteOrderProp,
  87                                _TestInvalidEq, unittest.TestCase):
  88     def setUp(self):
  89         self._ft = bt2.IntegerFieldType(35)
  90
  91     def tearDown(self):
  92         del self._ft
  93
  94     def test_create_default(self):
  95         self.assertEqual(self._ft.size, 35)
  96         self.assertIsNone(self._ft.mapped_clock_class)
  97
  98     def test_create_invalid_size(self):
  99         with self.assertRaises(TypeError):
 100             ft = bt2.IntegerFieldType('yes')
 101
 102     def test_create_neg_size(self):
 103         with self.assertRaises(ValueError):
 104             ft = bt2.IntegerFieldType(-2)
 105
 106     def test_create_neg_zero(self):
 107         with self.assertRaises(ValueError):
 108             ft = bt2.IntegerFieldType(0)
 109
 110     def test_create_full(self):
 111         cc = bt2.ClockClass('name', 1000)
 112         ft = bt2.IntegerFieldType(24, alignment=16,
 113                                   byte_order=bt2.ByteOrder.BIG_ENDIAN,
 114                                   is_signed=True, base=bt2.Base.OCTAL,
 115                                   encoding=bt2.Encoding.NONE,
 116                                   mapped_clock_class=cc)
 117         self.assertEqual(ft.size, 24)
 118         self.assertEqual(ft.alignment, 16)
 119         self.assertEqual(ft.byte_order, bt2.ByteOrder.BIG_ENDIAN)
 120         self.assertTrue(ft.is_signed)
 121         self.assertEqual(ft.base, bt2.Base.OCTAL)
 122         self.assertEqual(ft.encoding, bt2.Encoding.NONE)
 123         self.assertEqual(ft.mapped_clock_class, cc)
 124
 125     def test_create_field(self):
 126         field = self._ft()
 127         self.assertIsInstance(field, bt2.fields._IntegerField)
 128
 129     def test_create_field_init(self):
 130         field = self._ft(23)
 131         self.assertEqual(field, 23)
 132
 133
 134 class FloatingPointNumberFieldTypeTestCase(_TestCopySimple, _TestAlignmentProp,
 135                                            _TestByteOrderProp, _TestInvalidEq,
 136                                            unittest.TestCase):
 137     def setUp(self):
 138         self._ft = bt2.FloatingPointNumberFieldType()
 139
 140     def tearDown(self):
 141         del self._ft
 142
 143     def test_create_default(self):
 144         pass
 145
 146     def test_create_full(self):
 147         ft = bt2.FloatingPointNumberFieldType(alignment=16,
 148                                               byte_order=bt2.ByteOrder.BIG_ENDIAN,
 149                                               exponent_size=11,
 150                                               mantissa_size=53)
 151         self.assertEqual(ft.alignment, 16)
 152         self.assertEqual(ft.byte_order, bt2.ByteOrder.BIG_ENDIAN)
 153         self.assertEqual(ft.exponent_size, 11)
 154         self.assertEqual(ft.mantissa_size, 53)
 155
 156     def test_assign_exponent_size(self):
 157         self._ft.exponent_size = 8
 158         self.assertEqual(self._ft.exponent_size, 8)
 159
 160     def test_assign_invalid_exponent_size(self):
 161         with self.assertRaises(TypeError):
 162             self._ft.exponent_size = 'yes'
 163
 164     def test_assign_mantissa_size(self):
 165         self._ft.mantissa_size = 24
 166         self.assertEqual(self._ft.mantissa_size, 24)
 167
 168     def test_assign_invalid_mantissa_size(self):
 169         with self.assertRaises(TypeError):
 170             self._ft.mantissa_size = 'no'
 171
 172     def test_create_field(self):
 173         field = self._ft()
 174         self.assertIsInstance(field, bt2.fields._FloatingPointNumberField)
 175
 176     def test_create_field_init(self):
 177         field = self._ft(17.5)
 178         self.assertEqual(field, 17.5)
 179
 180
 181 class EnumerationFieldTypeTestCase(_TestIntegerFieldTypeProps, _TestInvalidEq,
 182                                    _TestCopySimple, _TestAlignmentProp,
 183                                    _TestByteOrderProp, unittest.TestCase):
 184     def setUp(self):
 185         self._ft = bt2.EnumerationFieldType(size=35)
 186
 187     def tearDown(self):
 188         del self._ft
 189
 190     def test_create_from_int_ft(self):
 191         int_ft = bt2.IntegerFieldType(23)
 192         self._ft = bt2.EnumerationFieldType(int_ft)
 193
 194     def test_create_from_invalid_type(self):
 195         with self.assertRaises(TypeError):
 196             self._ft = bt2.EnumerationFieldType('coucou')
 197
 198     def test_create_from_invalid_ft(self):
 199         with self.assertRaises(TypeError):
 200             ft = bt2.FloatingPointNumberFieldType()
 201             self._ft = bt2.EnumerationFieldType(ft)
 202
 203     def test_create_full(self):
 204         ft = bt2.EnumerationFieldType(size=24, alignment=16,
 205                                       byte_order=bt2.ByteOrder.BIG_ENDIAN,
 206                                       is_signed=True, base=bt2.Base.OCTAL,
 207                                       encoding=bt2.Encoding.NONE,
 208                                       mapped_clock_class=None)
 209         self.assertEqual(ft.size, 24)
 210         self.assertEqual(ft.alignment, 16)
 211         self.assertEqual(ft.byte_order, bt2.ByteOrder.BIG_ENDIAN)
 212         self.assertTrue(ft.is_signed)
 213         self.assertEqual(ft.base, bt2.Base.OCTAL)
 214         self.assertEqual(ft.encoding, bt2.Encoding.NONE)
 215         #self.assertIsNone(ft.mapped_clock_class)
 216
 217     def test_integer_field_type_prop(self):
 218         int_ft = bt2.IntegerFieldType(23)
 219         enum_ft = bt2.EnumerationFieldType(int_ft)
 220         self.assertEqual(enum_ft.integer_field_type.addr, int_ft.addr)
 221
 222     def test_add_mapping_simple(self):
 223         self._ft.add_mapping('hello', 24)
 224         mapping = self._ft[0]
 225         self.assertEqual(mapping.name, 'hello')
 226         self.assertEqual(mapping.lower, 24)
 227         self.assertEqual(mapping.upper, 24)
 228
 229     def test_add_mapping_simple_kwargs(self):
 230         self._ft.add_mapping(name='hello', lower=17, upper=23)
 231         mapping = self._ft[0]
 232         self.assertEqual(mapping.name, 'hello')
 233         self.assertEqual(mapping.lower, 17)
 234         self.assertEqual(mapping.upper, 23)
 235
 236     def test_add_mapping_range(self):
 237         self._ft.add_mapping('hello', 21, 199)
 238         mapping = self._ft[0]
 239         self.assertEqual(mapping.name, 'hello')
 240         self.assertEqual(mapping.lower, 21)
 241         self.assertEqual(mapping.upper, 199)
 242
 243     def test_add_mapping_invalid_name(self):
 244         with self.assertRaises(TypeError):
 245             self._ft.add_mapping(17, 21, 199)
 246
 247     def test_add_mapping_invalid_signedness_lower(self):
 248         with self.assertRaises(ValueError):
 249             self._ft.add_mapping('hello', -21, 199)
 250
 251     def test_add_mapping_invalid_signedness_upper(self):
 252         with self.assertRaises(ValueError):
 253             self._ft.add_mapping('hello', 21, -199)
 254
 255     def test_add_mapping_simple_signed(self):
 256         self._ft.is_signed = True
 257         self._ft.add_mapping('hello', -24)
 258         mapping = self._ft[0]
 259         self.assertEqual(mapping.name, 'hello')
 260         self.assertEqual(mapping.lower, -24)
 261         self.assertEqual(mapping.upper, -24)
 262
 263     def test_add_mapping_range_signed(self):
 264         self._ft.is_signed = True
 265         self._ft.add_mapping('hello', -21, 199)
 266         mapping = self._ft[0]
 267         self.assertEqual(mapping.name, 'hello')
 268         self.assertEqual(mapping.lower, -21)
 269         self.assertEqual(mapping.upper, 199)
 270
 271     def test_iadd(self):
 272         enum_ft = bt2.EnumerationFieldType(size=16)
 273         enum_ft.add_mapping('c', 4, 5)
 274         enum_ft.add_mapping('d', 6, 18)
 275         enum_ft.add_mapping('e', 20, 27)
 276         self._ft.add_mapping('a', 0, 2)
 277         self._ft.add_mapping('b', 3)
 278         self._ft += enum_ft
 279         self.assertEqual(self._ft[0].name, 'a')
 280         self.assertEqual(self._ft[0].lower, 0)
 281         self.assertEqual(self._ft[0].upper, 2)
 282         self.assertEqual(self._ft[1].name, 'b')
 283         self.assertEqual(self._ft[1].lower, 3)
 284         self.assertEqual(self._ft[1].upper, 3)
 285         self.assertEqual(self._ft[2].name, 'c')
 286         self.assertEqual(self._ft[2].lower, 4)
 287         self.assertEqual(self._ft[2].upper, 5)
 288         self.assertEqual(self._ft[3].name, 'd')
 289         self.assertEqual(self._ft[3].lower, 6)
 290         self.assertEqual(self._ft[3].upper, 18)
 291         self.assertEqual(self._ft[4].name, 'e')
 292         self.assertEqual(self._ft[4].lower, 20)
 293         self.assertEqual(self._ft[4].upper, 27)
 294
 295     def test_bool_op(self):
 296         self.assertFalse(self._ft)
 297         self._ft.add_mapping('a', 0)
 298         self.assertTrue(self._ft)
 299
 300     def test_len(self):
 301         self._ft.add_mapping('a', 0)
 302         self._ft.add_mapping('b', 1)
 303         self._ft.add_mapping('c', 2)
 304         self.assertEqual(len(self._ft), 3)
 305
 306     def test_getitem(self):
 307         self._ft.add_mapping('a', 0)
 308         self._ft.add_mapping('b', 1, 3)
 309         self._ft.add_mapping('c', 5)
 310         mapping = self._ft[1]
 311         self.assertEqual(mapping.name, 'b')
 312         self.assertEqual(mapping.lower, 1)
 313         self.assertEqual(mapping.upper, 3)
 314
 315     def test_iter(self):
 316         mappings = (
 317             ('a', 1, 5),
 318             ('b', 10, 17),
 319             ('c', 20, 1504),
 320             ('d', 22510, 99999),
 321         )
 322
 323         for mapping in mappings:
 324             self._ft.add_mapping(*mapping)
 325
 326         for ft_mapping, mapping in zip(self._ft, mappings):
 327             self.assertEqual(ft_mapping.name, mapping[0])
 328             self.assertEqual(ft_mapping.lower, mapping[1])
 329             self.assertEqual(ft_mapping.upper, mapping[2])
 330
 331     def test_mapping_eq(self):
 332         enum1 = bt2.EnumerationFieldType(size=32)
 333         enum2 = bt2.EnumerationFieldType(size=16)
 334         enum1.add_mapping('b', 1, 3)
 335         enum2.add_mapping('b', 1, 3)
 336         self.assertEqual(enum1[0], enum2[0])
 337
 338     def test_mapping_eq_invalid(self):
 339         enum1 = bt2.EnumerationFieldType(size=32)
 340         enum1.add_mapping('b', 1, 3)
 341         self.assertNotEqual(enum1[0], 23)
 342
 343     def _test_find_by_name(self, ft):
 344         ft.add_mapping('a', 0)
 345         ft.add_mapping('b', 1, 3)
 346         ft.add_mapping('a', 5)
 347         ft.add_mapping('a', 17, 144)
 348         ft.add_mapping('C', 5)
 349         mapping_iter = ft.mappings_by_name('a')
 350         mappings = list(mapping_iter)
 351         a0 = False
 352         a5 = False
 353         a17_144 = False
 354         i = 0
 355
 356         for mapping in mappings:
 357             i += 1
 358             self.assertEqual(mapping.name, 'a')
 359
 360             if mapping.lower == 0 and mapping.upper == 0:
 361                 a0 = True
 362             elif mapping.lower == 5 and mapping.upper == 5:
 363                 a5 = True
 364             elif mapping.lower == 17 and mapping.upper == 144:
 365                 a17_144 = True
 366
 367         self.assertEqual(i, 3)
 368         self.assertTrue(a0)
 369         self.assertTrue(a5)
 370         self.assertTrue(a17_144)
 371
 372     def test_find_by_name_signed(self):
 373         self._test_find_by_name(bt2.EnumerationFieldType(size=8, is_signed=True))
 374
 375     def test_find_by_name_unsigned(self):
 376         self._test_find_by_name(bt2.EnumerationFieldType(size=8))
 377
 378     def _test_find_by_value(self, ft):
 379         ft.add_mapping('a', 0)
 380         ft.add_mapping('b', 1, 3)
 381         ft.add_mapping('c', 5, 19)
 382         ft.add_mapping('d', 8, 15)
 383         ft.add_mapping('e', 10, 21)
 384         ft.add_mapping('f', 0)
 385         ft.add_mapping('g', 14)
 386         mapping_iter = ft.mappings_by_value(14)
 387         mappings = list(mapping_iter)
 388         c = False
 389         d = False
 390         e = False
 391         g = False
 392         i = 0
 393
 394         for mapping in mappings:
 395             i += 1
 396
 397             if mapping.name == 'c':
 398                 c = True
 399             elif mapping.name == 'd':
 400                 d = True
 401             elif mapping.name == 'e':
 402                 e = True
 403             elif mapping.name == 'g':
 404                 g = True
 405
 406         self.assertEqual(i, 4)
 407         self.assertTrue(c)
 408         self.assertTrue(d)
 409         self.assertTrue(e)
 410         self.assertTrue(g)
 411
 412     def test_find_by_value_signed(self):
 413         self._test_find_by_value(bt2.EnumerationFieldType(size=8, is_signed=True))
 414
 415     def test_find_by_value_unsigned(self):
 416         self._test_find_by_value(bt2.EnumerationFieldType(size=8))
 417
 418     def test_create_field(self):
 419         self._ft.add_mapping('c', 4, 5)
 420         field = self._ft()
 421         self.assertIsInstance(field, bt2.fields._EnumerationField)
 422
 423     def test_create_field_init(self):
 424         self._ft.add_mapping('c', 4, 5)
 425         field = self._ft(4)
 426         self.assertEqual(field, 4)
 427
 428
 429 class StringFieldTypeTestCase(_TestCopySimple, _TestInvalidEq,
 430                               unittest.TestCase):
 431     def setUp(self):
 432         self._ft = bt2.StringFieldType()
 433
 434     def tearDown(self):
 435         del self._ft
 436
 437     def test_create_default(self):
 438         pass
 439
 440     def test_create_full(self):
 441         ft = bt2.StringFieldType(encoding=bt2.Encoding.UTF8)
 442         self.assertEqual(ft.encoding, bt2.Encoding.UTF8)
 443
 444     def test_assign_encoding(self):
 445         self._ft.encoding = bt2.Encoding.UTF8
 446         self.assertEqual(self._ft.encoding, bt2.Encoding.UTF8)
 447
 448     def test_assign_invalid_encoding(self):
 449         with self.assertRaises(TypeError):
 450             self._ft.encoding = 'yes'
 451
 452     def test_create_field(self):
 453         field = self._ft()
 454         self.assertIsInstance(field, bt2.fields._StringField)
 455
 456     def test_create_field_init(self):
 457         field = self._ft('hola')
 458         self.assertEqual(field, 'hola')
 459
 460
 461 class _TestFieldContainer(_TestInvalidEq, _TestCopySimple):
 462     def test_append_field(self):
 463         int_field_type = bt2.IntegerFieldType(32)
 464         self._ft.append_field('int32', int_field_type)
 465         field_type = self._ft['int32']
 466         self.assertEqual(field_type, int_field_type)
 467
 468     def test_append_field_kwargs(self):
 469         int_field_type = bt2.IntegerFieldType(32)
 470         self._ft.append_field(name='int32', field_type=int_field_type)
 471         field_type = self._ft['int32']
 472         self.assertEqual(field_type, int_field_type)
 473
 474     def test_append_field_invalid_name(self):
 475         with self.assertRaises(TypeError):
 476             self._ft.append_field(23, bt2.StringFieldType())
 477
 478     def test_append_field_invalid_field_type(self):
 479         with self.assertRaises(TypeError):
 480             self._ft.append_field('yes', object())
 481
 482     def test_iadd(self):
 483         struct_ft = bt2.StructureFieldType()
 484         c_field_type = bt2.StringFieldType()
 485         d_field_type = bt2.EnumerationFieldType(size=32)
 486         e_field_type = bt2.StructureFieldType()
 487         struct_ft.append_field('c_string', c_field_type)
 488         struct_ft.append_field('d_enum', d_field_type)
 489         struct_ft.append_field('e_struct', e_field_type)
 490         a_field_type = bt2.FloatingPointNumberFieldType()
 491         b_field_type = bt2.IntegerFieldType(17)
 492         self._ft.append_field('a_float', a_field_type)
 493         self._ft.append_field('b_int', b_field_type)
 494         self._ft += struct_ft
 495         self.assertEqual(self._ft['a_float'], a_field_type)
 496         self.assertEqual(self._ft['b_int'], b_field_type)
 497         self.assertEqual(self._ft['c_string'], c_field_type)
 498         self.assertEqual(self._ft['d_enum'], d_field_type)
 499         self.assertEqual(self._ft['e_struct'], e_field_type)
 500
 501     def test_bool_op(self):
 502         self.assertFalse(self._ft)
 503         self._ft.append_field('a', bt2.StringFieldType())
 504         self.assertTrue(self._ft)
 505
 506     def test_len(self):
 507         ft = bt2.StringFieldType()
 508         self._ft.append_field('a', ft)
 509         self._ft.append_field('b', ft)
 510         self._ft.append_field('c', ft)
 511         self.assertEqual(len(self._ft), 3)
 512
 513     def test_getitem(self):
 514         a_ft = bt2.IntegerFieldType(32)
 515         b_ft = bt2.StringFieldType()
 516         c_ft = bt2.FloatingPointNumberFieldType()
 517         self._ft.append_field('a', a_ft)
 518         self._ft.append_field('b', b_ft)
 519         self._ft.append_field('c', c_ft)
 520         self.assertEqual(self._ft['b'], b_ft)
 521
 522     def test_getitem_invalid_key_type(self):
 523         with self.assertRaises(TypeError):
 524             self._ft[0]
 525
 526     def test_getitem_invalid_key(self):
 527         with self.assertRaises(KeyError):
 528             self._ft['no way']
 529
 530     def test_contains(self):
 531         self.assertFalse('a' in self._ft)
 532         self._ft.append_field('a', bt2.StringFieldType())
 533         self.assertTrue('a' in self._ft)
 534
 535     def test_iter(self):
 536         a_ft = bt2.IntegerFieldType(32)
 537         b_ft = bt2.StringFieldType()
 538         c_ft = bt2.FloatingPointNumberFieldType()
 539         fields = (
 540             ('a', a_ft),
 541             ('b', b_ft),
 542             ('c', c_ft),
 543         )
 544
 545         for field in fields:
 546             self._ft.append_field(*field)
 547
 548         for (name, ft_field_type), field in zip(self._ft.items(), fields):
 549             self.assertEqual(name, field[0])
 550             self.assertEqual(ft_field_type, field[1])
 551
 552     def test_at_index(self):
 553         a_ft = bt2.IntegerFieldType(32)
 554         b_ft = bt2.StringFieldType()
 555         c_ft = bt2.FloatingPointNumberFieldType()
 556         self._ft.append_field('c', c_ft)
 557         self._ft.append_field('a', a_ft)
 558         self._ft.append_field('b', b_ft)
 559         self.assertEqual(self._ft.at_index(1), a_ft)
 560
 561     def test_at_index_invalid(self):
 562         self._ft.append_field('c', bt2.IntegerFieldType(32))
 563
 564         with self.assertRaises(TypeError):
 565             self._ft.at_index('yes')
 566
 567     def test_at_index_out_of_bounds_after(self):
 568         self._ft.append_field('c', bt2.IntegerFieldType(32))
 569
 570         with self.assertRaises(IndexError):
 571             self._ft.at_index(len(self._ft))
 572
 573
 574 class StructureFieldTypeTestCase(_TestFieldContainer, unittest.TestCase):
 575     def setUp(self):
 576         self._ft = bt2.StructureFieldType()
 577
 578     def tearDown(self):
 579         del self._ft
 580
 581     def test_create_default(self):
 582         self.assertEqual(self._ft.alignment, 1)
 583
 584     def test_create_with_min_alignment(self):
 585         ft = bt2.StructureFieldType(8)
 586         self.assertEqual(ft.alignment, 8)
 587
 588     def test_assign_alignment(self):
 589         with self.assertRaises(AttributeError):
 590             self._ft.alignment = 32
 591
 592     def test_assign_min_alignment(self):
 593         self._ft.min_alignment = 64
 594         self.assertTrue(self._ft.alignment >= 64)
 595
 596     def test_assign_invalid_min_alignment(self):
 597         with self.assertRaises(ValueError):
 598             self._ft.min_alignment = 23
 599
 600     def test_assign_get_min_alignment(self):
 601         with self.assertRaises(AttributeError):
 602             self._ft.min_alignment
 603
 604     def test_create_field(self):
 605         field = self._ft()
 606         self.assertIsInstance(field, bt2.fields._StructureField)
 607
 608     def test_create_field_init_invalid(self):
 609         with self.assertRaises(bt2.Error):
 610             field = self._ft(23)
 611
 612
 613 class VariantFieldTypeTestCase(_TestFieldContainer, unittest.TestCase):
 614     def setUp(self):
 615         self._ft = bt2.VariantFieldType('path.to.tag')
 616
 617     def tearDown(self):
 618         del self._ft
 619
 620     def test_create_default(self):
 621         self.assertEqual(self._ft.tag_name, 'path.to.tag')
 622
 623     def test_create_invalid_tag_name(self):
 624         with self.assertRaises(TypeError):
 625             self._ft = bt2.VariantFieldType(23)
 626
 627     def test_assign_tag_name(self):
 628         self._ft.tag_name = 'a.different.tag'
 629         self.assertEqual(self._ft.tag_name, 'a.different.tag')
 630
 631     def test_assign_invalid_tag_name(self):
 632         with self.assertRaises(TypeError):
 633             self._ft.tag_name = -17
 634
 635
 636 class ArrayFieldTypeTestCase(_TestInvalidEq, _TestCopySimple,
 637                              unittest.TestCase):
 638     def setUp(self):
 639         self._elem_ft = bt2.IntegerFieldType(23)
 640         self._ft = bt2.ArrayFieldType(self._elem_ft, 45)
 641
 642     def tearDown(self):
 643         del self._ft
 644         del self._elem_ft
 645
 646     def test_create_default(self):
 647         self.assertEqual(self._ft.element_field_type, self._elem_ft)
 648         self.assertEqual(self._ft.length, 45)
 649
 650     def test_create_invalid_field_type(self):
 651         with self.assertRaises(TypeError):
 652             self._ft = bt2.ArrayFieldType(object(), 45)
 653
 654     def test_create_invalid_length(self):
 655         with self.assertRaises(ValueError):
 656             self._ft = bt2.ArrayFieldType(bt2.StringFieldType(), -17)
 657
 658     def test_create_invalid_length_type(self):
 659         with self.assertRaises(TypeError):
 660             self._ft = bt2.ArrayFieldType(bt2.StringFieldType(), 'the length')
 661
 662     def test_create_field(self):
 663         field = self._ft()
 664         self.assertIsInstance(field, bt2.fields._ArrayField)
 665
 666     def test_create_field_init_invalid(self):
 667         with self.assertRaises(bt2.Error):
 668             field = self._ft(23)
 669
 670
 671 class SequenceFieldTypeTestCase(_TestInvalidEq, _TestCopySimple,
 672                                 unittest.TestCase):
 673     def setUp(self):
 674         self._elem_ft = bt2.IntegerFieldType(23)
 675         self._ft = bt2.SequenceFieldType(self._elem_ft, 'the.length')
 676
 677     def tearDown(self):
 678         del self._ft
 679         del self._elem_ft
 680
 681     def test_create_default(self):
 682         self.assertEqual(self._ft.element_field_type, self._elem_ft)
 683         self.assertEqual(self._ft.length_name, 'the.length')
 684
 685     def test_create_invalid_field_type(self):
 686         with self.assertRaises(TypeError):
 687             self._ft = bt2.ArrayFieldType(object(), 'the.length')
 688
 689     def test_create_invalid_length_type(self):
 690         with self.assertRaises(TypeError):
 691             self._ft = bt2.SequenceFieldType(bt2.StringFieldType(), 17)
 692
 693     def test_create_field(self):
 694         field = self._ft()
 695         self.assertIsInstance(field, bt2.fields._SequenceField)
 696
 697     def test_create_field_init_invalid(self):
 698         with self.assertRaises(bt2.Error):
 699             field = self._ft(23)