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