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.
22 from utils
import get_default_trace_class
25 class _TestIntegerFieldClassProps
:
26 def test_create_default(self
):
27 fc
= self
._create
_func
()
28 self
.assertEqual(fc
.field_value_range
, 64)
29 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.DECIMAL
)
31 def test_create_range(self
):
32 fc
= self
._create
_func
(field_value_range
=35)
33 self
.assertEqual(fc
.field_value_range
, 35)
35 fc
= self
._create
_func
(36)
36 self
.assertEqual(fc
.field_value_range
, 36)
38 def test_create_invalid_range(self
):
39 with self
.assertRaises(TypeError):
40 self
._create
_func
('yes')
42 with self
.assertRaises(TypeError):
43 self
._create
_func
(field_value_range
='yes')
45 with self
.assertRaises(ValueError):
46 self
._create
_func
(field_value_range
=-2)
48 with self
.assertRaises(ValueError):
49 self
._create
_func
(field_value_range
=0)
51 def test_create_base(self
):
52 fc
= self
._create
_func
(
53 preferred_display_base
=bt2
.IntegerDisplayBase
.HEXADECIMAL
55 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.HEXADECIMAL
)
57 def test_create_invalid_base_type(self
):
58 with self
.assertRaises(TypeError):
59 self
._create
_func
(preferred_display_base
='yes')
61 def test_create_invalid_base_value(self
):
62 with self
.assertRaises(ValueError):
63 self
._create
_func
(preferred_display_base
=444)
65 def test_create_full(self
):
66 fc
= self
._create
_func
(24, preferred_display_base
=bt2
.IntegerDisplayBase
.OCTAL
)
67 self
.assertEqual(fc
.field_value_range
, 24)
68 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.OCTAL
)
71 class IntegerFieldClassTestCase(_TestIntegerFieldClassProps
, unittest
.TestCase
):
73 self
._tc
= get_default_trace_class()
74 self
._create
_func
= self
._tc
.create_signed_integer_field_class
77 class RealFieldClassTestCase(unittest
.TestCase
):
79 self
._tc
= get_default_trace_class()
81 def test_create_default(self
):
82 fc
= self
._tc
.create_real_field_class()
83 self
.assertFalse(fc
.is_single_precision
)
85 def test_create_is_single_precision(self
):
86 fc
= self
._tc
.create_real_field_class(is_single_precision
=True)
87 self
.assertTrue(fc
.is_single_precision
)
89 def test_create_invalid_is_single_precision(self
):
90 with self
.assertRaises(TypeError):
91 self
._tc
.create_real_field_class(is_single_precision
='hohoho')
94 # Converts an _EnumerationFieldClassMapping to a list of ranges:
96 # [(lower0, upper0), (lower1, upper1), ...]
99 def enum_mapping_to_set(mapping
):
100 return {(x
.lower
, x
.upper
) for x
in mapping
.ranges
}
103 class _EnumerationFieldClassTestCase(_TestIntegerFieldClassProps
):
105 self
._tc
= get_default_trace_class()
107 self
._fc
= self
._create
_func
()
109 def test_create_from_invalid_type(self
):
110 with self
.assertRaises(TypeError):
111 self
._create
_func
('coucou')
113 def test_add_mapping_simple(self
):
114 self
._fc
.add_mapping('hello', self
._ranges
1)
115 mapping
= self
._fc
['hello']
116 self
.assertEqual(mapping
.label
, 'hello')
117 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
119 def test_add_mapping_simple_kwargs(self
):
120 self
._fc
.add_mapping(label
='hello', ranges
=self
._ranges
1)
121 mapping
= self
._fc
['hello']
122 self
.assertEqual(mapping
.label
, 'hello')
123 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
125 def test_add_mapping_invalid_name(self
):
126 with self
.assertRaises(TypeError):
127 self
._fc
.add_mapping(17, self
._ranges
1)
129 def test_add_mapping_invalid_range(self
):
130 with self
.assertRaises(TypeError):
131 self
._fc
.add_mapping('allo', 'meow')
133 def test_add_mapping_dup_label(self
):
134 with self
.assertRaises(ValueError):
135 self
._fc
.add_mapping('a', self
._ranges
1)
136 self
._fc
.add_mapping('a', self
._ranges
2)
138 def test_add_mapping_invalid_ranges_signedness(self
):
139 with self
.assertRaises(TypeError):
140 self
._fc
.add_mapping('allo', self
._inval
_ranges
)
143 self
._fc
.add_mapping('c', self
._ranges
1)
145 self
._fc
+= [('d', self
._ranges
2), ('e', self
._ranges
3)]
147 self
.assertEqual(len(self
._fc
), 3)
148 self
.assertEqual(self
._fc
['c'].label
, 'c')
149 self
.assertEqual(self
._fc
['c'].ranges
, self
._ranges
1)
150 self
.assertEqual(self
._fc
['d'].label
, 'd')
151 self
.assertEqual(self
._fc
['d'].ranges
, self
._ranges
2)
152 self
.assertEqual(self
._fc
['e'].label
, 'e')
153 self
.assertEqual(self
._fc
['e'].ranges
, self
._ranges
3)
155 def test_bool_op(self
):
156 self
.assertFalse(self
._fc
)
157 self
._fc
.add_mapping('a', self
._ranges
1)
158 self
.assertTrue(self
._fc
)
161 self
._fc
.add_mapping('a', self
._ranges
1)
162 self
._fc
.add_mapping('b', self
._ranges
2)
163 self
._fc
.add_mapping('c', self
._ranges
3)
164 self
.assertEqual(len(self
._fc
), 3)
166 def test_getitem(self
):
167 self
._fc
.add_mapping('a', self
._ranges
1)
168 self
._fc
.add_mapping('b', self
._ranges
2)
169 self
._fc
.add_mapping('c', self
._ranges
3)
170 mapping
= self
._fc
['a']
171 self
.assertEqual(mapping
.label
, 'a')
172 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
174 def test_getitem_nonexistent(self
):
175 with self
.assertRaises(KeyError):
176 self
._fc
['doesnotexist']
179 self
._fc
.add_mapping('a', self
._ranges
1)
180 self
._fc
.add_mapping('b', self
._ranges
2)
181 self
._fc
.add_mapping('c', self
._ranges
3)
183 # This exercises iteration.
184 labels
= sorted(self
._fc
)
186 self
.assertEqual(labels
, ['a', 'b', 'c'])
188 def test_find_by_value(self
):
189 self
._fc
.add_mapping('a', self
._ranges
1)
190 self
._fc
.add_mapping('b', self
._ranges
2)
191 self
._fc
.add_mapping('c', self
._ranges
3)
192 mappings
= self
._fc
.mappings_for_value(self
._value
_in
_range
_1_and
_3)
193 labels
= set([mapping
.label
for mapping
in mappings
])
194 expected_labels
= set(['a', 'c'])
195 self
.assertEqual(labels
, expected_labels
)
198 class UnsignedEnumerationFieldClassTestCase(
199 _EnumerationFieldClassTestCase
, unittest
.TestCase
201 def _spec_set_up(self
):
202 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
203 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
204 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 22), (48, 99)])
205 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, -5), (48, 1928)])
206 self
._value
_in
_range
_1_and
_3 = 20
207 self
._create
_func
= self
._tc
.create_unsigned_enumeration_field_class
210 class SignedEnumerationFieldClassTestCase(
211 _EnumerationFieldClassTestCase
, unittest
.TestCase
213 def _spec_set_up(self
):
214 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
215 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
216 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(-100, -1), (8, 16), (48, 99)])
217 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
218 self
._value
_in
_range
_1_and
_3 = -7
219 self
._create
_func
= self
._tc
.create_signed_enumeration_field_class
222 class StringFieldClassTestCase(unittest
.TestCase
):
224 tc
= get_default_trace_class()
225 self
._fc
= tc
.create_string_field_class()
227 def test_create_default(self
):
228 self
.assertIsNotNone(self
._fc
)
231 class _TestElementContainer
:
233 self
._tc
= get_default_trace_class()
234 self
._fc
= self
._create
_default
_fc
()
236 def test_create_default(self
):
237 self
.assertIsNotNone(self
._fc
)
239 def test_append_element(self
):
240 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
241 self
._append
_element
_method
(self
._fc
, 'int32', int_field_class
)
242 field_class
= self
._fc
['int32'].field_class
243 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
245 def test_append_element_kwargs(self
):
246 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
247 self
._append
_element
_method
(self
._fc
, name
='int32', field_class
=int_field_class
)
248 field_class
= self
._fc
['int32'].field_class
249 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
251 def test_append_element_invalid_name(self
):
252 sub_fc
= self
._tc
.create_string_field_class()
254 with self
.assertRaises(TypeError):
255 self
._append
_element
_method
(self
._fc
, 23, sub_fc
)
257 def test_append_element_invalid_field_class(self
):
258 with self
.assertRaises(TypeError):
259 self
._append
_element
_method
(self
._fc
, 'yes', object())
261 def test_append_element_dup_name(self
):
262 sub_fc1
= self
._tc
.create_string_field_class()
263 sub_fc2
= self
._tc
.create_string_field_class()
265 with self
.assertRaises(ValueError):
266 self
._append
_element
_method
(self
._fc
, 'yes', sub_fc1
)
267 self
._append
_element
_method
(self
._fc
, 'yes', sub_fc2
)
270 other_fc
= self
._create
_default
_fc
()
271 a_field_class
= self
._tc
.create_real_field_class()
272 b_field_class
= self
._tc
.create_signed_integer_field_class(17)
273 self
._append
_element
_method
(self
._fc
, 'a_float', a_field_class
)
274 self
._append
_element
_method
(self
._fc
, 'b_int', b_field_class
)
275 c_field_class
= self
._tc
.create_string_field_class()
276 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
279 e_field_class
= self
._tc
.create_structure_field_class()
281 ('c_string', c_field_class
),
282 ('d_enum', d_field_class
),
283 ('e_struct', e_field_class
),
285 self
.assertEqual(self
._fc
['a_float'].field_class
.addr
, a_field_class
.addr
)
286 self
.assertEqual(self
._fc
['a_float'].name
, 'a_float')
287 self
.assertEqual(self
._fc
['b_int'].field_class
.addr
, b_field_class
.addr
)
288 self
.assertEqual(self
._fc
['b_int'].name
, 'b_int')
289 self
.assertEqual(self
._fc
['c_string'].field_class
.addr
, c_field_class
.addr
)
290 self
.assertEqual(self
._fc
['c_string'].name
, 'c_string')
291 self
.assertEqual(self
._fc
['d_enum'].field_class
.addr
, d_field_class
.addr
)
292 self
.assertEqual(self
._fc
['d_enum'].name
, 'd_enum')
293 self
.assertEqual(self
._fc
['e_struct'].field_class
.addr
, e_field_class
.addr
)
294 self
.assertEqual(self
._fc
['e_struct'].name
, 'e_struct')
296 def test_bool_op(self
):
297 self
.assertFalse(self
._fc
)
298 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
299 self
.assertTrue(self
._fc
)
302 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
303 self
._append
_element
_method
(self
._fc
, 'b', self
._tc
.create_string_field_class())
304 self
._append
_element
_method
(self
._fc
, 'c', self
._tc
.create_string_field_class())
305 self
.assertEqual(len(self
._fc
), 3)
307 def test_getitem(self
):
308 a_fc
= self
._tc
.create_signed_integer_field_class(32)
309 b_fc
= self
._tc
.create_string_field_class()
310 c_fc
= self
._tc
.create_real_field_class()
311 self
._append
_element
_method
(self
._fc
, 'a', a_fc
)
312 self
._append
_element
_method
(self
._fc
, 'b', b_fc
)
313 self
._append
_element
_method
(self
._fc
, 'c', c_fc
)
314 self
.assertEqual(self
._fc
['b'].field_class
.addr
, b_fc
.addr
)
315 self
.assertEqual(self
._fc
['b'].name
, 'b')
317 def test_getitem_invalid_key_type(self
):
318 with self
.assertRaises(TypeError):
321 def test_getitem_invalid_key(self
):
322 with self
.assertRaises(KeyError):
325 def test_contains(self
):
326 self
.assertFalse('a' in self
._fc
)
327 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
328 self
.assertTrue('a' in self
._fc
)
331 a_fc
= self
._tc
.create_signed_integer_field_class(32)
332 b_fc
= self
._tc
.create_string_field_class()
333 c_fc
= self
._tc
.create_real_field_class()
334 elements
= (('a', a_fc
), ('b', b_fc
), ('c', c_fc
))
336 for elem
in elements
:
337 self
._append
_element
_method
(self
._fc
, *elem
)
339 for (name
, element
), test_elem
in zip(self
._fc
.items(), elements
):
340 self
.assertEqual(element
.name
, test_elem
[0])
341 self
.assertEqual(name
, element
.name
)
342 self
.assertEqual(element
.field_class
.addr
, test_elem
[1].addr
)
344 def test_at_index(self
):
345 a_fc
= self
._tc
.create_signed_integer_field_class(32)
346 b_fc
= self
._tc
.create_string_field_class()
347 c_fc
= self
._tc
.create_real_field_class()
348 self
._append
_element
_method
(self
._fc
, 'c', c_fc
)
349 self
._append
_element
_method
(self
._fc
, 'a', a_fc
)
350 self
._append
_element
_method
(self
._fc
, 'b', b_fc
)
351 elem
= self
._at
_index
_method
(self
._fc
, 1)
352 self
.assertEqual(elem
.field_class
.addr
, a_fc
.addr
)
353 self
.assertEqual(elem
.name
, 'a')
355 def test_at_index_invalid(self
):
356 self
._append
_element
_method
(
357 self
._fc
, 'c', self
._tc
.create_signed_integer_field_class(32)
360 with self
.assertRaises(TypeError):
361 self
._at
_index
_method
(self
._fc
, 'yes')
363 def test_at_index_out_of_bounds_after(self
):
364 self
._append
_element
_method
(
365 self
._fc
, 'c', self
._tc
.create_signed_integer_field_class(32)
368 with self
.assertRaises(IndexError):
369 self
._at
_index
_method
(self
._fc
, len(self
._fc
))
372 class StructureFieldClassTestCase(_TestElementContainer
, unittest
.TestCase
):
373 _append_element_method
= staticmethod(bt2
._StructureFieldClass
.append_member
)
374 _at_index_method
= staticmethod(bt2
._StructureFieldClass
.member_at_index
)
376 def _create_default_fc(self
):
377 return self
._tc
.create_structure_field_class()
380 class VariantFieldClassWithoutSelectorTestCase(
381 _TestElementContainer
, unittest
.TestCase
383 _append_element_method
= staticmethod(
384 bt2
._VariantFieldClassWithoutSelector
.append_option
386 _at_index_method
= staticmethod(
387 bt2
._VariantFieldClassWithoutSelector
.option_at_index
390 def _create_default_fc(self
):
391 return self
._tc
.create_variant_field_class()
394 class _VariantFieldClassWithSelectorTestCase
:
396 self
._tc
= get_default_trace_class()
398 self
._fc
= self
._create
_default
_fc
()
400 def _create_default_fc(self
):
401 return self
._tc
.create_variant_field_class(self
._selector
_fc
)
403 def test_create_default(self
):
404 self
.assertIsNotNone(self
._fc
)
406 def test_append_element(self
):
407 str_field_class
= self
._tc
.create_string_field_class()
408 self
._fc
.append_option('str', str_field_class
, self
._ranges
1)
409 opt
= self
._fc
['str']
410 self
.assertEqual(opt
.field_class
.addr
, str_field_class
.addr
)
411 self
.assertEqual(opt
.name
, 'str')
412 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
414 def test_append_element_kwargs(self
):
415 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
416 self
._fc
.append_option(
417 name
='int32', field_class
=int_field_class
, ranges
=self
._ranges
1
419 opt
= self
._fc
['int32']
420 self
.assertEqual(opt
.field_class
.addr
, int_field_class
.addr
)
421 self
.assertEqual(opt
.name
, 'int32')
422 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
424 def test_append_element_invalid_name(self
):
425 sub_fc
= self
._tc
.create_string_field_class()
427 with self
.assertRaises(TypeError):
428 self
._fc
.append_option(self
._fc
, 23, sub_fc
)
430 def test_append_element_invalid_field_class(self
):
431 with self
.assertRaises(TypeError):
432 self
._fc
.append_option(self
._fc
, 'yes', object())
434 def test_append_element_invalid_ranges(self
):
435 sub_fc
= self
._tc
.create_string_field_class()
437 with self
.assertRaises(TypeError):
438 self
._fc
.append_option(self
._fc
, sub_fc
, 'lel')
440 def test_append_element_dup_name(self
):
441 sub_fc1
= self
._tc
.create_string_field_class()
442 sub_fc2
= self
._tc
.create_string_field_class()
444 with self
.assertRaises(ValueError):
445 self
._fc
.append_option('yes', sub_fc1
, self
._ranges
1)
446 self
._fc
.append_option('yes', sub_fc2
, self
._ranges
2)
448 def test_append_element_invalid_ranges_signedness(self
):
449 sub_fc
= self
._tc
.create_string_field_class()
451 with self
.assertRaises(TypeError):
452 self
._fc
.append_option(self
._fc
, sub_fc
, self
._inval
_ranges
)
455 other_fc
= self
._create
_default
_fc
()
456 a_field_class
= self
._tc
.create_real_field_class()
457 self
._fc
.append_option('a_float', a_field_class
, self
._ranges
1)
458 c_field_class
= self
._tc
.create_string_field_class()
459 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
463 ('c_string', c_field_class
, self
._ranges
2),
464 ('d_enum', d_field_class
, self
._ranges
3),
466 self
.assertEqual(self
._fc
['a_float'].field_class
.addr
, a_field_class
.addr
)
467 self
.assertEqual(self
._fc
['a_float'].name
, 'a_float')
468 self
.assertEqual(self
._fc
['a_float'].ranges
, self
._ranges
1)
469 self
.assertEqual(self
._fc
['c_string'].field_class
.addr
, c_field_class
.addr
)
470 self
.assertEqual(self
._fc
['c_string'].name
, 'c_string')
471 self
.assertEqual(self
._fc
['c_string'].ranges
, self
._ranges
2)
472 self
.assertEqual(self
._fc
['d_enum'].field_class
.addr
, d_field_class
.addr
)
473 self
.assertEqual(self
._fc
['d_enum'].name
, 'd_enum')
474 self
.assertEqual(self
._fc
['d_enum'].ranges
, self
._ranges
3)
476 def test_bool_op(self
):
477 self
.assertFalse(self
._fc
)
478 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
479 self
.assertTrue(self
._fc
)
482 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
483 self
._fc
.append_option('b', self
._tc
.create_string_field_class(), self
._ranges
2)
484 self
._fc
.append_option('c', self
._tc
.create_string_field_class(), self
._ranges
3)
485 self
.assertEqual(len(self
._fc
), 3)
487 def test_getitem(self
):
488 a_fc
= self
._tc
.create_signed_integer_field_class(32)
489 b_fc
= self
._tc
.create_string_field_class()
490 c_fc
= self
._tc
.create_real_field_class()
491 self
._fc
.append_option('a', a_fc
, self
._ranges
1)
492 self
._fc
.append_option('b', b_fc
, self
._ranges
2)
493 self
._fc
.append_option('c', c_fc
, self
._ranges
3)
494 self
.assertEqual(self
._fc
['b'].field_class
.addr
, b_fc
.addr
)
495 self
.assertEqual(self
._fc
['b'].name
, 'b')
496 self
.assertEqual(self
._fc
['b'].ranges
.addr
, self
._ranges
2.addr
)
498 def test_getitem_invalid_key_type(self
):
499 with self
.assertRaises(TypeError):
502 def test_getitem_invalid_key(self
):
503 with self
.assertRaises(KeyError):
506 def test_contains(self
):
507 self
.assertFalse('a' in self
._fc
)
508 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
509 self
.assertTrue('a' in self
._fc
)
512 a_fc
= self
._tc
.create_signed_integer_field_class(32)
513 b_fc
= self
._tc
.create_string_field_class()
514 c_fc
= self
._tc
.create_real_field_class()
516 ('a', a_fc
, self
._ranges
1),
517 ('b', b_fc
, self
._ranges
2),
518 ('c', c_fc
, self
._ranges
3),
522 self
._fc
.append_option(*opt
)
524 for (name
, opt
), test_opt
in zip(self
._fc
.items(), opts
):
525 self
.assertEqual(opt
.name
, test_opt
[0])
526 self
.assertEqual(name
, opt
.name
)
527 self
.assertEqual(opt
.field_class
.addr
, test_opt
[1].addr
)
528 self
.assertEqual(opt
.ranges
.addr
, test_opt
[2].addr
)
530 def test_at_index(self
):
531 a_fc
= self
._tc
.create_signed_integer_field_class(32)
532 b_fc
= self
._tc
.create_string_field_class()
533 c_fc
= self
._tc
.create_real_field_class()
534 self
._fc
.append_option('c', c_fc
, self
._ranges
1)
535 self
._fc
.append_option('a', a_fc
, self
._ranges
2)
536 self
._fc
.append_option('b', b_fc
, self
._ranges
3)
537 self
.assertEqual(self
._fc
.option_at_index(1).field_class
.addr
, a_fc
.addr
)
538 self
.assertEqual(self
._fc
.option_at_index(1).name
, 'a')
539 self
.assertEqual(self
._fc
.option_at_index(1).ranges
.addr
, self
._ranges
2.addr
)
541 def test_at_index_invalid(self
):
542 self
._fc
.append_option(
543 'c', self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
546 with self
.assertRaises(TypeError):
547 self
._fc
.option_at_index('yes')
549 def test_at_index_out_of_bounds_after(self
):
550 self
._fc
.append_option(
551 'c', self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
554 with self
.assertRaises(IndexError):
555 self
._fc
.option_at_index(len(self
._fc
))
557 def _fill_default_fc_for_field_path_test(self
):
558 # Create something equivalent to:
560 # struct outer_struct_fc {
562 # struct inner_struct_fc {
563 # [u]int64_t selector;
566 # variant <selector> {
567 # real a; // selected with self._ranges1
568 # int21_t b; // selected with self._ranges2
569 # uint34_t c; // selected with self._ranges3
573 self
._fc
.append_option('a', self
._tc
.create_real_field_class(), self
._ranges
1)
574 self
._fc
.append_option(
575 'b', self
._tc
.create_signed_integer_field_class(21), self
._ranges
2
577 self
._fc
.append_option(
578 'c', self
._tc
.create_unsigned_integer_field_class(34), self
._ranges
3
581 foo_fc
= self
._tc
.create_real_field_class()
582 bar_fc
= self
._tc
.create_string_field_class()
583 baz_fc
= self
._tc
.create_string_field_class()
585 inner_struct_fc
= self
._tc
.create_structure_field_class()
586 inner_struct_fc
.append_member('selector', self
._selector
_fc
)
587 inner_struct_fc
.append_member('bar', bar_fc
)
588 inner_struct_fc
.append_member('baz', baz_fc
)
589 inner_struct_fc
.append_member('variant', self
._fc
)
591 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
595 outer_struct_fc
= self
._tc
.create_structure_field_class()
596 outer_struct_fc
.append_member('foo', foo_fc
)
597 outer_struct_fc
.append_member('inner_struct', inner_struct_array_fc
)
599 # The path to the selector field is resolved when the sequence is
600 # actually used, for example in a packet context.
601 self
._tc
.create_stream_class(
602 supports_packets
=True, packet_context_field_class
=outer_struct_fc
605 def test_selector_field_path_length(self
):
606 self
._fill
_default
_fc
_for
_field
_path
_test
()
607 self
.assertEqual(len(self
._fc
.selector_field_path
), 3)
609 def test_selector_field_path_iter(self
):
610 self
._fill
_default
_fc
_for
_field
_path
_test
()
611 path_items
= list(self
._fc
.selector_field_path
)
613 self
.assertEqual(len(path_items
), 3)
615 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
616 self
.assertEqual(path_items
[0].index
, 1)
618 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
620 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
621 self
.assertEqual(path_items
[2].index
, 0)
623 def test_selector_field_path_root_scope(self
):
624 self
._fill
_default
_fc
_for
_field
_path
_test
()
626 self
._fc
.selector_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
630 class VariantFieldClassWithUnsignedSelectorTestCase(
631 _VariantFieldClassWithSelectorTestCase
, unittest
.TestCase
633 def _spec_set_up(self
):
634 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
635 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
636 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
637 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, 16), (48, 99)])
638 self
._selector
_fc
= self
._tc
.create_unsigned_integer_field_class()
641 class VariantFieldClassWithSignedSelectorTestCase(
642 _VariantFieldClassWithSelectorTestCase
, unittest
.TestCase
644 def _spec_set_up(self
):
645 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
646 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
647 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(8, 16), (48, 99)])
648 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
649 self
._selector
_fc
= self
._tc
.create_signed_integer_field_class()
652 class StaticArrayFieldClassTestCase(unittest
.TestCase
):
654 self
._tc
= get_default_trace_class()
655 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
657 def test_create_default(self
):
658 fc
= self
._tc
.create_static_array_field_class(self
._elem
_fc
, 45)
659 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
660 self
.assertEqual(fc
.length
, 45)
662 def test_create_invalid_elem_field_class(self
):
663 with self
.assertRaises(TypeError):
664 self
._tc
.create_static_array_field_class(object(), 45)
666 def test_create_invalid_length(self
):
667 with self
.assertRaises(ValueError):
668 self
._tc
.create_static_array_field_class(
669 self
._tc
.create_string_field_class(), -17
672 def test_create_invalid_length_type(self
):
673 with self
.assertRaises(TypeError):
674 self
._tc
.create_static_array_field_class(
675 self
._tc
.create_string_field_class(), 'the length'
679 class DynamicArrayFieldClassTestCase(unittest
.TestCase
):
681 self
._tc
= get_default_trace_class()
682 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
683 self
._len
_fc
= self
._tc
.create_unsigned_integer_field_class(12)
685 def test_create_default(self
):
686 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
)
687 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
688 self
.assertIsNone(fc
.length_field_path
, None)
690 def _create_field_class_for_field_path_test(self
):
691 # Create something a field class that is equivalent to:
693 # struct outer_struct_fc {
695 # struct inner_struct_fc {
699 # uint23_t dyn_array[len];
703 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
, self
._len
_fc
)
705 foo_fc
= self
._tc
.create_real_field_class()
706 bar_fc
= self
._tc
.create_string_field_class()
707 baz_fc
= self
._tc
.create_string_field_class()
709 inner_struct_fc
= self
._tc
.create_structure_field_class()
710 inner_struct_fc
.append_member('bar', bar_fc
)
711 inner_struct_fc
.append_member('baz', baz_fc
)
712 inner_struct_fc
.append_member('len', self
._len
_fc
)
713 inner_struct_fc
.append_member('dyn_array', fc
)
715 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
719 outer_struct_fc
= self
._tc
.create_structure_field_class()
720 outer_struct_fc
.append_member('foo', foo_fc
)
721 outer_struct_fc
.append_member('inner_struct', inner_struct_array_fc
)
723 # The path to the length field is resolved when the sequence is
724 # actually used, for example in a packet context.
725 self
._tc
.create_stream_class(
726 packet_context_field_class
=outer_struct_fc
, supports_packets
=True
731 def test_field_path_len(self
):
732 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
733 self
.assertEqual(len(fc
.length_field_path
), 3)
735 def test_field_path_iter(self
):
736 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
737 path_items
= list(fc
.length_field_path
)
739 self
.assertEqual(len(path_items
), 3)
741 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
742 self
.assertEqual(path_items
[0].index
, 1)
744 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
746 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
747 self
.assertEqual(path_items
[2].index
, 2)
749 def test_field_path_root_scope(self
):
750 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
752 fc
.length_field_path
.root_scope
, bt2
.FieldPathScope
.PACKET_CONTEXT
755 def test_create_invalid_field_class(self
):
756 with self
.assertRaises(TypeError):
757 self
._tc
.create_dynamic_array_field_class(object())
759 def test_create_invalid_length_type(self
):
760 with self
.assertRaises(TypeError):
761 self
._tc
.create_dynamic_array_field_class(
762 self
._tc
.create_string_field_class(), 17
766 if __name__
== "__main__":