1 # SPDX-License-Identifier: GPL-2.0-only
3 # Copyright (C) 2019 EfficiOS Inc.
9 from bt2
import value
as bt2_value
10 from bt2
import field_class
as bt2_field_class
11 from utils
import TestOutputPortMessageIterator
, get_default_trace_class
14 def _create_stream(tc
, ctx_field_classes
):
15 packet_context_fc
= tc
.create_structure_field_class()
16 for name
, fc
in ctx_field_classes
:
17 packet_context_fc
.append_member(name
, fc
)
20 stream_class
= tc
.create_stream_class(
21 packet_context_field_class
=packet_context_fc
, supports_packets
=True
24 stream
= trace
.create_stream(stream_class
)
28 def _create_const_field_class(tc
, field_class
, value_setter_fn
):
29 field_name
= "const field"
31 class MyIter(bt2
._UserMessageIterator
):
32 def __init__(self
, config
, self_port_output
):
34 nonlocal value_setter_fn
35 stream
= _create_stream(tc
, [(field_name
, field_class
)])
36 packet
= stream
.create_packet()
38 value_setter_fn(packet
.context_field
[field_name
])
41 self
._create
_stream
_beginning
_message
(stream
),
42 self
._create
_packet
_beginning
_message
(packet
),
46 if len(self
._msgs
) == 0:
49 return self
._msgs
.pop(0)
51 class MySrc(bt2
._UserSourceComponent
, message_iterator_class
=MyIter
):
52 def __init__(self
, config
, params
, obj
):
53 self
._add
_output
_port
("out", params
)
56 src_comp
= graph
.add_component(MySrc
, "my_source", None)
57 msg_iter
= TestOutputPortMessageIterator(graph
, src_comp
.output_ports
["out"])
59 # Ignore first message, stream beginning
61 packet_beg_msg
= next(msg_iter
)
63 return packet_beg_msg
.packet
.context_field
[field_name
].cls
66 class _TestFieldClass
:
67 def test_create_user_attributes(self
):
68 fc
= self
._create
_default
_field
_class
(user_attributes
={"salut": 23})
69 self
.assertEqual(fc
.user_attributes
, {"salut": 23})
70 self
.assertIs(type(fc
.user_attributes
), bt2_value
.MapValue
)
72 def test_const_create_user_attributes(self
):
73 fc
= self
._create
_default
_const
_field
_class
(user_attributes
={"salut": 23})
74 self
.assertEqual(fc
.user_attributes
, {"salut": 23})
75 self
.assertIs(type(fc
.user_attributes
), bt2_value
._MapValueConst
)
77 def test_create_invalid_user_attributes(self
):
78 with self
.assertRaises(TypeError):
79 self
._create
_default
_field
_class
(user_attributes
=object())
81 def test_create_invalid_user_attributes_value_type(self
):
82 with self
.assertRaises(TypeError):
83 self
._create
_default
_field
_class
(user_attributes
=23)
86 class BoolFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
88 def _const_value_setter(field
):
91 def _create_default_field_class(self
, **kwargs
):
92 tc
= get_default_trace_class()
93 return tc
.create_bool_field_class(**kwargs
)
95 def _create_default_const_field_class(self
, *args
, **kwargs
):
96 tc
= get_default_trace_class()
97 fc
= tc
.create_bool_field_class(*args
, **kwargs
)
98 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
101 self
._fc
= self
._create
_default
_field
_class
()
102 self
._fc
_const
= self
._create
_default
_const
_field
_class
()
104 def test_create_default(self
):
105 self
.assertIsNotNone(self
._fc
)
106 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
109 class BitArrayFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
111 def _const_value_setter(field
):
114 def _create_field_class(self
, *args
, **kwargs
):
115 tc
= get_default_trace_class()
116 return tc
.create_bit_array_field_class(*args
, **kwargs
)
118 def _create_default_field_class(self
, **kwargs
):
119 return self
._create
_field
_class
(17, **kwargs
)
121 def _create_default_const_field_class(self
, *args
, **kwargs
):
122 tc
= get_default_trace_class()
123 fc
= tc
.create_bit_array_field_class(17, **kwargs
)
124 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
127 self
._fc
= self
._create
_default
_field
_class
()
129 def test_create_default(self
):
130 self
.assertIsNotNone(self
._fc
)
131 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
133 def test_create_length_out_of_range(self
):
134 with self
.assertRaises(ValueError):
135 self
._create
_field
_class
(65)
137 def test_create_length_zero(self
):
138 with self
.assertRaises(ValueError):
139 self
._create
_field
_class
(0)
141 def test_create_length_invalid_type(self
):
142 with self
.assertRaises(TypeError):
143 self
._create
_field
_class
("lel")
145 def test_length_prop(self
):
146 self
.assertEqual(self
._fc
.length
, 17)
149 class _TestIntegerFieldClassProps
:
150 def test_create_default(self
):
151 fc
= self
._create
_default
_field
_class
()
152 self
.assertEqual(fc
.field_value_range
, 64)
153 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.DECIMAL
)
154 self
.assertEqual(len(fc
.user_attributes
), 0)
156 def test_create_range(self
):
157 fc
= self
._create
_field
_class
(field_value_range
=35)
158 self
.assertEqual(fc
.field_value_range
, 35)
160 fc
= self
._create
_field
_class
(36)
161 self
.assertEqual(fc
.field_value_range
, 36)
163 def test_create_invalid_range(self
):
164 with self
.assertRaises(TypeError):
165 self
._create
_field
_class
("yes")
167 with self
.assertRaises(TypeError):
168 self
._create
_field
_class
(field_value_range
="yes")
170 with self
.assertRaises(ValueError):
171 self
._create
_field
_class
(field_value_range
=-2)
173 with self
.assertRaises(ValueError):
174 self
._create
_field
_class
(field_value_range
=0)
176 def test_create_base(self
):
177 fc
= self
._create
_field
_class
(
178 preferred_display_base
=bt2
.IntegerDisplayBase
.HEXADECIMAL
180 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.HEXADECIMAL
)
182 def test_create_invalid_base_type(self
):
183 with self
.assertRaises(TypeError):
184 self
._create
_field
_class
(preferred_display_base
="yes")
186 def test_create_invalid_base_value(self
):
187 with self
.assertRaises(ValueError):
188 self
._create
_field
_class
(preferred_display_base
=444)
190 def test_create_full(self
):
191 fc
= self
._create
_field
_class
(
192 24, preferred_display_base
=bt2
.IntegerDisplayBase
.OCTAL
194 self
.assertEqual(fc
.field_value_range
, 24)
195 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.OCTAL
)
198 class SignedIntegerFieldClassTestCase(
199 _TestIntegerFieldClassProps
, _TestFieldClass
, unittest
.TestCase
202 def _const_value_setter(field
):
205 def _create_field_class(self
, *args
, **kwargs
):
206 tc
= get_default_trace_class()
207 return tc
.create_signed_integer_field_class(*args
, **kwargs
)
209 def _create_default_const_field_class(self
, *args
, **kwargs
):
210 tc
= get_default_trace_class()
211 fc
= tc
.create_signed_integer_field_class(*args
, **kwargs
)
212 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
214 _create_default_field_class
= _create_field_class
217 class UnsignedIntegerFieldClassTestCase(
218 _TestIntegerFieldClassProps
, _TestFieldClass
, unittest
.TestCase
221 def _const_value_setter(field
):
224 def _create_field_class(self
, *args
, **kwargs
):
225 tc
= get_default_trace_class()
226 return tc
.create_unsigned_integer_field_class(*args
, **kwargs
)
228 def _create_default_const_field_class(self
, *args
, **kwargs
):
229 tc
= get_default_trace_class()
230 fc
= tc
.create_signed_integer_field_class(*args
, **kwargs
)
231 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
233 _create_default_field_class
= _create_field_class
236 class SingleRealFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
238 def _const_value_setter(field
):
241 def _create_field_class(self
, *args
, **kwargs
):
242 tc
= get_default_trace_class()
243 return tc
.create_single_precision_real_field_class(*args
, **kwargs
)
245 def _create_default_const_field_class(self
, *args
, **kwargs
):
246 tc
= get_default_trace_class()
247 fc
= tc
.create_single_precision_real_field_class(*args
, **kwargs
)
248 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
250 _create_default_field_class
= _create_field_class
252 def test_create_default(self
):
253 fc
= self
._create
_field
_class
()
254 self
.assertEqual(len(fc
.user_attributes
), 0)
257 class DoubleRealFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
259 def _const_value_setter(field
):
262 def _create_field_class(self
, *args
, **kwargs
):
263 tc
= get_default_trace_class()
264 return tc
.create_double_precision_real_field_class(*args
, **kwargs
)
266 def _create_default_const_field_class(self
, *args
, **kwargs
):
267 tc
= get_default_trace_class()
268 fc
= tc
.create_double_precision_real_field_class(*args
, **kwargs
)
269 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
271 _create_default_field_class
= _create_field_class
273 def test_create_default(self
):
274 fc
= self
._create
_field
_class
()
275 self
.assertEqual(len(fc
.user_attributes
), 0)
278 # Converts an _EnumerationFieldClassMapping to a list of ranges:
280 # [(lower0, upper0), (lower1, upper1), ...]
283 def enum_mapping_to_set(mapping
):
284 return {(x
.lower
, x
.upper
) for x
in mapping
.ranges
}
287 class _EnumerationFieldClassTestCase(_TestIntegerFieldClassProps
):
290 self
._fc
= self
._create
_default
_field
_class
()
291 self
._fc
_const
= self
._create
_default
_const
_field
_class
()
293 def test_create_from_invalid_type(self
):
294 with self
.assertRaises(TypeError):
295 self
._create
_field
_class
("coucou")
297 def test_add_mapping_simple(self
):
298 self
._fc
.add_mapping("hello", self
._ranges
1)
299 mapping
= self
._fc
["hello"]
300 self
.assertEqual(mapping
.label
, "hello")
301 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
303 def test_const_add_mapping(self
):
304 with self
.assertRaises(AttributeError):
305 self
._fc
_const
.add_mapping("hello", self
._ranges
1)
307 def test_add_mapping_simple_kwargs(self
):
308 self
._fc
.add_mapping(label
="hello", ranges
=self
._ranges
1)
309 mapping
= self
._fc
["hello"]
310 self
.assertEqual(mapping
.label
, "hello")
311 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
313 def test_add_mapping_invalid_name(self
):
314 with self
.assertRaises(TypeError):
315 self
._fc
.add_mapping(17, self
._ranges
1)
317 def test_add_mapping_invalid_range(self
):
318 with self
.assertRaises(TypeError):
319 self
._fc
.add_mapping("allo", "meow")
321 def test_add_mapping_dup_label(self
):
322 with self
.assertRaises(ValueError):
323 self
._fc
.add_mapping("a", self
._ranges
1)
324 self
._fc
.add_mapping("a", self
._ranges
2)
326 def test_add_mapping_invalid_ranges_signedness(self
):
327 with self
.assertRaises(TypeError):
328 self
._fc
.add_mapping("allo", self
._inval
_ranges
)
331 self
._fc
.add_mapping("c", self
._ranges
1)
333 self
._fc
+= [("d", self
._ranges
2), ("e", self
._ranges
3)]
335 self
.assertEqual(len(self
._fc
), 3)
336 self
.assertEqual(self
._fc
["c"].label
, "c")
337 self
.assertEqual(self
._fc
["c"].ranges
, self
._ranges
1)
338 self
.assertEqual(self
._fc
["d"].label
, "d")
339 self
.assertEqual(self
._fc
["d"].ranges
, self
._ranges
2)
340 self
.assertEqual(self
._fc
["e"].label
, "e")
341 self
.assertEqual(self
._fc
["e"].ranges
, self
._ranges
3)
343 def test_const_iadd(self
):
344 with self
.assertRaises(TypeError):
345 self
._fc
_const
+= [("d", self
._ranges
2), ("e", self
._ranges
3)]
347 def test_bool_op(self
):
348 self
.assertFalse(self
._fc
)
349 self
._fc
.add_mapping("a", self
._ranges
1)
350 self
.assertTrue(self
._fc
)
353 self
._fc
.add_mapping("a", self
._ranges
1)
354 self
._fc
.add_mapping("b", self
._ranges
2)
355 self
._fc
.add_mapping("c", self
._ranges
3)
356 self
.assertEqual(len(self
._fc
), 3)
358 def test_getitem(self
):
359 self
._fc
.add_mapping("a", self
._ranges
1)
360 self
._fc
.add_mapping("b", self
._ranges
2)
361 self
._fc
.add_mapping("c", self
._ranges
3)
362 mapping
= self
._fc
["a"]
363 self
.assertEqual(mapping
.label
, "a")
364 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
365 self
.assertIs(type(mapping
), self
._MAPPING
_CLASS
)
366 self
.assertIs(type(mapping
.ranges
), self
._CONST
_RANGE
_SET
_CLASS
)
368 def test_getitem_nonexistent(self
):
369 with self
.assertRaises(KeyError):
370 self
._fc
["doesnotexist"]
373 self
._fc
.add_mapping("a", self
._ranges
1)
374 self
._fc
.add_mapping("b", self
._ranges
2)
375 self
._fc
.add_mapping("c", self
._ranges
3)
377 # This exercises iteration.
378 labels
= sorted(self
._fc
)
380 self
.assertEqual(labels
, ["a", "b", "c"])
382 def test_find_by_value(self
):
383 self
._fc
.add_mapping("a", self
._ranges
1)
384 self
._fc
.add_mapping("b", self
._ranges
2)
385 self
._fc
.add_mapping("c", self
._ranges
3)
386 mappings
= self
._fc
.mappings_for_value(self
._value
_in
_range
_1_and
_3)
387 labels
= set([mapping
.label
for mapping
in mappings
])
388 expected_labels
= set(["a", "c"])
389 self
.assertEqual(labels
, expected_labels
)
392 class UnsignedEnumerationFieldClassTestCase(
393 _EnumerationFieldClassTestCase
, _TestFieldClass
, unittest
.TestCase
395 _MAPPING_CLASS
= bt2_field_class
._UnsignedEnumerationFieldClassMappingConst
396 _RANGE_SET_CLASS
= bt2
.UnsignedIntegerRangeSet
397 _CONST_RANGE_SET_CLASS
= bt2
._UnsignedIntegerRangeSetConst
399 def _spec_set_up(self
):
400 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
401 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
402 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 22), (48, 99)])
403 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, -5), (48, 1928)])
404 self
._value
_in
_range
_1_and
_3 = 20
407 def _const_value_setter(field
):
410 def _create_field_class(self
, *args
, **kwargs
):
411 tc
= get_default_trace_class()
412 return tc
.create_unsigned_enumeration_field_class(*args
, **kwargs
)
414 def _create_default_const_field_class(self
, *args
, **kwargs
):
415 tc
= get_default_trace_class()
416 fc
= tc
.create_unsigned_enumeration_field_class(*args
, **kwargs
)
417 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
419 _create_default_field_class
= _create_field_class
422 class SignedEnumerationFieldClassTestCase(
423 _EnumerationFieldClassTestCase
, _TestFieldClass
, unittest
.TestCase
425 _MAPPING_CLASS
= bt2_field_class
._SignedEnumerationFieldClassMappingConst
426 _RANGE_SET_CLASS
= bt2
.SignedIntegerRangeSet
427 _CONST_RANGE_SET_CLASS
= bt2
._SignedIntegerRangeSetConst
429 def _spec_set_up(self
):
430 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
431 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
432 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(-100, -1), (8, 16), (48, 99)])
433 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
434 self
._value
_in
_range
_1_and
_3 = -7
437 def _const_value_setter(field
):
440 def _create_field_class(self
, *args
, **kwargs
):
441 tc
= get_default_trace_class()
442 return tc
.create_signed_enumeration_field_class(*args
, **kwargs
)
444 def _create_default_const_field_class(self
, *args
, **kwargs
):
445 tc
= get_default_trace_class()
446 fc
= tc
.create_signed_enumeration_field_class(*args
, **kwargs
)
447 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
449 _create_default_field_class
= _create_field_class
452 class StringFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
454 def _const_value_setter(field
):
455 field
.value
= "chaine"
457 def _create_field_class(self
, *args
, **kwargs
):
458 tc
= get_default_trace_class()
459 return tc
.create_string_field_class(*args
, **kwargs
)
461 def _create_default_const_field_class(self
, *args
, **kwargs
):
462 tc
= get_default_trace_class()
463 fc
= tc
.create_string_field_class(*args
, **kwargs
)
464 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
466 _create_default_field_class
= _create_field_class
469 self
._fc
= self
._create
_default
_field
_class
()
471 def test_create_default(self
):
472 self
.assertIsNotNone(self
._fc
)
473 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
476 class _TestElementContainer
:
478 self
._tc
= get_default_trace_class()
479 self
._fc
= self
._create
_default
_field
_class
()
480 self
._fc
_const
= self
._create
_default
_const
_field
_class
()
482 def test_create_default(self
):
483 self
.assertIsNotNone(self
._fc
)
484 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
486 def test_append_element(self
):
487 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
488 self
._append
_element
_method
(self
._fc
, "int32", int_field_class
)
489 field_class
= self
._fc
["int32"].field_class
490 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
492 def test_append_element_kwargs(self
):
493 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
494 self
._append
_element
_method
(self
._fc
, name
="int32", field_class
=int_field_class
)
495 field_class
= self
._fc
["int32"].field_class
496 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
498 def test_append_element_invalid_name(self
):
499 sub_fc
= self
._tc
.create_string_field_class()
501 with self
.assertRaises(TypeError):
502 self
._append
_element
_method
(self
._fc
, 23, sub_fc
)
504 def test_append_element_invalid_field_class(self
):
505 with self
.assertRaises(TypeError):
506 self
._append
_element
_method
(self
._fc
, "yes", object())
508 def test_append_element_dup_name(self
):
509 sub_fc1
= self
._tc
.create_string_field_class()
510 sub_fc2
= self
._tc
.create_string_field_class()
512 with self
.assertRaises(ValueError):
513 self
._append
_element
_method
(self
._fc
, "yes", sub_fc1
)
514 self
._append
_element
_method
(self
._fc
, "yes", sub_fc2
)
516 def test_attr_field_class(self
):
517 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
518 self
._append
_element
_method
(self
._fc
, "int32", int_field_class
)
519 field_class
= self
._fc
["int32"].field_class
521 self
.assertIs(type(field_class
), bt2_field_class
._SignedIntegerFieldClass
)
523 def test_const_attr_field_class(self
):
524 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
525 self
._append
_element
_method
(self
._fc
, "int32", int_field_class
)
526 field_class
= self
._fc
["int32"].field_class
527 const_fc
= _create_const_field_class(
528 self
._tc
, self
._fc
, self
._const
_value
_setter
530 field_class
= const_fc
["int32"].field_class
532 self
.assertIs(type(field_class
), bt2_field_class
._SignedIntegerFieldClassConst
)
535 a_field_class
= self
._tc
.create_single_precision_real_field_class()
536 b_field_class
= self
._tc
.create_signed_integer_field_class(17)
537 self
._append
_element
_method
(self
._fc
, "a_float", a_field_class
)
538 self
._append
_element
_method
(self
._fc
, "b_int", b_field_class
)
539 c_field_class
= self
._tc
.create_string_field_class()
540 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
543 e_field_class
= self
._tc
.create_structure_field_class()
545 ("c_string", c_field_class
),
546 ("d_enum", d_field_class
),
547 ("e_struct", e_field_class
),
549 self
.assertEqual(self
._fc
["a_float"].field_class
.addr
, a_field_class
.addr
)
550 self
.assertEqual(self
._fc
["a_float"].name
, "a_float")
551 self
.assertEqual(self
._fc
["b_int"].field_class
.addr
, b_field_class
.addr
)
552 self
.assertEqual(self
._fc
["b_int"].name
, "b_int")
553 self
.assertEqual(self
._fc
["c_string"].field_class
.addr
, c_field_class
.addr
)
554 self
.assertEqual(self
._fc
["c_string"].name
, "c_string")
555 self
.assertEqual(self
._fc
["d_enum"].field_class
.addr
, d_field_class
.addr
)
556 self
.assertEqual(self
._fc
["d_enum"].name
, "d_enum")
557 self
.assertEqual(self
._fc
["e_struct"].field_class
.addr
, e_field_class
.addr
)
558 self
.assertEqual(self
._fc
["e_struct"].name
, "e_struct")
560 def test_const_iadd(self
):
561 a_field_class
= self
._tc
.create_single_precision_real_field_class()
562 with self
.assertRaises(TypeError):
563 self
._fc
_const
+= a_field_class
565 def test_bool_op(self
):
566 self
.assertFalse(self
._fc
)
567 self
._append
_element
_method
(self
._fc
, "a", self
._tc
.create_string_field_class())
568 self
.assertTrue(self
._fc
)
571 self
._append
_element
_method
(self
._fc
, "a", self
._tc
.create_string_field_class())
572 self
._append
_element
_method
(self
._fc
, "b", self
._tc
.create_string_field_class())
573 self
._append
_element
_method
(self
._fc
, "c", self
._tc
.create_string_field_class())
574 self
.assertEqual(len(self
._fc
), 3)
576 def test_getitem(self
):
577 a_fc
= self
._tc
.create_signed_integer_field_class(32)
578 b_fc
= self
._tc
.create_string_field_class()
579 c_fc
= self
._tc
.create_single_precision_real_field_class()
580 self
._append
_element
_method
(self
._fc
, "a", a_fc
)
581 self
._append
_element
_method
(self
._fc
, "b", b_fc
)
582 self
._append
_element
_method
(self
._fc
, "c", c_fc
)
583 self
.assertEqual(self
._fc
["b"].field_class
.addr
, b_fc
.addr
)
584 self
.assertEqual(self
._fc
["b"].name
, "b")
586 def test_getitem_invalid_key_type(self
):
587 with self
.assertRaises(TypeError):
590 def test_getitem_invalid_key(self
):
591 with self
.assertRaises(KeyError):
594 def test_contains(self
):
595 self
.assertFalse("a" in self
._fc
)
596 self
._append
_element
_method
(self
._fc
, "a", self
._tc
.create_string_field_class())
597 self
.assertTrue("a" in self
._fc
)
600 a_fc
= self
._tc
.create_signed_integer_field_class(32)
601 b_fc
= self
._tc
.create_string_field_class()
602 c_fc
= self
._tc
.create_single_precision_real_field_class()
603 elements
= (("a", a_fc
), ("b", b_fc
), ("c", c_fc
))
605 for elem
in elements
:
606 self
._append
_element
_method
(self
._fc
, *elem
)
608 for (name
, element
), test_elem
in zip(self
._fc
.items(), elements
):
609 self
.assertEqual(element
.name
, test_elem
[0])
610 self
.assertEqual(name
, element
.name
)
611 self
.assertEqual(element
.field_class
.addr
, test_elem
[1].addr
)
612 self
.assertEqual(len(element
.user_attributes
), 0)
614 def test_at_index(self
):
615 a_fc
= self
._tc
.create_signed_integer_field_class(32)
616 b_fc
= self
._tc
.create_string_field_class()
617 c_fc
= self
._tc
.create_single_precision_real_field_class()
618 self
._append
_element
_method
(self
._fc
, "c", c_fc
)
619 self
._append
_element
_method
(self
._fc
, "a", a_fc
)
620 self
._append
_element
_method
(self
._fc
, "b", b_fc
)
621 elem
= self
._at
_index
_method
(self
._fc
, 1)
622 self
.assertEqual(elem
.field_class
.addr
, a_fc
.addr
)
623 self
.assertEqual(elem
.name
, "a")
625 def test_at_index_invalid(self
):
626 self
._append
_element
_method
(
627 self
._fc
, "c", self
._tc
.create_signed_integer_field_class(32)
630 with self
.assertRaises(TypeError):
631 self
._at
_index
_method
(self
._fc
, "yes")
633 def test_at_index_out_of_bounds_after(self
):
634 self
._append
_element
_method
(
635 self
._fc
, "c", self
._tc
.create_signed_integer_field_class(32)
638 with self
.assertRaises(IndexError):
639 self
._at
_index
_method
(self
._fc
, len(self
._fc
))
641 def test_user_attributes(self
):
642 self
._append
_element
_method
(
645 self
._tc
.create_string_field_class(),
646 user_attributes
={"salut": 23},
648 self
.assertEqual(self
._fc
["c"].user_attributes
, {"salut": 23})
649 self
.assertIs(type(self
._fc
.user_attributes
), bt2_value
.MapValue
)
650 self
.assertIs(type(self
._fc
["c"].user_attributes
), bt2_value
.MapValue
)
652 def test_invalid_user_attributes(self
):
653 with self
.assertRaises(TypeError):
654 self
._append
_element
_method
(
657 self
._tc
.create_string_field_class(),
658 user_attributes
=object(),
661 def test_invalid_user_attributes_value_type(self
):
662 with self
.assertRaises(TypeError):
663 self
._append
_element
_method
(
664 self
._fc
, "c", self
._tc
.create_string_field_class(), user_attributes
=23
668 class StructureFieldClassTestCase(
669 _TestFieldClass
, _TestElementContainer
, unittest
.TestCase
671 _append_element_method
= staticmethod(bt2
._StructureFieldClass
.append_member
)
672 _at_index_method
= staticmethod(bt2
._StructureFieldClass
.member_at_index
)
675 def _const_value_setter(field
):
678 def _create_field_class(self
, *args
, **kwargs
):
679 tc
= get_default_trace_class()
680 return tc
.create_structure_field_class(*args
, **kwargs
)
682 def _create_default_const_field_class(self
, *args
, **kwargs
):
683 tc
= get_default_trace_class()
684 fc
= tc
.create_structure_field_class(*args
, **kwargs
)
685 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
687 _create_default_field_class
= _create_field_class
689 def test_const_member_field_class(self
):
690 def _real_value_setter(field
):
691 field
.value
= {"real": 0}
693 tc
= get_default_trace_class()
694 fc
= tc
.create_structure_field_class()
695 member_fc
= self
._tc
.create_single_precision_real_field_class()
696 fc
.append_member("real", member_fc
)
697 const_fc
= _create_const_field_class(tc
, fc
, _real_value_setter
)
700 type(const_fc
["real"].field_class
),
701 bt2_field_class
._SinglePrecisionRealFieldClassConst
,
704 def test_member_field_class(self
):
705 tc
= get_default_trace_class()
706 fc
= tc
.create_structure_field_class()
707 member_fc
= self
._tc
.create_single_precision_real_field_class()
708 fc
.append_member("real", member_fc
)
711 type(fc
["real"].field_class
), bt2_field_class
._SinglePrecisionRealFieldClass
715 class OptionWithoutSelectorFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
717 def _const_value_setter(field
):
718 field
.has_field
= True
721 def _create_default_field_class(self
, *args
, **kwargs
):
722 return self
._tc
.create_option_without_selector_field_class(
723 self
._content
_fc
, *args
, **kwargs
726 def _create_default_const_field_class(self
, *args
, **kwargs
):
727 fc
= self
._tc
.create_option_without_selector_field_class(
728 self
._content
_fc
, *args
, **kwargs
730 return _create_const_field_class(self
._tc
, fc
, self
._const
_value
_setter
)
733 self
._tc
= get_default_trace_class()
734 self
._content
_fc
= self
._tc
.create_signed_integer_field_class(23)
736 def test_create_default(self
):
737 fc
= self
._create
_default
_field
_class
()
738 self
.assertEqual(fc
.field_class
.addr
, self
._content
_fc
.addr
)
739 self
.assertEqual(len(fc
.user_attributes
), 0)
741 def test_create_invalid_field_class(self
):
742 with self
.assertRaises(TypeError):
743 self
._tc
.create_option_without_selector_field_class(object())
745 def test_attr_field_class(self
):
746 fc
= self
._create
_default
_field
_class
()
747 self
.assertIs(type(fc
.field_class
), bt2_field_class
._SignedIntegerFieldClass
)
749 def test_const_attr_field_class(self
):
750 fc
= self
._create
_default
_const
_field
_class
()
752 type(fc
.field_class
), bt2_field_class
._SignedIntegerFieldClassConst
756 class _OptionWithSelectorFieldClassTestCase(_TestFieldClass
):
758 def _const_value_setter(field
):
759 field
["opt"].has_field
= True
760 field
["opt"].value
= 12
762 def _create_default_const_field_class(self
, *args
, **kwargs
):
763 # Create a struct to contain the option and its selector else we can't
764 # create the non-const field necessary to get the the const field_class
765 struct_fc
= self
._tc
.create_structure_field_class()
766 struct_fc
.append_member("selecteux", self
._tag
_fc
)
767 opt_fc
= self
._create
_default
_field
_class
(*args
, **kwargs
)
768 struct_fc
.append_member("opt", opt_fc
)
770 return _create_const_field_class(self
._tc
, struct_fc
, self
._const
_value
_setter
)[
775 self
._tc
= get_default_trace_class()
776 self
._content
_fc
= self
._tc
.create_signed_integer_field_class(23)
777 self
._tag
_fc
= self
._create
_tag
_fc
()
779 def _create_field_class_for_field_path_test(self
):
780 fc
= self
._create
_default
_field
_class
()
782 foo_fc
= self
._tc
.create_single_precision_real_field_class()
783 bar_fc
= self
._tc
.create_string_field_class()
784 baz_fc
= self
._tc
.create_string_field_class()
786 inner_struct_fc
= self
._tc
.create_structure_field_class()
787 inner_struct_fc
.append_member("bar", bar_fc
)
788 inner_struct_fc
.append_member("baz", baz_fc
)
789 inner_struct_fc
.append_member("tag", self
._tag
_fc
)
790 inner_struct_fc
.append_member("opt", fc
)
792 opt_struct_array_fc
= self
._tc
.create_option_without_selector_field_class(
796 outer_struct_fc
= self
._tc
.create_structure_field_class()
797 outer_struct_fc
.append_member("foo", foo_fc
)
798 outer_struct_fc
.append_member("inner_opt", opt_struct_array_fc
)
800 # The path to the selector field class is resolved when the
801 # option field class is actually used, for example in a packet
803 self
._tc
.create_stream_class(
804 packet_context_field_class
=outer_struct_fc
, supports_packets
=True
809 def test_field_path_len(self
):
810 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
811 self
.assertEqual(len(fc
.selector_field_path
), 3)
813 def test_field_path_iter(self
):
814 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
815 path_items
= list(fc
.selector_field_path
)
817 self
.assertEqual(len(path_items
), 3)
819 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
820 self
.assertEqual(path_items
[0].index
, 1)
822 self
.assertIsInstance(path_items
[1], bt2
._CurrentOptionContentFieldPathItem
)
824 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
825 self
.assertEqual(path_items
[2].index
, 2)
827 def test_field_path_root_scope(self
):
828 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
830 fc
.selector_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
834 class OptionWithBoolSelectorFieldClassTestCase(
835 _OptionWithSelectorFieldClassTestCase
, unittest
.TestCase
837 def _create_default_field_class(self
, *args
, **kwargs
):
838 return self
._tc
.create_option_with_bool_selector_field_class(
839 self
._content
_fc
, self
._tag
_fc
, *args
, **kwargs
842 def _create_tag_fc(self
):
843 return self
._tc
.create_bool_field_class()
845 def test_create_default(self
):
846 fc
= self
._create
_default
_field
_class
()
847 self
.assertEqual(fc
.field_class
.addr
, self
._content
_fc
.addr
)
848 self
.assertFalse(fc
.selector_is_reversed
)
849 self
.assertEqual(len(fc
.user_attributes
), 0)
851 def test_create_selector_is_reversed_wrong_type(self
):
852 with self
.assertRaises(TypeError):
853 self
._create
_default
_field
_class
(selector_is_reversed
=23)
855 def test_create_invalid_selector_type(self
):
856 with self
.assertRaises(TypeError):
857 self
._tc
.create_option_with_bool_selector_field_class(self
._content
_fc
, 17)
859 def test_attr_selector_is_reversed(self
):
860 fc
= self
._create
_default
_field
_class
(selector_is_reversed
=True)
861 self
.assertTrue(fc
.selector_is_reversed
)
863 def test_const_attr_selector_is_reversed(self
):
864 fc
= self
._create
_default
_const
_field
_class
(selector_is_reversed
=True)
865 self
.assertTrue(fc
.selector_is_reversed
)
868 class _OptionWithIntegerSelectorFieldClassTestCase(
869 _OptionWithSelectorFieldClassTestCase
871 def _create_default_field_class(self
, *args
, **kwargs
):
872 return self
._tc
.create_option_with_integer_selector_field_class(
873 self
._content
_fc
, self
._tag
_fc
, self
._ranges
, *args
, **kwargs
876 def test_create_default(self
):
877 fc
= self
._create
_default
_field
_class
()
878 self
.assertEqual(fc
.field_class
.addr
, self
._content
_fc
.addr
)
879 self
.assertEqual(fc
.ranges
, self
._ranges
)
880 self
.assertEqual(len(fc
.user_attributes
), 0)
882 def test_create_ranges_wrong_type(self
):
883 with self
.assertRaises(TypeError):
884 self
._tc
.create_option_with_integer_selector_field_class(
885 self
._content
_fc
, self
._tag
_fc
, 23
888 def test_create_ranges_empty(self
):
889 with self
.assertRaises(ValueError):
890 self
._tc
.create_option_with_integer_selector_field_class(
891 self
._content
_fc
, self
._tag
_fc
, type(self
._ranges
)()
894 def test_create_invalid_selector_type(self
):
895 with self
.assertRaises(TypeError):
896 self
._tc
.create_option_with_bool_selector_field_class(self
._content
_fc
, 17)
898 def test_attr_ranges(self
):
899 fc
= self
._create
_default
_field
_class
()
900 self
.assertEqual(fc
.ranges
, self
._ranges
)
902 def test_const_attr_ranges(self
):
903 fc
= self
._create
_default
_const
_field
_class
()
904 self
.assertEqual(fc
.ranges
, self
._ranges
)
907 class OptionWithUnsignedIntegerSelectorFieldClassTestCase(
908 _OptionWithIntegerSelectorFieldClassTestCase
, unittest
.TestCase
911 self
._ranges
= bt2
.UnsignedIntegerRangeSet([(1, 3), (18, 44)])
914 def _create_tag_fc(self
):
915 return self
._tc
.create_unsigned_integer_field_class()
918 class VariantFieldClassWithoutSelectorTestCase(
919 _TestFieldClass
, _TestElementContainer
, unittest
.TestCase
921 _append_element_method
= staticmethod(
922 bt2
._VariantFieldClassWithoutSelector
.append_option
924 _at_index_method
= staticmethod(
925 bt2
._VariantFieldClassWithoutSelector
.option_at_index
929 def _const_value_setter(variant_field
):
930 variant_field
.selected_option_index
= 0
931 variant_field
.value
= 12
933 def _create_field_class(self
, *args
, **kwargs
):
934 tc
= get_default_trace_class()
935 return tc
.create_variant_field_class(*args
, **kwargs
)
937 def _create_default_const_field_class(self
, *args
, **kwargs
):
938 tc
= get_default_trace_class()
939 fc
= tc
.create_variant_field_class(*args
, **kwargs
)
940 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
941 fc
.append_option("int32", int_field_class
)
943 return _create_const_field_class(tc
, fc
, self
._const
_value
_setter
)
945 _create_default_field_class
= _create_field_class
948 class _VariantFieldClassWithIntegerSelectorTestCase
:
950 def _const_value_setter(field
):
951 field
["variant"].selected_option_index
= 0
952 field
["variant"] = 12
954 def _create_default_field_class(self
, *args
, **kwargs
):
955 return self
._tc
.create_variant_field_class(
956 *args
, selector_fc
=self
._selector
_fc
, **kwargs
959 def _create_default_const_field_class(self
, *args
, **kwargs
):
960 # Create a struct to contain the variant and its selector else we can't
961 # create the non-const field necessary to get the the const field_class
962 struct_fc
= self
._tc
.create_structure_field_class()
963 struct_fc
.append_member("selecteux", self
._selector
_fc
)
964 variant_fc
= self
._tc
.create_variant_field_class(
965 *args
, selector_fc
=self
._selector
_fc
967 variant_fc
.append_option(
968 "a", self
._tc
.create_signed_integer_field_class(32), self
._ranges
1
970 struct_fc
.append_member("variant", variant_fc
, **kwargs
)
972 return _create_const_field_class(self
._tc
, struct_fc
, self
._const
_value
_setter
)[
977 self
._tc
= get_default_trace_class()
979 self
._fc
= self
._create
_default
_field
_class
()
981 def test_create_default(self
):
982 self
.assertIsNotNone(self
._fc
)
983 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
985 def test_append_element(self
):
986 str_field_class
= self
._tc
.create_string_field_class()
987 self
._fc
.append_option("str", str_field_class
, self
._ranges
1)
988 opt
= self
._fc
["str"]
989 self
.assertEqual(opt
.field_class
.addr
, str_field_class
.addr
)
990 self
.assertEqual(opt
.name
, "str")
991 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
993 def test_const_append(self
):
994 fc_const
= self
._create
_default
_const
_field
_class
()
995 str_field_class
= self
._tc
.create_string_field_class()
996 with self
.assertRaises(AttributeError):
997 fc_const
.append_option("str", str_field_class
, self
._ranges
1)
999 def test_append_element_kwargs(self
):
1000 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
1001 self
._fc
.append_option(
1002 name
="int32", field_class
=int_field_class
, ranges
=self
._ranges
1
1004 opt
= self
._fc
["int32"]
1005 self
.assertEqual(opt
.field_class
.addr
, int_field_class
.addr
)
1006 self
.assertEqual(opt
.name
, "int32")
1007 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
1009 def test_append_element_invalid_name(self
):
1010 sub_fc
= self
._tc
.create_string_field_class()
1012 with self
.assertRaises(TypeError):
1013 self
._fc
.append_option(self
._fc
, 23, sub_fc
)
1015 def test_append_element_invalid_field_class(self
):
1016 with self
.assertRaises(TypeError):
1017 self
._fc
.append_option(self
._fc
, "yes", object())
1019 def test_append_element_invalid_ranges(self
):
1020 sub_fc
= self
._tc
.create_string_field_class()
1022 with self
.assertRaises(TypeError):
1023 self
._fc
.append_option(self
._fc
, sub_fc
, "lel")
1025 def test_append_element_dup_name(self
):
1026 sub_fc1
= self
._tc
.create_string_field_class()
1027 sub_fc2
= self
._tc
.create_string_field_class()
1029 with self
.assertRaises(ValueError):
1030 self
._fc
.append_option("yes", sub_fc1
, self
._ranges
1)
1031 self
._fc
.append_option("yes", sub_fc2
, self
._ranges
2)
1033 def test_append_element_invalid_ranges_signedness(self
):
1034 sub_fc
= self
._tc
.create_string_field_class()
1036 with self
.assertRaises(TypeError):
1037 self
._fc
.append_option(self
._fc
, sub_fc
, self
._inval
_ranges
)
1039 def test_user_attributes(self
):
1040 self
._fc
.append_option(
1042 self
._tc
.create_string_field_class(),
1044 user_attributes
={"salut": 23},
1046 self
.assertEqual(self
._fc
["c"].user_attributes
, {"salut": 23})
1047 self
.assertIs(type(self
._fc
.user_attributes
), bt2_value
.MapValue
)
1049 def test_const_user_attributes(self
):
1050 fc_const
= self
._create
_default
_const
_field
_class
()
1051 self
.assertIs(type(fc_const
.user_attributes
), bt2_value
._MapValueConst
)
1053 def test_invalid_user_attributes(self
):
1054 with self
.assertRaises(TypeError):
1055 self
._fc
.append_option(
1057 self
._tc
.create_string_field_class(),
1059 user_attributes
=object(),
1062 def test_invalid_user_attributes_value_type(self
):
1063 with self
.assertRaises(TypeError):
1064 self
._fc
.append_option(
1066 self
._tc
.create_string_field_class(),
1071 def test_iadd(self
):
1072 a_field_class
= self
._tc
.create_single_precision_real_field_class()
1073 self
._fc
.append_option("a_float", a_field_class
, self
._ranges
1)
1074 c_field_class
= self
._tc
.create_string_field_class()
1075 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
1076 field_value_range
=32
1079 ("c_string", c_field_class
, self
._ranges
2),
1080 ("d_enum", d_field_class
, self
._ranges
3),
1082 self
.assertEqual(self
._fc
["a_float"].field_class
.addr
, a_field_class
.addr
)
1083 self
.assertEqual(self
._fc
["a_float"].name
, "a_float")
1084 self
.assertEqual(self
._fc
["a_float"].ranges
, self
._ranges
1)
1085 self
.assertEqual(self
._fc
["c_string"].field_class
.addr
, c_field_class
.addr
)
1086 self
.assertEqual(self
._fc
["c_string"].name
, "c_string")
1087 self
.assertEqual(self
._fc
["c_string"].ranges
, self
._ranges
2)
1088 self
.assertEqual(self
._fc
["d_enum"].field_class
.addr
, d_field_class
.addr
)
1089 self
.assertEqual(self
._fc
["d_enum"].name
, "d_enum")
1090 self
.assertEqual(self
._fc
["d_enum"].ranges
, self
._ranges
3)
1092 def test_const_iadd(self
):
1093 fc_const
= self
._create
_default
_const
_field
_class
()
1094 a_field_class
= self
._tc
.create_single_precision_real_field_class()
1095 with self
.assertRaises(TypeError):
1096 fc_const
+= [("a_float", a_field_class
, self
._ranges
1)]
1098 def test_bool_op(self
):
1099 self
.assertFalse(self
._fc
)
1100 self
._fc
.append_option("a", self
._tc
.create_string_field_class(), self
._ranges
1)
1101 self
.assertTrue(self
._fc
)
1104 self
._fc
.append_option("a", self
._tc
.create_string_field_class(), self
._ranges
1)
1105 self
._fc
.append_option("b", self
._tc
.create_string_field_class(), self
._ranges
2)
1106 self
._fc
.append_option("c", self
._tc
.create_string_field_class(), self
._ranges
3)
1107 self
.assertEqual(len(self
._fc
), 3)
1109 def test_getitem(self
):
1110 a_fc
= self
._tc
.create_signed_integer_field_class(32)
1111 b_fc
= self
._tc
.create_string_field_class()
1112 c_fc
= self
._tc
.create_single_precision_real_field_class()
1113 self
._fc
.append_option("a", a_fc
, self
._ranges
1)
1114 self
._fc
.append_option("b", b_fc
, self
._ranges
2)
1115 self
._fc
.append_option("c", c_fc
, self
._ranges
3)
1116 self
.assertEqual(self
._fc
["b"].field_class
.addr
, b_fc
.addr
)
1117 self
.assertEqual(self
._fc
["b"].name
, "b")
1118 self
.assertEqual(self
._fc
["b"].ranges
.addr
, self
._ranges
2.addr
)
1120 def test_option_field_class(self
):
1121 a_fc
= self
._tc
.create_signed_integer_field_class(32)
1122 self
._fc
.append_option("a", a_fc
, self
._ranges
1)
1124 type(self
._fc
["a"].field_class
), bt2_field_class
._SignedIntegerFieldClass
1127 def test_const_option_field_class(self
):
1128 fc_const
= self
._create
_default
_const
_field
_class
()
1130 type(fc_const
["a"].field_class
),
1131 bt2_field_class
._SignedIntegerFieldClassConst
,
1134 def test_getitem_invalid_key_type(self
):
1135 with self
.assertRaises(TypeError):
1138 def test_getitem_invalid_key(self
):
1139 with self
.assertRaises(KeyError):
1142 def test_contains(self
):
1143 self
.assertFalse("a" in self
._fc
)
1144 self
._fc
.append_option("a", self
._tc
.create_string_field_class(), self
._ranges
1)
1145 self
.assertTrue("a" in self
._fc
)
1147 def test_iter(self
):
1148 a_fc
= self
._tc
.create_signed_integer_field_class(32)
1149 b_fc
= self
._tc
.create_string_field_class()
1150 c_fc
= self
._tc
.create_single_precision_real_field_class()
1152 ("a", a_fc
, self
._ranges
1),
1153 ("b", b_fc
, self
._ranges
2),
1154 ("c", c_fc
, self
._ranges
3),
1158 self
._fc
.append_option(*opt
)
1160 for (name
, opt
), test_opt
in zip(self
._fc
.items(), opts
):
1161 self
.assertEqual(opt
.name
, test_opt
[0])
1162 self
.assertEqual(name
, opt
.name
)
1163 self
.assertEqual(opt
.field_class
.addr
, test_opt
[1].addr
)
1164 self
.assertEqual(opt
.ranges
.addr
, test_opt
[2].addr
)
1166 def test_at_index(self
):
1167 a_fc
= self
._tc
.create_signed_integer_field_class(32)
1168 b_fc
= self
._tc
.create_string_field_class()
1169 c_fc
= self
._tc
.create_single_precision_real_field_class()
1170 self
._fc
.append_option("c", c_fc
, self
._ranges
1)
1171 self
._fc
.append_option("a", a_fc
, self
._ranges
2)
1172 self
._fc
.append_option("b", b_fc
, self
._ranges
3)
1173 self
.assertEqual(self
._fc
.option_at_index(1).field_class
.addr
, a_fc
.addr
)
1174 self
.assertEqual(self
._fc
.option_at_index(1).name
, "a")
1175 self
.assertEqual(self
._fc
.option_at_index(1).ranges
.addr
, self
._ranges
2.addr
)
1177 def test_at_index_invalid(self
):
1178 self
._fc
.append_option(
1179 "c", self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
1182 with self
.assertRaises(TypeError):
1183 self
._fc
.option_at_index("yes")
1185 def test_at_index_out_of_bounds_after(self
):
1186 self
._fc
.append_option(
1187 "c", self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
1190 with self
.assertRaises(IndexError):
1191 self
._fc
.option_at_index(len(self
._fc
))
1193 def _fill_default_fc_for_field_path_test(self
):
1194 # Create something equivalent to:
1196 # struct outer_struct_fc {
1198 # struct inner_struct_fc {
1199 # [u]int64_t selector;
1202 # variant <selector> {
1203 # real a; // selected with self._ranges1
1204 # int21_t b; // selected with self._ranges2
1205 # uint34_t c; // selected with self._ranges3
1207 # } inner_struct[2];
1209 self
._fc
.append_option(
1210 "a", self
._tc
.create_single_precision_real_field_class(), self
._ranges
1
1212 self
._fc
.append_option(
1213 "b", self
._tc
.create_signed_integer_field_class(21), self
._ranges
2
1215 self
._fc
.append_option(
1216 "c", self
._tc
.create_unsigned_integer_field_class(34), self
._ranges
3
1219 foo_fc
= self
._tc
.create_single_precision_real_field_class()
1220 bar_fc
= self
._tc
.create_string_field_class()
1221 baz_fc
= self
._tc
.create_string_field_class()
1223 inner_struct_fc
= self
._tc
.create_structure_field_class()
1224 inner_struct_fc
.append_member("selector", self
._selector
_fc
)
1225 inner_struct_fc
.append_member("bar", bar_fc
)
1226 inner_struct_fc
.append_member("baz", baz_fc
)
1227 inner_struct_fc
.append_member("variant", self
._fc
)
1229 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
1233 outer_struct_fc
= self
._tc
.create_structure_field_class()
1234 outer_struct_fc
.append_member("foo", foo_fc
)
1235 outer_struct_fc
.append_member("inner_struct", inner_struct_array_fc
)
1237 # The path to the selector field is resolved when the sequence is
1238 # actually used, for example in a packet context.
1239 self
._tc
.create_stream_class(
1240 supports_packets
=True, packet_context_field_class
=outer_struct_fc
1243 def test_selector_field_path_length(self
):
1244 self
._fill
_default
_fc
_for
_field
_path
_test
()
1245 self
.assertEqual(len(self
._fc
.selector_field_path
), 3)
1247 def test_selector_field_path_iter(self
):
1248 self
._fill
_default
_fc
_for
_field
_path
_test
()
1249 path_items
= list(self
._fc
.selector_field_path
)
1251 self
.assertEqual(len(path_items
), 3)
1253 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
1254 self
.assertEqual(path_items
[0].index
, 1)
1256 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
1258 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
1259 self
.assertEqual(path_items
[2].index
, 0)
1261 def test_selector_field_path_root_scope(self
):
1262 self
._fill
_default
_fc
_for
_field
_path
_test
()
1264 self
._fc
.selector_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
1268 class VariantFieldClassWithUnsignedSelectorTestCase(
1269 _VariantFieldClassWithIntegerSelectorTestCase
, unittest
.TestCase
1271 def _spec_set_up(self
):
1272 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
1273 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
1274 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
1275 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, 16), (48, 99)])
1276 self
._selector
_fc
= self
._tc
.create_unsigned_integer_field_class()
1279 class VariantFieldClassWithSignedSelectorTestCase(
1280 _VariantFieldClassWithIntegerSelectorTestCase
, unittest
.TestCase
1282 def _spec_set_up(self
):
1283 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
1284 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
1285 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(8, 16), (48, 99)])
1286 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
1287 self
._selector
_fc
= self
._tc
.create_signed_integer_field_class()
1290 class _ArrayFieldClassTestCase
:
1291 def test_attr_element_field_class(self
):
1292 fc
= self
._create
_array
()
1294 type(fc
.element_field_class
), bt2_field_class
._SignedIntegerFieldClass
1298 class _ArrayFieldClassConstTestCase
:
1299 def test_const_attr_element_field_class(self
):
1300 fc
= self
._create
_const
_array
()
1302 type(fc
.element_field_class
), bt2_field_class
._SignedIntegerFieldClassConst
1306 class StaticArrayFieldClassTestCase(
1307 _ArrayFieldClassTestCase
, _ArrayFieldClassConstTestCase
, unittest
.TestCase
1310 def _const_value_setter(field
):
1311 field
.value
= [9] * 45
1313 def _create_array(self
):
1314 return self
._tc
.create_static_array_field_class(self
._elem
_fc
, 45)
1316 def _create_const_array(self
):
1317 fc
= self
._tc
.create_static_array_field_class(self
._elem
_fc
, 45)
1318 return _create_const_field_class(self
._tc
, fc
, self
._const
_value
_setter
)
1321 self
._tc
= get_default_trace_class()
1322 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
1324 def test_create_default(self
):
1325 fc
= self
._tc
.create_static_array_field_class(self
._elem
_fc
, 45)
1326 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
1327 self
.assertEqual(fc
.length
, 45)
1328 self
.assertEqual(len(fc
.user_attributes
), 0)
1330 def test_create_invalid_elem_field_class(self
):
1331 with self
.assertRaises(TypeError):
1332 self
._tc
.create_static_array_field_class(object(), 45)
1334 def test_create_invalid_length(self
):
1335 with self
.assertRaises(ValueError):
1336 self
._tc
.create_static_array_field_class(
1337 self
._tc
.create_string_field_class(), -17
1340 def test_create_invalid_length_type(self
):
1341 with self
.assertRaises(TypeError):
1342 self
._tc
.create_static_array_field_class(
1343 self
._tc
.create_string_field_class(), "the length"
1347 class DynamicArrayFieldClassTestCase(
1348 _ArrayFieldClassTestCase
, _ArrayFieldClassConstTestCase
, unittest
.TestCase
1351 def _const_value_setter(field
):
1354 def _create_array(self
):
1355 return self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
)
1357 def _create_const_array(self
):
1358 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
)
1359 return _create_const_field_class(self
._tc
, fc
, self
._const
_value
_setter
)
1362 self
._tc
= get_default_trace_class()
1363 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
1365 def test_create_default(self
):
1366 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
)
1367 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
1368 self
.assertEqual(len(fc
.user_attributes
), 0)
1370 def test_create_invalid_field_class(self
):
1371 with self
.assertRaises(TypeError):
1372 self
._tc
.create_dynamic_array_field_class(object())
1375 class DynamicArrayWithLengthFieldFieldClassTestCase(
1376 _ArrayFieldClassTestCase
, unittest
.TestCase
1379 def _const_value_setter(field
):
1382 def _create_array(self
):
1383 return self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
, self
._len
_fc
)
1386 self
._tc
= get_default_trace_class()
1387 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
1388 self
._len
_fc
= self
._tc
.create_unsigned_integer_field_class(12)
1390 def test_create_default(self
):
1391 fc
= self
._create
_array
()
1392 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
1393 self
.assertIsNone(fc
.length_field_path
, None)
1394 self
.assertEqual(len(fc
.user_attributes
), 0)
1396 def _create_field_class_for_field_path_test(self
):
1397 # Create something a field class that is equivalent to:
1399 # struct outer_struct_fc {
1401 # struct inner_struct_fc {
1405 # uint23_t dyn_array[len];
1406 # } inner_struct[2];
1409 fc
= self
._create
_array
()
1411 foo_fc
= self
._tc
.create_single_precision_real_field_class()
1412 bar_fc
= self
._tc
.create_string_field_class()
1413 baz_fc
= self
._tc
.create_string_field_class()
1415 inner_struct_fc
= self
._tc
.create_structure_field_class()
1416 inner_struct_fc
.append_member("bar", bar_fc
)
1417 inner_struct_fc
.append_member("baz", baz_fc
)
1418 inner_struct_fc
.append_member("len", self
._len
_fc
)
1419 inner_struct_fc
.append_member("dyn_array", fc
)
1421 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
1425 outer_struct_fc
= self
._tc
.create_structure_field_class()
1426 outer_struct_fc
.append_member("foo", foo_fc
)
1427 outer_struct_fc
.append_member("inner_struct", inner_struct_array_fc
)
1429 # The path to the length field is resolved when the sequence is
1430 # actually used, for example in a packet context.
1431 self
._tc
.create_stream_class(
1432 packet_context_field_class
=outer_struct_fc
, supports_packets
=True
1437 def test_field_path_len(self
):
1438 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
1439 self
.assertEqual(len(fc
.length_field_path
), 3)
1441 def test_field_path_iter(self
):
1442 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
1443 path_items
= list(fc
.length_field_path
)
1445 self
.assertEqual(len(path_items
), 3)
1447 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
1448 self
.assertEqual(path_items
[0].index
, 1)
1450 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
1452 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
1453 self
.assertEqual(path_items
[2].index
, 2)
1455 def test_field_path_root_scope(self
):
1456 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
1458 fc
.length_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
1461 def test_create_invalid_length_type(self
):
1462 with self
.assertRaises(TypeError):
1463 self
._tc
.create_dynamic_array_field_class(
1464 self
._tc
.create_string_field_class(), 17
1468 if __name__
== "__main__":