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')
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)
91 def test_create_default(self
):
92 self
.assertEqual(self
._ft
.size
, 35)
94 def test_create_invalid_size(self
):
95 with self
.assertRaises(TypeError):
96 ft
= bt2
.IntegerFieldType('yes')
98 def test_create_neg_size(self
):
99 with self
.assertRaises(ValueError):
100 ft
= bt2
.IntegerFieldType(-2)
102 def test_create_neg_zero(self
):
103 with self
.assertRaises(ValueError):
104 ft
= bt2
.IntegerFieldType(0)
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
)
121 def test_create_field(self
):
123 self
.assertIsInstance(field
, bt2
.fields
._IntegerField
)
125 def test_create_field_init(self
):
127 self
.assertEqual(field
, 23)
130 class FloatingPointNumberFieldTypeTestCase(_TestCopySimple
, _TestAlignmentProp
,
131 _TestByteOrderProp
, _TestInvalidEq
,
134 self
._ft
= bt2
.FloatingPointNumberFieldType()
136 def test_create_default(self
):
139 def test_create_full(self
):
140 ft
= bt2
.FloatingPointNumberFieldType(alignment
=16,
141 byte_order
=bt2
.ByteOrder
.BIG_ENDIAN
,
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)
149 def test_assign_exponent_size(self
):
150 self
._ft
.exponent_size
= 8
151 self
.assertEqual(self
._ft
.exponent_size
, 8)
153 def test_assign_invalid_exponent_size(self
):
154 with self
.assertRaises(TypeError):
155 self
._ft
.exponent_size
= 'yes'
157 def test_assign_mantissa_size(self
):
158 self
._ft
.mantissa_size
= 24
159 self
.assertEqual(self
._ft
.mantissa_size
, 24)
161 def test_assign_invalid_mantissa_size(self
):
162 with self
.assertRaises(TypeError):
163 self
._ft
.mantissa_size
= 'no'
165 def test_create_field(self
):
167 self
.assertIsInstance(field
, bt2
.fields
._FloatingPointNumberField
)
169 def test_create_field_init(self
):
170 field
= self
._ft
(17.5)
171 self
.assertEqual(field
, 17.5)
174 class EnumerationFieldTypeTestCase(_TestIntegerFieldTypeProps
, _TestInvalidEq
,
175 _TestCopySimple
, _TestAlignmentProp
,
176 _TestByteOrderProp
, unittest
.TestCase
):
178 self
._ft
= bt2
.EnumerationFieldType(size
=35)
180 def test_create_from_int_ft(self
):
181 int_ft
= bt2
.IntegerFieldType(23)
182 self
._ft
= bt2
.EnumerationFieldType(int_ft
)
184 def test_create_from_invalid_type(self
):
185 with self
.assertRaises(TypeError):
186 self
._ft
= bt2
.EnumerationFieldType('coucou')
188 def test_create_from_invalid_ft(self
):
189 with self
.assertRaises(TypeError):
190 ft
= bt2
.FloatingPointNumberFieldType()
191 self
._ft
= bt2
.EnumerationFieldType(ft
)
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)
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
)
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)
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)
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)
233 def test_append_mapping_invalid_name(self
):
234 with self
.assertRaises(TypeError):
235 self
._ft
.append_mapping(17, 21, 199)
237 def test_append_mapping_invalid_signedness_lower(self
):
238 with self
.assertRaises(ValueError):
239 self
._ft
.append_mapping('hello', -21, 199)
241 def test_append_mapping_invalid_signedness_upper(self
):
242 with self
.assertRaises(ValueError):
243 self
._ft
.append_mapping('hello', 21, -199)
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)
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)
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)
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)
285 def test_bool_op(self
):
286 self
.assertFalse(self
._ft
)
287 self
._ft
.append_mapping('a', 0)
288 self
.assertTrue(self
._ft
)
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)
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)
313 for mapping
in mappings
:
314 self
._ft
.append_mapping(*mapping
)
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])
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])
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)
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
)
346 for mapping
in mappings
:
348 self
.assertEqual(mapping
.name
, 'a')
350 if mapping
.lower
== 0 and mapping
.upper
== 0:
352 elif mapping
.lower
== 5 and mapping
.upper
== 5:
354 elif mapping
.lower
== 17 and mapping
.upper
== 144:
357 self
.assertEqual(i
, 3)
360 self
.assertTrue(a17_144
)
362 def test_find_by_name_signed(self
):
363 self
._test
_find
_by
_name
(bt2
.EnumerationFieldType(size
=8, is_signed
=True))
365 def test_find_by_name_unsigned(self
):
366 self
._test
_find
_by
_name
(bt2
.EnumerationFieldType(size
=8))
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
)
384 for mapping
in mappings
:
387 if mapping
.name
== 'c':
389 elif mapping
.name
== 'd':
391 elif mapping
.name
== 'e':
393 elif mapping
.name
== 'g':
396 self
.assertEqual(i
, 4)
402 def test_find_by_value_signed(self
):
403 self
._test
_find
_by
_value
(bt2
.EnumerationFieldType(size
=8, is_signed
=True))
405 def test_find_by_value_unsigned(self
):
406 self
._test
_find
_by
_value
(bt2
.EnumerationFieldType(size
=8))
408 def test_create_field(self
):
409 self
._ft
.append_mapping('c', 4, 5)
411 self
.assertIsInstance(field
, bt2
.fields
._EnumerationField
)
413 def test_create_field_init(self
):
414 self
._ft
.append_mapping('c', 4, 5)
416 self
.assertEqual(field
, 4)
419 class StringFieldTypeTestCase(_TestCopySimple
, _TestInvalidEq
,
422 self
._ft
= bt2
.StringFieldType()
424 def test_create_default(self
):
427 def test_create_full(self
):
428 ft
= bt2
.StringFieldType(encoding
=bt2
.Encoding
.UTF8
)
429 self
.assertEqual(ft
.encoding
, bt2
.Encoding
.UTF8
)
431 def test_assign_encoding(self
):
432 self
._ft
.encoding
= bt2
.Encoding
.UTF8
433 self
.assertEqual(self
._ft
.encoding
, bt2
.Encoding
.UTF8
)
435 def test_assign_invalid_encoding(self
):
436 with self
.assertRaises(TypeError):
437 self
._ft
.encoding
= 'yes'
439 def test_create_field(self
):
441 self
.assertIsInstance(field
, bt2
.fields
._StringField
)
443 def test_create_field_init(self
):
444 field
= self
._ft
('hola')
445 self
.assertEqual(field
, 'hola')
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
)
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
)
461 def test_append_field_invalid_name(self
):
462 with self
.assertRaises(TypeError):
463 self
._ft
.append_field(23, bt2
.StringFieldType())
465 def test_append_field_invalid_field_type(self
):
466 with self
.assertRaises(TypeError):
467 self
._ft
.append_field('yes', object())
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
)
488 def test_bool_op(self
):
489 self
.assertFalse(self
._ft
)
490 self
._ft
.append_field('a', bt2
.StringFieldType())
491 self
.assertTrue(self
._ft
)
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)
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
)
509 def test_getitem_invalid_key_type(self
):
510 with self
.assertRaises(TypeError):
513 def test_getitem_invalid_key(self
):
514 with self
.assertRaises(KeyError):
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
)
523 a_ft
= bt2
.IntegerFieldType(32)
524 b_ft
= bt2
.StringFieldType()
525 c_ft
= bt2
.FloatingPointNumberFieldType()
533 self
._ft
.append_field(*field
)
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])
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
)
548 def test_at_index_invalid(self
):
549 self
._ft
.append_field('c', bt2
.IntegerFieldType(32))
551 with self
.assertRaises(TypeError):
552 self
._ft
.at_index('yes')
555 class StructureFieldTypeTestCase(_TestFieldContainer
, unittest
.TestCase
):
557 self
._ft
= bt2
.StructureFieldType()
559 def test_create_default(self
):
560 self
.assertEqual(self
._ft
.alignment
, 1)
562 def test_create_with_min_alignment(self
):
563 ft
= bt2
.StructureFieldType(8)
564 self
.assertEqual(ft
.alignment
, 8)
566 def test_assign_alignment(self
):
567 with self
.assertRaises(AttributeError):
568 self
._ft
.alignment
= 32
570 def test_assign_min_alignment(self
):
571 self
._ft
.min_alignment
= 64
572 self
.assertTrue(self
._ft
.alignment
>= 64)
574 def test_assign_invalid_min_alignment(self
):
575 with self
.assertRaises(ValueError):
576 self
._ft
.min_alignment
= 23
578 def test_assign_get_min_alignment(self
):
579 with self
.assertRaises(AttributeError):
580 self
._ft
.min_alignment
582 def test_create_field(self
):
584 self
.assertIsInstance(field
, bt2
.fields
._StructureField
)
586 def test_create_field_init_invalid(self
):
587 with self
.assertRaises(bt2
.Error
):
591 class VariantFieldTypeTestCase(_TestFieldContainer
, unittest
.TestCase
):
593 self
._ft
= bt2
.VariantFieldType('path.to.tag')
595 def test_create_default(self
):
596 self
.assertEqual(self
._ft
.tag_name
, 'path.to.tag')
598 def test_create_invalid_tag_name(self
):
599 with self
.assertRaises(TypeError):
600 self
._ft
= bt2
.VariantFieldType(23)
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')
606 def test_assign_invalid_tag_name(self
):
607 with self
.assertRaises(TypeError):
608 self
._ft
.tag_name
= -17
611 class ArrayFieldTypeTestCase(_TestInvalidEq
, _TestCopySimple
,
614 self
._elem
_ft
= bt2
.IntegerFieldType(23)
615 self
._ft
= bt2
.ArrayFieldType(self
._elem
_ft
, 45)
617 def test_create_default(self
):
618 self
.assertEqual(self
._ft
.element_field_type
, self
._elem
_ft
)
619 self
.assertEqual(self
._ft
.length
, 45)
621 def test_create_invalid_field_type(self
):
622 with self
.assertRaises(TypeError):
623 self
._ft
= bt2
.ArrayFieldType(object(), 45)
625 def test_create_invalid_length(self
):
626 with self
.assertRaises(ValueError):
627 self
._ft
= bt2
.ArrayFieldType(bt2
.StringFieldType(), -17)
629 def test_create_invalid_length_type(self
):
630 with self
.assertRaises(TypeError):
631 self
._ft
= bt2
.ArrayFieldType(bt2
.StringFieldType(), 'the length')
633 def test_create_field(self
):
635 self
.assertIsInstance(field
, bt2
.fields
._ArrayField
)
637 def test_create_field_init_invalid(self
):
638 with self
.assertRaises(bt2
.Error
):
642 class SequenceFieldTypeTestCase(_TestInvalidEq
, _TestCopySimple
,
645 self
._elem
_ft
= bt2
.IntegerFieldType(23)
646 self
._ft
= bt2
.SequenceFieldType(self
._elem
_ft
, 'the.length')
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')
652 def test_create_invalid_field_type(self
):
653 with self
.assertRaises(TypeError):
654 self
._ft
= bt2
.ArrayFieldType(object(), 'the.length')
656 def test_create_invalid_length_type(self
):
657 with self
.assertRaises(TypeError):
658 self
._ft
= bt2
.SequenceFieldType(bt2
.StringFieldType(), 17)
660 def test_create_field(self
):
662 self
.assertIsInstance(field
, bt2
.fields
._SequenceField
)
664 def test_create_field_init_invalid(self
):
665 with self
.assertRaises(bt2
.Error
):