2 # Copyright (C) 2019 EfficiOS Inc.
4 # This program is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU General Public License
6 # as published by the Free Software Foundation; only version 2
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
14 # You should have received a copy of the GNU General Public License
15 # along with this program; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 from utils
import get_default_trace_class
24 class _TestFieldClass
:
25 def test_create_user_attributes(self
):
26 fc
= self
._create
_default
_field
_class
(user_attributes
={'salut': 23})
27 self
.assertEqual(fc
.user_attributes
, {'salut': 23})
29 def test_create_invalid_user_attributes(self
):
30 with self
.assertRaises(TypeError):
31 self
._create
_default
_field
_class
(user_attributes
=object())
33 def test_create_invalid_user_attributes_value_type(self
):
34 with self
.assertRaises(TypeError):
35 self
._create
_default
_field
_class
(user_attributes
=23)
38 class BoolFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
39 def _create_default_field_class(self
, **kwargs
):
40 tc
= get_default_trace_class()
41 return tc
.create_bool_field_class(**kwargs
)
44 self
._fc
= self
._create
_default
_field
_class
()
46 def test_create_default(self
):
47 self
.assertIsNotNone(self
._fc
)
48 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
51 class BitArrayFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
52 def _create_field_class(self
, *args
, **kwargs
):
53 tc
= get_default_trace_class()
54 return tc
.create_bit_array_field_class(*args
, **kwargs
)
56 def _create_default_field_class(self
, **kwargs
):
57 return self
._create
_field
_class
(17, **kwargs
)
60 self
._fc
= self
._create
_default
_field
_class
()
62 def test_create_default(self
):
63 self
.assertIsNotNone(self
._fc
)
64 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
66 def test_create_length_out_of_range(self
):
67 with self
.assertRaises(ValueError):
68 self
._create
_field
_class
(65)
70 def test_create_length_zero(self
):
71 with self
.assertRaises(ValueError):
72 self
._create
_field
_class
(0)
74 def test_create_length_invalid_type(self
):
75 with self
.assertRaises(TypeError):
76 self
._create
_field
_class
('lel')
78 def test_length_prop(self
):
79 self
.assertEqual(self
._fc
.length
, 17)
82 class _TestIntegerFieldClassProps
:
83 def test_create_default(self
):
84 fc
= self
._create
_default
_field
_class
()
85 self
.assertEqual(fc
.field_value_range
, 64)
86 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.DECIMAL
)
87 self
.assertEqual(len(fc
.user_attributes
), 0)
89 def test_create_range(self
):
90 fc
= self
._create
_field
_class
(field_value_range
=35)
91 self
.assertEqual(fc
.field_value_range
, 35)
93 fc
= self
._create
_field
_class
(36)
94 self
.assertEqual(fc
.field_value_range
, 36)
96 def test_create_invalid_range(self
):
97 with self
.assertRaises(TypeError):
98 self
._create
_field
_class
('yes')
100 with self
.assertRaises(TypeError):
101 self
._create
_field
_class
(field_value_range
='yes')
103 with self
.assertRaises(ValueError):
104 self
._create
_field
_class
(field_value_range
=-2)
106 with self
.assertRaises(ValueError):
107 self
._create
_field
_class
(field_value_range
=0)
109 def test_create_base(self
):
110 fc
= self
._create
_field
_class
(
111 preferred_display_base
=bt2
.IntegerDisplayBase
.HEXADECIMAL
113 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.HEXADECIMAL
)
115 def test_create_invalid_base_type(self
):
116 with self
.assertRaises(TypeError):
117 self
._create
_field
_class
(preferred_display_base
='yes')
119 def test_create_invalid_base_value(self
):
120 with self
.assertRaises(ValueError):
121 self
._create
_field
_class
(preferred_display_base
=444)
123 def test_create_full(self
):
124 fc
= self
._create
_field
_class
(
125 24, preferred_display_base
=bt2
.IntegerDisplayBase
.OCTAL
127 self
.assertEqual(fc
.field_value_range
, 24)
128 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.OCTAL
)
131 class SignedIntegerFieldClassTestCase(
132 _TestIntegerFieldClassProps
, _TestFieldClass
, unittest
.TestCase
134 def _create_field_class(self
, *args
, **kwargs
):
135 tc
= get_default_trace_class()
136 return tc
.create_signed_integer_field_class(*args
, **kwargs
)
138 _create_default_field_class
= _create_field_class
141 class UnsignedIntegerFieldClassTestCase(
142 _TestIntegerFieldClassProps
, _TestFieldClass
, unittest
.TestCase
144 def _create_field_class(self
, *args
, **kwargs
):
145 tc
= get_default_trace_class()
146 return tc
.create_unsigned_integer_field_class(*args
, **kwargs
)
148 _create_default_field_class
= _create_field_class
151 class RealFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
152 def _create_field_class(self
, *args
, **kwargs
):
153 tc
= get_default_trace_class()
154 return tc
.create_real_field_class(*args
, **kwargs
)
156 _create_default_field_class
= _create_field_class
158 def test_create_default(self
):
159 fc
= self
._create
_field
_class
()
160 self
.assertFalse(fc
.is_single_precision
)
161 self
.assertEqual(len(fc
.user_attributes
), 0)
163 def test_create_is_single_precision(self
):
164 fc
= self
._create
_field
_class
(is_single_precision
=True)
165 self
.assertTrue(fc
.is_single_precision
)
167 def test_create_invalid_is_single_precision(self
):
168 with self
.assertRaises(TypeError):
169 self
._create
_field
_class
(is_single_precision
='hohoho')
172 # Converts an _EnumerationFieldClassMapping to a list of ranges:
174 # [(lower0, upper0), (lower1, upper1), ...]
177 def enum_mapping_to_set(mapping
):
178 return {(x
.lower
, x
.upper
) for x
in mapping
.ranges
}
181 class _EnumerationFieldClassTestCase(_TestIntegerFieldClassProps
):
184 self
._fc
= self
._create
_default
_field
_class
()
186 def test_create_from_invalid_type(self
):
187 with self
.assertRaises(TypeError):
188 self
._create
_field
_class
('coucou')
190 def test_add_mapping_simple(self
):
191 self
._fc
.add_mapping('hello', self
._ranges
1)
192 mapping
= self
._fc
['hello']
193 self
.assertEqual(mapping
.label
, 'hello')
194 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
196 def test_add_mapping_simple_kwargs(self
):
197 self
._fc
.add_mapping(label
='hello', ranges
=self
._ranges
1)
198 mapping
= self
._fc
['hello']
199 self
.assertEqual(mapping
.label
, 'hello')
200 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
202 def test_add_mapping_invalid_name(self
):
203 with self
.assertRaises(TypeError):
204 self
._fc
.add_mapping(17, self
._ranges
1)
206 def test_add_mapping_invalid_range(self
):
207 with self
.assertRaises(TypeError):
208 self
._fc
.add_mapping('allo', 'meow')
210 def test_add_mapping_dup_label(self
):
211 with self
.assertRaises(ValueError):
212 self
._fc
.add_mapping('a', self
._ranges
1)
213 self
._fc
.add_mapping('a', self
._ranges
2)
215 def test_add_mapping_invalid_ranges_signedness(self
):
216 with self
.assertRaises(TypeError):
217 self
._fc
.add_mapping('allo', self
._inval
_ranges
)
220 self
._fc
.add_mapping('c', self
._ranges
1)
222 self
._fc
+= [('d', self
._ranges
2), ('e', self
._ranges
3)]
224 self
.assertEqual(len(self
._fc
), 3)
225 self
.assertEqual(self
._fc
['c'].label
, 'c')
226 self
.assertEqual(self
._fc
['c'].ranges
, self
._ranges
1)
227 self
.assertEqual(self
._fc
['d'].label
, 'd')
228 self
.assertEqual(self
._fc
['d'].ranges
, self
._ranges
2)
229 self
.assertEqual(self
._fc
['e'].label
, 'e')
230 self
.assertEqual(self
._fc
['e'].ranges
, self
._ranges
3)
232 def test_bool_op(self
):
233 self
.assertFalse(self
._fc
)
234 self
._fc
.add_mapping('a', self
._ranges
1)
235 self
.assertTrue(self
._fc
)
238 self
._fc
.add_mapping('a', self
._ranges
1)
239 self
._fc
.add_mapping('b', self
._ranges
2)
240 self
._fc
.add_mapping('c', self
._ranges
3)
241 self
.assertEqual(len(self
._fc
), 3)
243 def test_getitem(self
):
244 self
._fc
.add_mapping('a', self
._ranges
1)
245 self
._fc
.add_mapping('b', self
._ranges
2)
246 self
._fc
.add_mapping('c', self
._ranges
3)
247 mapping
= self
._fc
['a']
248 self
.assertEqual(mapping
.label
, 'a')
249 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
251 def test_getitem_nonexistent(self
):
252 with self
.assertRaises(KeyError):
253 self
._fc
['doesnotexist']
256 self
._fc
.add_mapping('a', self
._ranges
1)
257 self
._fc
.add_mapping('b', self
._ranges
2)
258 self
._fc
.add_mapping('c', self
._ranges
3)
260 # This exercises iteration.
261 labels
= sorted(self
._fc
)
263 self
.assertEqual(labels
, ['a', 'b', 'c'])
265 def test_find_by_value(self
):
266 self
._fc
.add_mapping('a', self
._ranges
1)
267 self
._fc
.add_mapping('b', self
._ranges
2)
268 self
._fc
.add_mapping('c', self
._ranges
3)
269 mappings
= self
._fc
.mappings_for_value(self
._value
_in
_range
_1_and
_3)
270 labels
= set([mapping
.label
for mapping
in mappings
])
271 expected_labels
= set(['a', 'c'])
272 self
.assertEqual(labels
, expected_labels
)
275 class UnsignedEnumerationFieldClassTestCase(
276 _EnumerationFieldClassTestCase
, _TestFieldClass
, unittest
.TestCase
278 def _spec_set_up(self
):
279 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
280 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
281 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 22), (48, 99)])
282 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, -5), (48, 1928)])
283 self
._value
_in
_range
_1_and
_3 = 20
285 def _create_field_class(self
, *args
, **kwargs
):
286 tc
= get_default_trace_class()
287 return tc
.create_unsigned_enumeration_field_class(*args
, **kwargs
)
289 _create_default_field_class
= _create_field_class
292 class SignedEnumerationFieldClassTestCase(
293 _EnumerationFieldClassTestCase
, _TestFieldClass
, unittest
.TestCase
295 def _spec_set_up(self
):
296 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
297 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
298 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(-100, -1), (8, 16), (48, 99)])
299 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
300 self
._value
_in
_range
_1_and
_3 = -7
302 def _create_field_class(self
, *args
, **kwargs
):
303 tc
= get_default_trace_class()
304 return tc
.create_signed_enumeration_field_class(*args
, **kwargs
)
306 _create_default_field_class
= _create_field_class
309 class StringFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
310 def _create_field_class(self
, *args
, **kwargs
):
311 tc
= get_default_trace_class()
312 return tc
.create_string_field_class(*args
, **kwargs
)
314 _create_default_field_class
= _create_field_class
317 self
._fc
= self
._create
_default
_field
_class
()
319 def test_create_default(self
):
320 self
.assertIsNotNone(self
._fc
)
321 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
324 class _TestElementContainer
:
326 self
._tc
= get_default_trace_class()
327 self
._fc
= self
._create
_default
_field
_class
()
329 def test_create_default(self
):
330 self
.assertIsNotNone(self
._fc
)
331 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
333 def test_append_element(self
):
334 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
335 self
._append
_element
_method
(self
._fc
, 'int32', int_field_class
)
336 field_class
= self
._fc
['int32'].field_class
337 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
339 def test_append_element_kwargs(self
):
340 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
341 self
._append
_element
_method
(self
._fc
, name
='int32', field_class
=int_field_class
)
342 field_class
= self
._fc
['int32'].field_class
343 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
345 def test_append_element_invalid_name(self
):
346 sub_fc
= self
._tc
.create_string_field_class()
348 with self
.assertRaises(TypeError):
349 self
._append
_element
_method
(self
._fc
, 23, sub_fc
)
351 def test_append_element_invalid_field_class(self
):
352 with self
.assertRaises(TypeError):
353 self
._append
_element
_method
(self
._fc
, 'yes', object())
355 def test_append_element_dup_name(self
):
356 sub_fc1
= self
._tc
.create_string_field_class()
357 sub_fc2
= self
._tc
.create_string_field_class()
359 with self
.assertRaises(ValueError):
360 self
._append
_element
_method
(self
._fc
, 'yes', sub_fc1
)
361 self
._append
_element
_method
(self
._fc
, 'yes', sub_fc2
)
364 a_field_class
= self
._tc
.create_real_field_class()
365 b_field_class
= self
._tc
.create_signed_integer_field_class(17)
366 self
._append
_element
_method
(self
._fc
, 'a_float', a_field_class
)
367 self
._append
_element
_method
(self
._fc
, 'b_int', b_field_class
)
368 c_field_class
= self
._tc
.create_string_field_class()
369 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
372 e_field_class
= self
._tc
.create_structure_field_class()
374 ('c_string', c_field_class
),
375 ('d_enum', d_field_class
),
376 ('e_struct', e_field_class
),
378 self
.assertEqual(self
._fc
['a_float'].field_class
.addr
, a_field_class
.addr
)
379 self
.assertEqual(self
._fc
['a_float'].name
, 'a_float')
380 self
.assertEqual(self
._fc
['b_int'].field_class
.addr
, b_field_class
.addr
)
381 self
.assertEqual(self
._fc
['b_int'].name
, 'b_int')
382 self
.assertEqual(self
._fc
['c_string'].field_class
.addr
, c_field_class
.addr
)
383 self
.assertEqual(self
._fc
['c_string'].name
, 'c_string')
384 self
.assertEqual(self
._fc
['d_enum'].field_class
.addr
, d_field_class
.addr
)
385 self
.assertEqual(self
._fc
['d_enum'].name
, 'd_enum')
386 self
.assertEqual(self
._fc
['e_struct'].field_class
.addr
, e_field_class
.addr
)
387 self
.assertEqual(self
._fc
['e_struct'].name
, 'e_struct')
389 def test_bool_op(self
):
390 self
.assertFalse(self
._fc
)
391 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
392 self
.assertTrue(self
._fc
)
395 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
396 self
._append
_element
_method
(self
._fc
, 'b', self
._tc
.create_string_field_class())
397 self
._append
_element
_method
(self
._fc
, 'c', self
._tc
.create_string_field_class())
398 self
.assertEqual(len(self
._fc
), 3)
400 def test_getitem(self
):
401 a_fc
= self
._tc
.create_signed_integer_field_class(32)
402 b_fc
= self
._tc
.create_string_field_class()
403 c_fc
= self
._tc
.create_real_field_class()
404 self
._append
_element
_method
(self
._fc
, 'a', a_fc
)
405 self
._append
_element
_method
(self
._fc
, 'b', b_fc
)
406 self
._append
_element
_method
(self
._fc
, 'c', c_fc
)
407 self
.assertEqual(self
._fc
['b'].field_class
.addr
, b_fc
.addr
)
408 self
.assertEqual(self
._fc
['b'].name
, 'b')
410 def test_getitem_invalid_key_type(self
):
411 with self
.assertRaises(TypeError):
414 def test_getitem_invalid_key(self
):
415 with self
.assertRaises(KeyError):
418 def test_contains(self
):
419 self
.assertFalse('a' in self
._fc
)
420 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
421 self
.assertTrue('a' in self
._fc
)
424 a_fc
= self
._tc
.create_signed_integer_field_class(32)
425 b_fc
= self
._tc
.create_string_field_class()
426 c_fc
= self
._tc
.create_real_field_class()
427 elements
= (('a', a_fc
), ('b', b_fc
), ('c', c_fc
))
429 for elem
in elements
:
430 self
._append
_element
_method
(self
._fc
, *elem
)
432 for (name
, element
), test_elem
in zip(self
._fc
.items(), elements
):
433 self
.assertEqual(element
.name
, test_elem
[0])
434 self
.assertEqual(name
, element
.name
)
435 self
.assertEqual(element
.field_class
.addr
, test_elem
[1].addr
)
436 self
.assertEqual(len(element
.user_attributes
), 0)
438 def test_at_index(self
):
439 a_fc
= self
._tc
.create_signed_integer_field_class(32)
440 b_fc
= self
._tc
.create_string_field_class()
441 c_fc
= self
._tc
.create_real_field_class()
442 self
._append
_element
_method
(self
._fc
, 'c', c_fc
)
443 self
._append
_element
_method
(self
._fc
, 'a', a_fc
)
444 self
._append
_element
_method
(self
._fc
, 'b', b_fc
)
445 elem
= self
._at
_index
_method
(self
._fc
, 1)
446 self
.assertEqual(elem
.field_class
.addr
, a_fc
.addr
)
447 self
.assertEqual(elem
.name
, 'a')
449 def test_at_index_invalid(self
):
450 self
._append
_element
_method
(
451 self
._fc
, 'c', self
._tc
.create_signed_integer_field_class(32)
454 with self
.assertRaises(TypeError):
455 self
._at
_index
_method
(self
._fc
, 'yes')
457 def test_at_index_out_of_bounds_after(self
):
458 self
._append
_element
_method
(
459 self
._fc
, 'c', self
._tc
.create_signed_integer_field_class(32)
462 with self
.assertRaises(IndexError):
463 self
._at
_index
_method
(self
._fc
, len(self
._fc
))
465 def test_user_attributes(self
):
466 self
._append
_element
_method
(
469 self
._tc
.create_string_field_class(),
470 user_attributes
={'salut': 23},
472 self
.assertEqual(self
._fc
['c'].user_attributes
, {'salut': 23})
474 def test_invalid_user_attributes(self
):
475 with self
.assertRaises(TypeError):
476 self
._append
_element
_method
(
479 self
._tc
.create_string_field_class(),
480 user_attributes
=object(),
483 def test_invalid_user_attributes_value_type(self
):
484 with self
.assertRaises(TypeError):
485 self
._append
_element
_method
(
486 self
._fc
, 'c', self
._tc
.create_string_field_class(), user_attributes
=23
490 class StructureFieldClassTestCase(
491 _TestFieldClass
, _TestElementContainer
, unittest
.TestCase
493 _append_element_method
= staticmethod(bt2
._StructureFieldClass
.append_member
)
494 _at_index_method
= staticmethod(bt2
._StructureFieldClass
.member_at_index
)
496 def _create_field_class(self
, *args
, **kwargs
):
497 tc
= get_default_trace_class()
498 return tc
.create_structure_field_class(*args
, **kwargs
)
500 _create_default_field_class
= _create_field_class
503 class OptionFieldClassTestCase(_TestFieldClass
, unittest
.TestCase
):
504 def _create_default_field_class(self
, *args
, **kwargs
):
505 return self
._tc
.create_option_field_class(self
._content
_fc
, **kwargs
)
508 self
._tc
= get_default_trace_class()
509 self
._content
_fc
= self
._tc
.create_signed_integer_field_class(23)
510 self
._tag
_fc
= self
._tc
.create_bool_field_class()
512 def test_create_default(self
):
513 fc
= self
._create
_default
_field
_class
()
514 self
.assertEqual(fc
.field_class
.addr
, self
._content
_fc
.addr
)
515 self
.assertIsNone(fc
.selector_field_path
, None)
516 self
.assertEqual(len(fc
.user_attributes
), 0)
518 def _create_field_class_for_field_path_test(self
):
519 fc
= self
._create
_default
_field
_class
(selector_fc
=self
._tag
_fc
)
521 foo_fc
= self
._tc
.create_real_field_class()
522 bar_fc
= self
._tc
.create_string_field_class()
523 baz_fc
= self
._tc
.create_string_field_class()
525 inner_struct_fc
= self
._tc
.create_structure_field_class()
526 inner_struct_fc
.append_member('bar', bar_fc
)
527 inner_struct_fc
.append_member('baz', baz_fc
)
528 inner_struct_fc
.append_member('tag', self
._tag
_fc
)
529 inner_struct_fc
.append_member('opt', fc
)
531 opt_struct_array_fc
= self
._tc
.create_option_field_class(inner_struct_fc
)
533 outer_struct_fc
= self
._tc
.create_structure_field_class()
534 outer_struct_fc
.append_member('foo', foo_fc
)
535 outer_struct_fc
.append_member('inner_opt', opt_struct_array_fc
)
537 # The path to the selector field class is resolved when the
538 # option field class is actually used, for example in a packet
540 self
._tc
.create_stream_class(
541 packet_context_field_class
=outer_struct_fc
, supports_packets
=True
546 def test_field_path_len(self
):
547 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
548 self
.assertEqual(len(fc
.selector_field_path
), 3)
550 def test_field_path_iter(self
):
551 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
552 path_items
= list(fc
.selector_field_path
)
554 self
.assertEqual(len(path_items
), 3)
556 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
557 self
.assertEqual(path_items
[0].index
, 1)
559 self
.assertIsInstance(path_items
[1], bt2
._CurrentOptionContentFieldPathItem
)
561 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
562 self
.assertEqual(path_items
[2].index
, 2)
564 def test_field_path_root_scope(self
):
565 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
567 fc
.selector_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
570 def test_create_invalid_field_class(self
):
571 with self
.assertRaises(TypeError):
572 self
._tc
.create_option_field_class(object())
574 def test_create_invalid_selector_type(self
):
575 with self
.assertRaises(TypeError):
576 self
._tc
.create_option_field_class(self
._content
_fc
, 17)
579 class VariantFieldClassWithoutSelectorTestCase(
580 _TestFieldClass
, _TestElementContainer
, unittest
.TestCase
582 _append_element_method
= staticmethod(
583 bt2
._VariantFieldClassWithoutSelector
.append_option
585 _at_index_method
= staticmethod(
586 bt2
._VariantFieldClassWithoutSelector
.option_at_index
589 def _create_field_class(self
, *args
, **kwargs
):
590 tc
= get_default_trace_class()
591 return tc
.create_variant_field_class(*args
, **kwargs
)
593 _create_default_field_class
= _create_field_class
596 class _VariantFieldClassWithSelectorTestCase
:
597 def _create_default_field_class(self
, *args
, **kwargs
):
598 return self
._tc
.create_variant_field_class(
599 *args
, selector_fc
=self
._selector
_fc
, **kwargs
603 self
._tc
= get_default_trace_class()
605 self
._fc
= self
._create
_default
_field
_class
()
607 def test_create_default(self
):
608 self
.assertIsNotNone(self
._fc
)
609 self
.assertEqual(len(self
._fc
.user_attributes
), 0)
611 def test_append_element(self
):
612 str_field_class
= self
._tc
.create_string_field_class()
613 self
._fc
.append_option('str', str_field_class
, self
._ranges
1)
614 opt
= self
._fc
['str']
615 self
.assertEqual(opt
.field_class
.addr
, str_field_class
.addr
)
616 self
.assertEqual(opt
.name
, 'str')
617 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
619 def test_append_element_kwargs(self
):
620 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
621 self
._fc
.append_option(
622 name
='int32', field_class
=int_field_class
, ranges
=self
._ranges
1
624 opt
= self
._fc
['int32']
625 self
.assertEqual(opt
.field_class
.addr
, int_field_class
.addr
)
626 self
.assertEqual(opt
.name
, 'int32')
627 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
629 def test_append_element_invalid_name(self
):
630 sub_fc
= self
._tc
.create_string_field_class()
632 with self
.assertRaises(TypeError):
633 self
._fc
.append_option(self
._fc
, 23, sub_fc
)
635 def test_append_element_invalid_field_class(self
):
636 with self
.assertRaises(TypeError):
637 self
._fc
.append_option(self
._fc
, 'yes', object())
639 def test_append_element_invalid_ranges(self
):
640 sub_fc
= self
._tc
.create_string_field_class()
642 with self
.assertRaises(TypeError):
643 self
._fc
.append_option(self
._fc
, sub_fc
, 'lel')
645 def test_append_element_dup_name(self
):
646 sub_fc1
= self
._tc
.create_string_field_class()
647 sub_fc2
= self
._tc
.create_string_field_class()
649 with self
.assertRaises(ValueError):
650 self
._fc
.append_option('yes', sub_fc1
, self
._ranges
1)
651 self
._fc
.append_option('yes', sub_fc2
, self
._ranges
2)
653 def test_append_element_invalid_ranges_signedness(self
):
654 sub_fc
= self
._tc
.create_string_field_class()
656 with self
.assertRaises(TypeError):
657 self
._fc
.append_option(self
._fc
, sub_fc
, self
._inval
_ranges
)
659 def test_user_attributes(self
):
660 self
._fc
.append_option(
662 self
._tc
.create_string_field_class(),
664 user_attributes
={'salut': 23},
666 self
.assertEqual(self
._fc
['c'].user_attributes
, {'salut': 23})
668 def test_invalid_user_attributes(self
):
669 with self
.assertRaises(TypeError):
670 self
._fc
.append_option(
672 self
._tc
.create_string_field_class(),
674 user_attributes
=object(),
677 def test_invalid_user_attributes_value_type(self
):
678 with self
.assertRaises(TypeError):
679 self
._fc
.append_option(
681 self
._tc
.create_string_field_class(),
687 a_field_class
= self
._tc
.create_real_field_class()
688 self
._fc
.append_option('a_float', a_field_class
, self
._ranges
1)
689 c_field_class
= self
._tc
.create_string_field_class()
690 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
694 ('c_string', c_field_class
, self
._ranges
2),
695 ('d_enum', d_field_class
, self
._ranges
3),
697 self
.assertEqual(self
._fc
['a_float'].field_class
.addr
, a_field_class
.addr
)
698 self
.assertEqual(self
._fc
['a_float'].name
, 'a_float')
699 self
.assertEqual(self
._fc
['a_float'].ranges
, self
._ranges
1)
700 self
.assertEqual(self
._fc
['c_string'].field_class
.addr
, c_field_class
.addr
)
701 self
.assertEqual(self
._fc
['c_string'].name
, 'c_string')
702 self
.assertEqual(self
._fc
['c_string'].ranges
, self
._ranges
2)
703 self
.assertEqual(self
._fc
['d_enum'].field_class
.addr
, d_field_class
.addr
)
704 self
.assertEqual(self
._fc
['d_enum'].name
, 'd_enum')
705 self
.assertEqual(self
._fc
['d_enum'].ranges
, self
._ranges
3)
707 def test_bool_op(self
):
708 self
.assertFalse(self
._fc
)
709 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
710 self
.assertTrue(self
._fc
)
713 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
714 self
._fc
.append_option('b', self
._tc
.create_string_field_class(), self
._ranges
2)
715 self
._fc
.append_option('c', self
._tc
.create_string_field_class(), self
._ranges
3)
716 self
.assertEqual(len(self
._fc
), 3)
718 def test_getitem(self
):
719 a_fc
= self
._tc
.create_signed_integer_field_class(32)
720 b_fc
= self
._tc
.create_string_field_class()
721 c_fc
= self
._tc
.create_real_field_class()
722 self
._fc
.append_option('a', a_fc
, self
._ranges
1)
723 self
._fc
.append_option('b', b_fc
, self
._ranges
2)
724 self
._fc
.append_option('c', c_fc
, self
._ranges
3)
725 self
.assertEqual(self
._fc
['b'].field_class
.addr
, b_fc
.addr
)
726 self
.assertEqual(self
._fc
['b'].name
, 'b')
727 self
.assertEqual(self
._fc
['b'].ranges
.addr
, self
._ranges
2.addr
)
729 def test_getitem_invalid_key_type(self
):
730 with self
.assertRaises(TypeError):
733 def test_getitem_invalid_key(self
):
734 with self
.assertRaises(KeyError):
737 def test_contains(self
):
738 self
.assertFalse('a' in self
._fc
)
739 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
740 self
.assertTrue('a' in self
._fc
)
743 a_fc
= self
._tc
.create_signed_integer_field_class(32)
744 b_fc
= self
._tc
.create_string_field_class()
745 c_fc
= self
._tc
.create_real_field_class()
747 ('a', a_fc
, self
._ranges
1),
748 ('b', b_fc
, self
._ranges
2),
749 ('c', c_fc
, self
._ranges
3),
753 self
._fc
.append_option(*opt
)
755 for (name
, opt
), test_opt
in zip(self
._fc
.items(), opts
):
756 self
.assertEqual(opt
.name
, test_opt
[0])
757 self
.assertEqual(name
, opt
.name
)
758 self
.assertEqual(opt
.field_class
.addr
, test_opt
[1].addr
)
759 self
.assertEqual(opt
.ranges
.addr
, test_opt
[2].addr
)
761 def test_at_index(self
):
762 a_fc
= self
._tc
.create_signed_integer_field_class(32)
763 b_fc
= self
._tc
.create_string_field_class()
764 c_fc
= self
._tc
.create_real_field_class()
765 self
._fc
.append_option('c', c_fc
, self
._ranges
1)
766 self
._fc
.append_option('a', a_fc
, self
._ranges
2)
767 self
._fc
.append_option('b', b_fc
, self
._ranges
3)
768 self
.assertEqual(self
._fc
.option_at_index(1).field_class
.addr
, a_fc
.addr
)
769 self
.assertEqual(self
._fc
.option_at_index(1).name
, 'a')
770 self
.assertEqual(self
._fc
.option_at_index(1).ranges
.addr
, self
._ranges
2.addr
)
772 def test_at_index_invalid(self
):
773 self
._fc
.append_option(
774 'c', self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
777 with self
.assertRaises(TypeError):
778 self
._fc
.option_at_index('yes')
780 def test_at_index_out_of_bounds_after(self
):
781 self
._fc
.append_option(
782 'c', self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
785 with self
.assertRaises(IndexError):
786 self
._fc
.option_at_index(len(self
._fc
))
788 def _fill_default_fc_for_field_path_test(self
):
789 # Create something equivalent to:
791 # struct outer_struct_fc {
793 # struct inner_struct_fc {
794 # [u]int64_t selector;
797 # variant <selector> {
798 # real a; // selected with self._ranges1
799 # int21_t b; // selected with self._ranges2
800 # uint34_t c; // selected with self._ranges3
804 self
._fc
.append_option('a', self
._tc
.create_real_field_class(), self
._ranges
1)
805 self
._fc
.append_option(
806 'b', self
._tc
.create_signed_integer_field_class(21), self
._ranges
2
808 self
._fc
.append_option(
809 'c', self
._tc
.create_unsigned_integer_field_class(34), self
._ranges
3
812 foo_fc
= self
._tc
.create_real_field_class()
813 bar_fc
= self
._tc
.create_string_field_class()
814 baz_fc
= self
._tc
.create_string_field_class()
816 inner_struct_fc
= self
._tc
.create_structure_field_class()
817 inner_struct_fc
.append_member('selector', self
._selector
_fc
)
818 inner_struct_fc
.append_member('bar', bar_fc
)
819 inner_struct_fc
.append_member('baz', baz_fc
)
820 inner_struct_fc
.append_member('variant', self
._fc
)
822 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
826 outer_struct_fc
= self
._tc
.create_structure_field_class()
827 outer_struct_fc
.append_member('foo', foo_fc
)
828 outer_struct_fc
.append_member('inner_struct', inner_struct_array_fc
)
830 # The path to the selector field is resolved when the sequence is
831 # actually used, for example in a packet context.
832 self
._tc
.create_stream_class(
833 supports_packets
=True, packet_context_field_class
=outer_struct_fc
836 def test_selector_field_path_length(self
):
837 self
._fill
_default
_fc
_for
_field
_path
_test
()
838 self
.assertEqual(len(self
._fc
.selector_field_path
), 3)
840 def test_selector_field_path_iter(self
):
841 self
._fill
_default
_fc
_for
_field
_path
_test
()
842 path_items
= list(self
._fc
.selector_field_path
)
844 self
.assertEqual(len(path_items
), 3)
846 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
847 self
.assertEqual(path_items
[0].index
, 1)
849 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
851 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
852 self
.assertEqual(path_items
[2].index
, 0)
854 def test_selector_field_path_root_scope(self
):
855 self
._fill
_default
_fc
_for
_field
_path
_test
()
857 self
._fc
.selector_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
861 class VariantFieldClassWithUnsignedSelectorTestCase(
862 _VariantFieldClassWithSelectorTestCase
, unittest
.TestCase
864 def _spec_set_up(self
):
865 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
866 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
867 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
868 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, 16), (48, 99)])
869 self
._selector
_fc
= self
._tc
.create_unsigned_integer_field_class()
872 class VariantFieldClassWithSignedSelectorTestCase(
873 _VariantFieldClassWithSelectorTestCase
, unittest
.TestCase
875 def _spec_set_up(self
):
876 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
877 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
878 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(8, 16), (48, 99)])
879 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
880 self
._selector
_fc
= self
._tc
.create_signed_integer_field_class()
883 class StaticArrayFieldClassTestCase(unittest
.TestCase
):
885 self
._tc
= get_default_trace_class()
886 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
888 def test_create_default(self
):
889 fc
= self
._tc
.create_static_array_field_class(self
._elem
_fc
, 45)
890 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
891 self
.assertEqual(fc
.length
, 45)
892 self
.assertEqual(len(fc
.user_attributes
), 0)
894 def test_create_invalid_elem_field_class(self
):
895 with self
.assertRaises(TypeError):
896 self
._tc
.create_static_array_field_class(object(), 45)
898 def test_create_invalid_length(self
):
899 with self
.assertRaises(ValueError):
900 self
._tc
.create_static_array_field_class(
901 self
._tc
.create_string_field_class(), -17
904 def test_create_invalid_length_type(self
):
905 with self
.assertRaises(TypeError):
906 self
._tc
.create_static_array_field_class(
907 self
._tc
.create_string_field_class(), 'the length'
911 class DynamicArrayFieldClassTestCase(unittest
.TestCase
):
913 self
._tc
= get_default_trace_class()
914 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
915 self
._len
_fc
= self
._tc
.create_unsigned_integer_field_class(12)
917 def test_create_default(self
):
918 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
)
919 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
920 self
.assertIsNone(fc
.length_field_path
, None)
921 self
.assertEqual(len(fc
.user_attributes
), 0)
923 def _create_field_class_for_field_path_test(self
):
924 # Create something a field class that is equivalent to:
926 # struct outer_struct_fc {
928 # struct inner_struct_fc {
932 # uint23_t dyn_array[len];
936 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
, self
._len
_fc
)
938 foo_fc
= self
._tc
.create_real_field_class()
939 bar_fc
= self
._tc
.create_string_field_class()
940 baz_fc
= self
._tc
.create_string_field_class()
942 inner_struct_fc
= self
._tc
.create_structure_field_class()
943 inner_struct_fc
.append_member('bar', bar_fc
)
944 inner_struct_fc
.append_member('baz', baz_fc
)
945 inner_struct_fc
.append_member('len', self
._len
_fc
)
946 inner_struct_fc
.append_member('dyn_array', fc
)
948 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
952 outer_struct_fc
= self
._tc
.create_structure_field_class()
953 outer_struct_fc
.append_member('foo', foo_fc
)
954 outer_struct_fc
.append_member('inner_struct', inner_struct_array_fc
)
956 # The path to the length field is resolved when the sequence is
957 # actually used, for example in a packet context.
958 self
._tc
.create_stream_class(
959 packet_context_field_class
=outer_struct_fc
, supports_packets
=True
964 def test_field_path_len(self
):
965 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
966 self
.assertEqual(len(fc
.length_field_path
), 3)
968 def test_field_path_iter(self
):
969 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
970 path_items
= list(fc
.length_field_path
)
972 self
.assertEqual(len(path_items
), 3)
974 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
975 self
.assertEqual(path_items
[0].index
, 1)
977 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
979 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
980 self
.assertEqual(path_items
[2].index
, 2)
982 def test_field_path_root_scope(self
):
983 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
985 fc
.length_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
988 def test_create_invalid_field_class(self
):
989 with self
.assertRaises(TypeError):
990 self
._tc
.create_dynamic_array_field_class(object())
992 def test_create_invalid_length_type(self
):
993 with self
.assertRaises(TypeError):
994 self
._tc
.create_dynamic_array_field_class(
995 self
._tc
.create_string_field_class(), 17
999 if __name__
== "__main__":