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
)
14 cpy
= copy
.copy(self
._ft
)
17 def test_deepcopy(self
):
18 cpy
= copy
.deepcopy(self
._ft
)
22 class _TestAlignmentProp
:
23 def test_assign_alignment(self
):
24 self
._ft
.alignment
= 32
25 self
.assertEqual(self
._ft
.alignment
, 32)
27 def test_assign_invalid_alignment(self
):
28 with self
.assertRaises(ValueError):
29 self
._ft
.alignment
= 23
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
)
37 def test_assign_invalid_byte_order(self
):
38 with self
.assertRaises(TypeError):
39 self
._ft
.byte_order
= 'hey'
43 def test_eq_invalid(self
):
44 self
.assertFalse(self
._ft
== 23)
47 class _TestIntegerFieldTypeProps
:
48 def test_size_prop(self
):
49 self
.assertEqual(self
._ft
.size
, 35)
51 def test_assign_signed(self
):
52 self
._ft
.is_signed
= True
53 self
.assertTrue(self
._ft
.is_signed
)
55 def test_assign_invalid_signed(self
):
56 with self
.assertRaises(TypeError):
57 self
._ft
.is_signed
= 23
59 def test_assign_base(self
):
60 self
._ft
.base
= bt2
.Base
.HEXADECIMAL
61 self
.assertEqual(self
._ft
.base
, bt2
.Base
.HEXADECIMAL
)
63 def test_assign_invalid_base(self
):
64 with self
.assertRaises(TypeError):
67 def test_assign_encoding(self
):
68 self
._ft
.encoding
= bt2
.Encoding
.UTF8
69 self
.assertEqual(self
._ft
.encoding
, bt2
.Encoding
.UTF8
)
71 def test_assign_invalid_encoding(self
):
72 with self
.assertRaises(TypeError):
73 self
._ft
.encoding
= 'hey'
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
)
80 def test_assign_invalid_mapped_clock_class(self
):
81 with self
.assertRaises(TypeError):
82 self
._ft
.mapped_clock_class
= object()
85 class IntegerFieldTypeTestCase(_TestIntegerFieldTypeProps
, _TestCopySimple
,
86 _TestAlignmentProp
, _TestByteOrderProp
,
87 _TestInvalidEq
, unittest
.TestCase
):
89 self
._ft
= bt2
.IntegerFieldType(35)
94 def test_create_default(self
):
95 self
.assertEqual(self
._ft
.size
, 35)
96 self
.assertIsNone(self
._ft
.mapped_clock_class
)
98 def test_create_invalid_size(self
):
99 with self
.assertRaises(TypeError):
100 ft
= bt2
.IntegerFieldType('yes')
102 def test_create_neg_size(self
):
103 with self
.assertRaises(ValueError):
104 ft
= bt2
.IntegerFieldType(-2)
106 def test_create_neg_zero(self
):
107 with self
.assertRaises(ValueError):
108 ft
= bt2
.IntegerFieldType(0)
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
)
125 def test_create_field(self
):
127 self
.assertIsInstance(field
, bt2
.fields
._IntegerField
)
129 def test_create_field_init(self
):
131 self
.assertEqual(field
, 23)
134 class FloatingPointNumberFieldTypeTestCase(_TestCopySimple
, _TestAlignmentProp
,
135 _TestByteOrderProp
, _TestInvalidEq
,
138 self
._ft
= bt2
.FloatingPointNumberFieldType()
143 def test_create_default(self
):
146 def test_create_full(self
):
147 ft
= bt2
.FloatingPointNumberFieldType(alignment
=16,
148 byte_order
=bt2
.ByteOrder
.BIG_ENDIAN
,
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)
156 def test_assign_exponent_size(self
):
157 self
._ft
.exponent_size
= 8
158 self
.assertEqual(self
._ft
.exponent_size
, 8)
160 def test_assign_invalid_exponent_size(self
):
161 with self
.assertRaises(TypeError):
162 self
._ft
.exponent_size
= 'yes'
164 def test_assign_mantissa_size(self
):
165 self
._ft
.mantissa_size
= 24
166 self
.assertEqual(self
._ft
.mantissa_size
, 24)
168 def test_assign_invalid_mantissa_size(self
):
169 with self
.assertRaises(TypeError):
170 self
._ft
.mantissa_size
= 'no'
172 def test_create_field(self
):
174 self
.assertIsInstance(field
, bt2
.fields
._FloatingPointNumberField
)
176 def test_create_field_init(self
):
177 field
= self
._ft
(17.5)
178 self
.assertEqual(field
, 17.5)
181 class EnumerationFieldTypeTestCase(_TestIntegerFieldTypeProps
, _TestInvalidEq
,
182 _TestCopySimple
, _TestAlignmentProp
,
183 _TestByteOrderProp
, unittest
.TestCase
):
185 self
._ft
= bt2
.EnumerationFieldType(size
=35)
190 def test_create_from_int_ft(self
):
191 int_ft
= bt2
.IntegerFieldType(23)
192 self
._ft
= bt2
.EnumerationFieldType(int_ft
)
194 def test_create_from_invalid_type(self
):
195 with self
.assertRaises(TypeError):
196 self
._ft
= bt2
.EnumerationFieldType('coucou')
198 def test_create_from_invalid_ft(self
):
199 with self
.assertRaises(TypeError):
200 ft
= bt2
.FloatingPointNumberFieldType()
201 self
._ft
= bt2
.EnumerationFieldType(ft
)
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)
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
)
222 def test_append_mapping_simple(self
):
223 self
._ft
.append_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)
229 def test_append_mapping_simple_kwargs(self
):
230 self
._ft
.append_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)
236 def test_append_mapping_range(self
):
237 self
._ft
.append_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)
243 def test_append_mapping_invalid_name(self
):
244 with self
.assertRaises(TypeError):
245 self
._ft
.append_mapping(17, 21, 199)
247 def test_append_mapping_invalid_signedness_lower(self
):
248 with self
.assertRaises(ValueError):
249 self
._ft
.append_mapping('hello', -21, 199)
251 def test_append_mapping_invalid_signedness_upper(self
):
252 with self
.assertRaises(ValueError):
253 self
._ft
.append_mapping('hello', 21, -199)
255 def test_append_mapping_simple_signed(self
):
256 self
._ft
.is_signed
= True
257 self
._ft
.append_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)
263 def test_append_mapping_range_signed(self
):
264 self
._ft
.is_signed
= True
265 self
._ft
.append_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)
272 enum_ft
= bt2
.EnumerationFieldType(size
=16)
273 enum_ft
.append_mapping('c', 4, 5)
274 enum_ft
.append_mapping('d', 6, 18)
275 enum_ft
.append_mapping('e', 20, 27)
276 self
._ft
.append_mapping('a', 0, 2)
277 self
._ft
.append_mapping('b', 3)
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)
295 def test_bool_op(self
):
296 self
.assertFalse(self
._ft
)
297 self
._ft
.append_mapping('a', 0)
298 self
.assertTrue(self
._ft
)
301 self
._ft
.append_mapping('a', 0)
302 self
._ft
.append_mapping('b', 1)
303 self
._ft
.append_mapping('c', 2)
304 self
.assertEqual(len(self
._ft
), 3)
306 def test_getitem(self
):
307 self
._ft
.append_mapping('a', 0)
308 self
._ft
.append_mapping('b', 1, 3)
309 self
._ft
.append_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)
323 for mapping
in mappings
:
324 self
._ft
.append_mapping(*mapping
)
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])
331 def test_mapping_eq(self
):
332 enum1
= bt2
.EnumerationFieldType(size
=32)
333 enum2
= bt2
.EnumerationFieldType(size
=16)
334 enum1
.append_mapping('b', 1, 3)
335 enum2
.append_mapping('b', 1, 3)
336 self
.assertEqual(enum1
[0], enum2
[0])
338 def test_mapping_eq_invalid(self
):
339 enum1
= bt2
.EnumerationFieldType(size
=32)
340 enum1
.append_mapping('b', 1, 3)
341 self
.assertNotEqual(enum1
[0], 23)
343 def _test_find_by_name(self
, ft
):
344 ft
.append_mapping('a', 0)
345 ft
.append_mapping('b', 1, 3)
346 ft
.append_mapping('a', 5)
347 ft
.append_mapping('a', 17, 144)
348 ft
.append_mapping('C', 5)
349 mapping_iter
= ft
.mappings_by_name('a')
350 mappings
= list(mapping_iter
)
356 for mapping
in mappings
:
358 self
.assertEqual(mapping
.name
, 'a')
360 if mapping
.lower
== 0 and mapping
.upper
== 0:
362 elif mapping
.lower
== 5 and mapping
.upper
== 5:
364 elif mapping
.lower
== 17 and mapping
.upper
== 144:
367 self
.assertEqual(i
, 3)
370 self
.assertTrue(a17_144
)
372 def test_find_by_name_signed(self
):
373 self
._test
_find
_by
_name
(bt2
.EnumerationFieldType(size
=8, is_signed
=True))
375 def test_find_by_name_unsigned(self
):
376 self
._test
_find
_by
_name
(bt2
.EnumerationFieldType(size
=8))
378 def _test_find_by_value(self
, ft
):
379 ft
.append_mapping('a', 0)
380 ft
.append_mapping('b', 1, 3)
381 ft
.append_mapping('c', 5, 19)
382 ft
.append_mapping('d', 8, 15)
383 ft
.append_mapping('e', 10, 21)
384 ft
.append_mapping('f', 0)
385 ft
.append_mapping('g', 14)
386 mapping_iter
= ft
.mappings_by_value(14)
387 mappings
= list(mapping_iter
)
394 for mapping
in mappings
:
397 if mapping
.name
== 'c':
399 elif mapping
.name
== 'd':
401 elif mapping
.name
== 'e':
403 elif mapping
.name
== 'g':
406 self
.assertEqual(i
, 4)
412 def test_find_by_value_signed(self
):
413 self
._test
_find
_by
_value
(bt2
.EnumerationFieldType(size
=8, is_signed
=True))
415 def test_find_by_value_unsigned(self
):
416 self
._test
_find
_by
_value
(bt2
.EnumerationFieldType(size
=8))
418 def test_create_field(self
):
419 self
._ft
.append_mapping('c', 4, 5)
421 self
.assertIsInstance(field
, bt2
.fields
._EnumerationField
)
423 def test_create_field_init(self
):
424 self
._ft
.append_mapping('c', 4, 5)
426 self
.assertEqual(field
, 4)
429 class StringFieldTypeTestCase(_TestCopySimple
, _TestInvalidEq
,
432 self
._ft
= bt2
.StringFieldType()
437 def test_create_default(self
):
440 def test_create_full(self
):
441 ft
= bt2
.StringFieldType(encoding
=bt2
.Encoding
.UTF8
)
442 self
.assertEqual(ft
.encoding
, bt2
.Encoding
.UTF8
)
444 def test_assign_encoding(self
):
445 self
._ft
.encoding
= bt2
.Encoding
.UTF8
446 self
.assertEqual(self
._ft
.encoding
, bt2
.Encoding
.UTF8
)
448 def test_assign_invalid_encoding(self
):
449 with self
.assertRaises(TypeError):
450 self
._ft
.encoding
= 'yes'
452 def test_create_field(self
):
454 self
.assertIsInstance(field
, bt2
.fields
._StringField
)
456 def test_create_field_init(self
):
457 field
= self
._ft
('hola')
458 self
.assertEqual(field
, 'hola')
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
)
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
)
474 def test_append_field_invalid_name(self
):
475 with self
.assertRaises(TypeError):
476 self
._ft
.append_field(23, bt2
.StringFieldType())
478 def test_append_field_invalid_field_type(self
):
479 with self
.assertRaises(TypeError):
480 self
._ft
.append_field('yes', object())
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
)
501 def test_bool_op(self
):
502 self
.assertFalse(self
._ft
)
503 self
._ft
.append_field('a', bt2
.StringFieldType())
504 self
.assertTrue(self
._ft
)
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)
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
)
522 def test_getitem_invalid_key_type(self
):
523 with self
.assertRaises(TypeError):
526 def test_getitem_invalid_key(self
):
527 with self
.assertRaises(KeyError):
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
)
536 a_ft
= bt2
.IntegerFieldType(32)
537 b_ft
= bt2
.StringFieldType()
538 c_ft
= bt2
.FloatingPointNumberFieldType()
546 self
._ft
.append_field(*field
)
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])
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
)
561 def test_at_index_invalid(self
):
562 self
._ft
.append_field('c', bt2
.IntegerFieldType(32))
564 with self
.assertRaises(TypeError):
565 self
._ft
.at_index('yes')
567 def test_at_index_out_of_bounds_after(self
):
568 self
._ft
.append_field('c', bt2
.IntegerFieldType(32))
570 with self
.assertRaises(IndexError):
571 self
._ft
.at_index(len(self
._ft
))
574 class StructureFieldTypeTestCase(_TestFieldContainer
, unittest
.TestCase
):
576 self
._ft
= bt2
.StructureFieldType()
581 def test_create_default(self
):
582 self
.assertEqual(self
._ft
.alignment
, 1)
584 def test_create_with_min_alignment(self
):
585 ft
= bt2
.StructureFieldType(8)
586 self
.assertEqual(ft
.alignment
, 8)
588 def test_assign_alignment(self
):
589 with self
.assertRaises(AttributeError):
590 self
._ft
.alignment
= 32
592 def test_assign_min_alignment(self
):
593 self
._ft
.min_alignment
= 64
594 self
.assertTrue(self
._ft
.alignment
>= 64)
596 def test_assign_invalid_min_alignment(self
):
597 with self
.assertRaises(ValueError):
598 self
._ft
.min_alignment
= 23
600 def test_assign_get_min_alignment(self
):
601 with self
.assertRaises(AttributeError):
602 self
._ft
.min_alignment
604 def test_create_field(self
):
606 self
.assertIsInstance(field
, bt2
.fields
._StructureField
)
608 def test_create_field_init_invalid(self
):
609 with self
.assertRaises(bt2
.Error
):
613 class VariantFieldTypeTestCase(_TestFieldContainer
, unittest
.TestCase
):
615 self
._ft
= bt2
.VariantFieldType('path.to.tag')
620 def test_create_default(self
):
621 self
.assertEqual(self
._ft
.tag_name
, 'path.to.tag')
623 def test_create_invalid_tag_name(self
):
624 with self
.assertRaises(TypeError):
625 self
._ft
= bt2
.VariantFieldType(23)
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')
631 def test_assign_invalid_tag_name(self
):
632 with self
.assertRaises(TypeError):
633 self
._ft
.tag_name
= -17
636 class ArrayFieldTypeTestCase(_TestInvalidEq
, _TestCopySimple
,
639 self
._elem
_ft
= bt2
.IntegerFieldType(23)
640 self
._ft
= bt2
.ArrayFieldType(self
._elem
_ft
, 45)
646 def test_create_default(self
):
647 self
.assertEqual(self
._ft
.element_field_type
, self
._elem
_ft
)
648 self
.assertEqual(self
._ft
.length
, 45)
650 def test_create_invalid_field_type(self
):
651 with self
.assertRaises(TypeError):
652 self
._ft
= bt2
.ArrayFieldType(object(), 45)
654 def test_create_invalid_length(self
):
655 with self
.assertRaises(ValueError):
656 self
._ft
= bt2
.ArrayFieldType(bt2
.StringFieldType(), -17)
658 def test_create_invalid_length_type(self
):
659 with self
.assertRaises(TypeError):
660 self
._ft
= bt2
.ArrayFieldType(bt2
.StringFieldType(), 'the length')
662 def test_create_field(self
):
664 self
.assertIsInstance(field
, bt2
.fields
._ArrayField
)
666 def test_create_field_init_invalid(self
):
667 with self
.assertRaises(bt2
.Error
):
671 class SequenceFieldTypeTestCase(_TestInvalidEq
, _TestCopySimple
,
674 self
._elem
_ft
= bt2
.IntegerFieldType(23)
675 self
._ft
= bt2
.SequenceFieldType(self
._elem
_ft
, 'the.length')
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')
685 def test_create_invalid_field_type(self
):
686 with self
.assertRaises(TypeError):
687 self
._ft
= bt2
.ArrayFieldType(object(), 'the.length')
689 def test_create_invalid_length_type(self
):
690 with self
.assertRaises(TypeError):
691 self
._ft
= bt2
.SequenceFieldType(bt2
.StringFieldType(), 17)
693 def test_create_field(self
):
695 self
.assertIsInstance(field
, bt2
.fields
._SequenceField
)
697 def test_create_field_init_invalid(self
):
698 with self
.assertRaises(bt2
.Error
):