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.
23 from utils
import get_default_trace_class
26 class _TestIntegerFieldClassProps
:
27 def test_create_default(self
):
28 fc
= self
._create
_func
()
29 self
.assertEqual(fc
.field_value_range
, 64)
30 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.DECIMAL
)
32 def test_create_range(self
):
33 fc
= self
._create
_func
(field_value_range
=35)
34 self
.assertEqual(fc
.field_value_range
, 35)
36 fc
= self
._create
_func
(36)
37 self
.assertEqual(fc
.field_value_range
, 36)
39 def test_create_invalid_range(self
):
40 with self
.assertRaises(TypeError):
41 self
._create
_func
('yes')
43 with self
.assertRaises(TypeError):
44 self
._create
_func
(field_value_range
='yes')
46 with self
.assertRaises(ValueError):
47 self
._create
_func
(field_value_range
=-2)
49 with self
.assertRaises(ValueError):
50 self
._create
_func
(field_value_range
=0)
52 def test_create_base(self
):
53 fc
= self
._create
_func
(
54 preferred_display_base
=bt2
.IntegerDisplayBase
.HEXADECIMAL
56 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.HEXADECIMAL
)
58 def test_create_invalid_base_type(self
):
59 with self
.assertRaises(TypeError):
60 self
._create
_func
(preferred_display_base
='yes')
62 def test_create_invalid_base_value(self
):
63 with self
.assertRaises(ValueError):
64 self
._create
_func
(preferred_display_base
=444)
66 def test_create_full(self
):
67 fc
= self
._create
_func
(24, preferred_display_base
=bt2
.IntegerDisplayBase
.OCTAL
)
68 self
.assertEqual(fc
.field_value_range
, 24)
69 self
.assertEqual(fc
.preferred_display_base
, bt2
.IntegerDisplayBase
.OCTAL
)
72 class IntegerFieldClassTestCase(_TestIntegerFieldClassProps
, unittest
.TestCase
):
74 self
._tc
= get_default_trace_class()
75 self
._create
_func
= self
._tc
.create_signed_integer_field_class
78 class RealFieldClassTestCase(unittest
.TestCase
):
80 self
._tc
= get_default_trace_class()
82 def test_create_default(self
):
83 fc
= self
._tc
.create_real_field_class()
84 self
.assertFalse(fc
.is_single_precision
)
86 def test_create_is_single_precision(self
):
87 fc
= self
._tc
.create_real_field_class(is_single_precision
=True)
88 self
.assertTrue(fc
.is_single_precision
)
90 def test_create_invalid_is_single_precision(self
):
91 with self
.assertRaises(TypeError):
92 self
._tc
.create_real_field_class(is_single_precision
='hohoho')
95 # Converts an _EnumerationFieldClassMapping to a list of ranges:
97 # [(lower0, upper0), (lower1, upper1), ...]
100 def enum_mapping_to_set(mapping
):
101 return {(x
.lower
, x
.upper
) for x
in mapping
.ranges
}
104 class _EnumerationFieldClassTestCase(_TestIntegerFieldClassProps
):
106 self
._tc
= get_default_trace_class()
108 self
._fc
= self
._create
_func
()
110 def test_create_from_invalid_type(self
):
111 with self
.assertRaises(TypeError):
112 self
._create
_func
('coucou')
114 def test_add_mapping_simple(self
):
115 self
._fc
.add_mapping('hello', self
._ranges
1)
116 mapping
= self
._fc
['hello']
117 self
.assertEqual(mapping
.label
, 'hello')
118 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
120 def test_add_mapping_simple_kwargs(self
):
121 self
._fc
.add_mapping(label
='hello', ranges
=self
._ranges
1)
122 mapping
= self
._fc
['hello']
123 self
.assertEqual(mapping
.label
, 'hello')
124 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
126 def test_add_mapping_invalid_name(self
):
127 with self
.assertRaises(TypeError):
128 self
._fc
.add_mapping(17, self
._ranges
1)
130 def test_add_mapping_invalid_range(self
):
131 with self
.assertRaises(TypeError):
132 self
._fc
.add_mapping('allo', 'meow')
134 def test_add_mapping_dup_label(self
):
135 with self
.assertRaises(ValueError):
136 self
._fc
.add_mapping('a', self
._ranges
1)
137 self
._fc
.add_mapping('a', self
._ranges
2)
139 def test_add_mapping_invalid_ranges_signedness(self
):
140 with self
.assertRaises(TypeError):
141 self
._fc
.add_mapping('allo', self
._inval
_ranges
)
144 self
._fc
.add_mapping('c', self
._ranges
1)
146 self
._fc
+= [('d', self
._ranges
2), ('e', self
._ranges
3)]
148 self
.assertEqual(len(self
._fc
), 3)
149 self
.assertEqual(self
._fc
['c'].label
, 'c')
150 self
.assertEqual(self
._fc
['c'].ranges
, self
._ranges
1)
151 self
.assertEqual(self
._fc
['d'].label
, 'd')
152 self
.assertEqual(self
._fc
['d'].ranges
, self
._ranges
2)
153 self
.assertEqual(self
._fc
['e'].label
, 'e')
154 self
.assertEqual(self
._fc
['e'].ranges
, self
._ranges
3)
156 def test_bool_op(self
):
157 self
.assertFalse(self
._fc
)
158 self
._fc
.add_mapping('a', self
._ranges
1)
159 self
.assertTrue(self
._fc
)
162 self
._fc
.add_mapping('a', self
._ranges
1)
163 self
._fc
.add_mapping('b', self
._ranges
2)
164 self
._fc
.add_mapping('c', self
._ranges
3)
165 self
.assertEqual(len(self
._fc
), 3)
167 def test_getitem(self
):
168 self
._fc
.add_mapping('a', self
._ranges
1)
169 self
._fc
.add_mapping('b', self
._ranges
2)
170 self
._fc
.add_mapping('c', self
._ranges
3)
171 mapping
= self
._fc
['a']
172 self
.assertEqual(mapping
.label
, 'a')
173 self
.assertEqual(mapping
.ranges
, self
._ranges
1)
175 def test_getitem_nonexistent(self
):
176 with self
.assertRaises(KeyError):
177 self
._fc
['doesnotexist']
180 self
._fc
.add_mapping('a', self
._ranges
1)
181 self
._fc
.add_mapping('b', self
._ranges
2)
182 self
._fc
.add_mapping('c', self
._ranges
3)
184 # This exercises iteration.
185 labels
= sorted(self
._fc
)
187 self
.assertEqual(labels
, ['a', 'b', 'c'])
189 def test_find_by_value(self
):
190 self
._fc
.add_mapping('a', self
._ranges
1)
191 self
._fc
.add_mapping('b', self
._ranges
2)
192 self
._fc
.add_mapping('c', self
._ranges
3)
193 mappings
= self
._fc
.mappings_for_value(self
._value
_in
_range
_1_and
_3)
194 labels
= set([mapping
.label
for mapping
in mappings
])
195 expected_labels
= set(['a', 'c'])
196 self
.assertEqual(labels
, expected_labels
)
199 class UnsignedEnumerationFieldClassTestCase(
200 _EnumerationFieldClassTestCase
, unittest
.TestCase
202 def _spec_set_up(self
):
203 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
204 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
205 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 22), (48, 99)])
206 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, -5), (48, 1928)])
207 self
._value
_in
_range
_1_and
_3 = 20
208 self
._create
_func
= self
._tc
.create_unsigned_enumeration_field_class
211 class SignedEnumerationFieldClassTestCase(
212 _EnumerationFieldClassTestCase
, unittest
.TestCase
214 def _spec_set_up(self
):
215 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
216 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
217 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(-100, -1), (8, 16), (48, 99)])
218 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
219 self
._value
_in
_range
_1_and
_3 = -7
220 self
._create
_func
= self
._tc
.create_signed_enumeration_field_class
223 class StringFieldClassTestCase(unittest
.TestCase
):
225 tc
= get_default_trace_class()
226 self
._fc
= tc
.create_string_field_class()
228 def test_create_default(self
):
229 self
.assertIsNotNone(self
._fc
)
232 class _TestElementContainer
:
234 self
._tc
= get_default_trace_class()
235 self
._fc
= self
._create
_default
_fc
()
237 def test_create_default(self
):
238 self
.assertIsNotNone(self
._fc
)
240 def test_append_element(self
):
241 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
242 self
._append
_element
_method
(self
._fc
, 'int32', int_field_class
)
243 field_class
= self
._fc
['int32'].field_class
244 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
246 def test_append_element_kwargs(self
):
247 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
248 self
._append
_element
_method
(self
._fc
, name
='int32', field_class
=int_field_class
)
249 field_class
= self
._fc
['int32'].field_class
250 self
.assertEqual(field_class
.addr
, int_field_class
.addr
)
252 def test_append_element_invalid_name(self
):
253 sub_fc
= self
._tc
.create_string_field_class()
255 with self
.assertRaises(TypeError):
256 self
._append
_element
_method
(self
._fc
, 23, sub_fc
)
258 def test_append_element_invalid_field_class(self
):
259 with self
.assertRaises(TypeError):
260 self
._append
_element
_method
(self
._fc
, 'yes', object())
262 def test_append_element_dup_name(self
):
263 sub_fc1
= self
._tc
.create_string_field_class()
264 sub_fc2
= self
._tc
.create_string_field_class()
266 with self
.assertRaises(ValueError):
267 self
._append
_element
_method
(self
._fc
, 'yes', sub_fc1
)
268 self
._append
_element
_method
(self
._fc
, 'yes', sub_fc2
)
271 other_fc
= self
._create
_default
_fc
()
272 a_field_class
= self
._tc
.create_real_field_class()
273 b_field_class
= self
._tc
.create_signed_integer_field_class(17)
274 self
._append
_element
_method
(self
._fc
, 'a_float', a_field_class
)
275 self
._append
_element
_method
(self
._fc
, 'b_int', b_field_class
)
276 c_field_class
= self
._tc
.create_string_field_class()
277 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
280 e_field_class
= self
._tc
.create_structure_field_class()
282 ('c_string', c_field_class
),
283 ('d_enum', d_field_class
),
284 ('e_struct', e_field_class
),
286 self
.assertEqual(self
._fc
['a_float'].field_class
.addr
, a_field_class
.addr
)
287 self
.assertEqual(self
._fc
['a_float'].name
, 'a_float')
288 self
.assertEqual(self
._fc
['b_int'].field_class
.addr
, b_field_class
.addr
)
289 self
.assertEqual(self
._fc
['b_int'].name
, 'b_int')
290 self
.assertEqual(self
._fc
['c_string'].field_class
.addr
, c_field_class
.addr
)
291 self
.assertEqual(self
._fc
['c_string'].name
, 'c_string')
292 self
.assertEqual(self
._fc
['d_enum'].field_class
.addr
, d_field_class
.addr
)
293 self
.assertEqual(self
._fc
['d_enum'].name
, 'd_enum')
294 self
.assertEqual(self
._fc
['e_struct'].field_class
.addr
, e_field_class
.addr
)
295 self
.assertEqual(self
._fc
['e_struct'].name
, 'e_struct')
297 def test_bool_op(self
):
298 self
.assertFalse(self
._fc
)
299 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
300 self
.assertTrue(self
._fc
)
303 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
304 self
._append
_element
_method
(self
._fc
, 'b', self
._tc
.create_string_field_class())
305 self
._append
_element
_method
(self
._fc
, 'c', self
._tc
.create_string_field_class())
306 self
.assertEqual(len(self
._fc
), 3)
308 def test_getitem(self
):
309 a_fc
= self
._tc
.create_signed_integer_field_class(32)
310 b_fc
= self
._tc
.create_string_field_class()
311 c_fc
= self
._tc
.create_real_field_class()
312 self
._append
_element
_method
(self
._fc
, 'a', a_fc
)
313 self
._append
_element
_method
(self
._fc
, 'b', b_fc
)
314 self
._append
_element
_method
(self
._fc
, 'c', c_fc
)
315 self
.assertEqual(self
._fc
['b'].field_class
.addr
, b_fc
.addr
)
316 self
.assertEqual(self
._fc
['b'].name
, 'b')
318 def test_getitem_invalid_key_type(self
):
319 with self
.assertRaises(TypeError):
322 def test_getitem_invalid_key(self
):
323 with self
.assertRaises(KeyError):
326 def test_contains(self
):
327 self
.assertFalse('a' in self
._fc
)
328 self
._append
_element
_method
(self
._fc
, 'a', self
._tc
.create_string_field_class())
329 self
.assertTrue('a' in self
._fc
)
332 a_fc
= self
._tc
.create_signed_integer_field_class(32)
333 b_fc
= self
._tc
.create_string_field_class()
334 c_fc
= self
._tc
.create_real_field_class()
335 elements
= (('a', a_fc
), ('b', b_fc
), ('c', c_fc
))
337 for elem
in elements
:
338 self
._append
_element
_method
(self
._fc
, *elem
)
340 for (name
, element
), test_elem
in zip(self
._fc
.items(), elements
):
341 self
.assertEqual(element
.name
, test_elem
[0])
342 self
.assertEqual(name
, element
.name
)
343 self
.assertEqual(element
.field_class
.addr
, test_elem
[1].addr
)
345 def test_at_index(self
):
346 a_fc
= self
._tc
.create_signed_integer_field_class(32)
347 b_fc
= self
._tc
.create_string_field_class()
348 c_fc
= self
._tc
.create_real_field_class()
349 self
._append
_element
_method
(self
._fc
, 'c', c_fc
)
350 self
._append
_element
_method
(self
._fc
, 'a', a_fc
)
351 self
._append
_element
_method
(self
._fc
, 'b', b_fc
)
352 elem
= self
._at
_index
_method
(self
._fc
, 1)
353 self
.assertEqual(elem
.field_class
.addr
, a_fc
.addr
)
354 self
.assertEqual(elem
.name
, 'a')
356 def test_at_index_invalid(self
):
357 self
._append
_element
_method
(
358 self
._fc
, 'c', self
._tc
.create_signed_integer_field_class(32)
361 with self
.assertRaises(TypeError):
362 self
._at
_index
_method
(self
._fc
, 'yes')
364 def test_at_index_out_of_bounds_after(self
):
365 self
._append
_element
_method
(
366 self
._fc
, 'c', self
._tc
.create_signed_integer_field_class(32)
369 with self
.assertRaises(IndexError):
370 self
._at
_index
_method
(self
._fc
, len(self
._fc
))
373 class StructureFieldClassTestCase(_TestElementContainer
, unittest
.TestCase
):
374 _append_element_method
= staticmethod(bt2
._StructureFieldClass
.append_member
)
375 _at_index_method
= staticmethod(bt2
._StructureFieldClass
.member_at_index
)
377 def _create_default_fc(self
):
378 return self
._tc
.create_structure_field_class()
381 class VariantFieldClassWithoutSelectorTestCase(
382 _TestElementContainer
, unittest
.TestCase
384 _append_element_method
= staticmethod(
385 bt2
._VariantFieldClassWithoutSelector
.append_option
387 _at_index_method
= staticmethod(
388 bt2
._VariantFieldClassWithoutSelector
.option_at_index
391 def _create_default_fc(self
):
392 return self
._tc
.create_variant_field_class()
395 class _VariantFieldClassWithSelectorTestCase
:
397 self
._tc
= get_default_trace_class()
399 self
._fc
= self
._create
_default
_fc
()
401 def _create_default_fc(self
):
402 return self
._tc
.create_variant_field_class(self
._selector
_fc
)
404 def test_create_default(self
):
405 self
.assertIsNotNone(self
._fc
)
407 def test_append_element(self
):
408 str_field_class
= self
._tc
.create_string_field_class()
409 self
._fc
.append_option('str', str_field_class
, self
._ranges
1)
410 opt
= self
._fc
['str']
411 self
.assertEqual(opt
.field_class
.addr
, str_field_class
.addr
)
412 self
.assertEqual(opt
.name
, 'str')
413 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
415 def test_append_element_kwargs(self
):
416 int_field_class
= self
._tc
.create_signed_integer_field_class(32)
417 self
._fc
.append_option(
418 name
='int32', field_class
=int_field_class
, ranges
=self
._ranges
1
420 opt
= self
._fc
['int32']
421 self
.assertEqual(opt
.field_class
.addr
, int_field_class
.addr
)
422 self
.assertEqual(opt
.name
, 'int32')
423 self
.assertEqual(opt
.ranges
.addr
, self
._ranges
1.addr
)
425 def test_append_element_invalid_name(self
):
426 sub_fc
= self
._tc
.create_string_field_class()
428 with self
.assertRaises(TypeError):
429 self
._fc
.append_option(self
._fc
, 23, sub_fc
)
431 def test_append_element_invalid_field_class(self
):
432 with self
.assertRaises(TypeError):
433 self
._fc
.append_option(self
._fc
, 'yes', object())
435 def test_append_element_invalid_ranges(self
):
436 sub_fc
= self
._tc
.create_string_field_class()
438 with self
.assertRaises(TypeError):
439 self
._fc
.append_option(self
._fc
, sub_fc
, 'lel')
441 def test_append_element_dup_name(self
):
442 sub_fc1
= self
._tc
.create_string_field_class()
443 sub_fc2
= self
._tc
.create_string_field_class()
445 with self
.assertRaises(ValueError):
446 self
._fc
.append_option('yes', sub_fc1
, self
._ranges
1)
447 self
._fc
.append_option('yes', sub_fc2
, self
._ranges
2)
449 def test_append_element_invalid_ranges_signedness(self
):
450 sub_fc
= self
._tc
.create_string_field_class()
452 with self
.assertRaises(TypeError):
453 self
._fc
.append_option(self
._fc
, sub_fc
, self
._inval
_ranges
)
456 other_fc
= self
._create
_default
_fc
()
457 a_field_class
= self
._tc
.create_real_field_class()
458 self
._fc
.append_option('a_float', a_field_class
, self
._ranges
1)
459 c_field_class
= self
._tc
.create_string_field_class()
460 d_field_class
= self
._tc
.create_signed_enumeration_field_class(
464 ('c_string', c_field_class
, self
._ranges
2),
465 ('d_enum', d_field_class
, self
._ranges
3),
467 self
.assertEqual(self
._fc
['a_float'].field_class
.addr
, a_field_class
.addr
)
468 self
.assertEqual(self
._fc
['a_float'].name
, 'a_float')
469 self
.assertEqual(self
._fc
['a_float'].ranges
, self
._ranges
1)
470 self
.assertEqual(self
._fc
['c_string'].field_class
.addr
, c_field_class
.addr
)
471 self
.assertEqual(self
._fc
['c_string'].name
, 'c_string')
472 self
.assertEqual(self
._fc
['c_string'].ranges
, self
._ranges
2)
473 self
.assertEqual(self
._fc
['d_enum'].field_class
.addr
, d_field_class
.addr
)
474 self
.assertEqual(self
._fc
['d_enum'].name
, 'd_enum')
475 self
.assertEqual(self
._fc
['d_enum'].ranges
, self
._ranges
3)
477 def test_bool_op(self
):
478 self
.assertFalse(self
._fc
)
479 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
480 self
.assertTrue(self
._fc
)
483 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
484 self
._fc
.append_option('b', self
._tc
.create_string_field_class(), self
._ranges
2)
485 self
._fc
.append_option('c', self
._tc
.create_string_field_class(), self
._ranges
3)
486 self
.assertEqual(len(self
._fc
), 3)
488 def test_getitem(self
):
489 a_fc
= self
._tc
.create_signed_integer_field_class(32)
490 b_fc
= self
._tc
.create_string_field_class()
491 c_fc
= self
._tc
.create_real_field_class()
492 self
._fc
.append_option('a', a_fc
, self
._ranges
1)
493 self
._fc
.append_option('b', b_fc
, self
._ranges
2)
494 self
._fc
.append_option('c', c_fc
, self
._ranges
3)
495 self
.assertEqual(self
._fc
['b'].field_class
.addr
, b_fc
.addr
)
496 self
.assertEqual(self
._fc
['b'].name
, 'b')
497 self
.assertEqual(self
._fc
['b'].ranges
.addr
, self
._ranges
2.addr
)
499 def test_getitem_invalid_key_type(self
):
500 with self
.assertRaises(TypeError):
503 def test_getitem_invalid_key(self
):
504 with self
.assertRaises(KeyError):
507 def test_contains(self
):
508 self
.assertFalse('a' in self
._fc
)
509 self
._fc
.append_option('a', self
._tc
.create_string_field_class(), self
._ranges
1)
510 self
.assertTrue('a' in self
._fc
)
513 a_fc
= self
._tc
.create_signed_integer_field_class(32)
514 b_fc
= self
._tc
.create_string_field_class()
515 c_fc
= self
._tc
.create_real_field_class()
517 ('a', a_fc
, self
._ranges
1),
518 ('b', b_fc
, self
._ranges
2),
519 ('c', c_fc
, self
._ranges
3),
523 self
._fc
.append_option(*opt
)
525 for (name
, opt
), test_opt
in zip(self
._fc
.items(), opts
):
526 self
.assertEqual(opt
.name
, test_opt
[0])
527 self
.assertEqual(name
, opt
.name
)
528 self
.assertEqual(opt
.field_class
.addr
, test_opt
[1].addr
)
529 self
.assertEqual(opt
.ranges
.addr
, test_opt
[2].addr
)
531 def test_at_index(self
):
532 a_fc
= self
._tc
.create_signed_integer_field_class(32)
533 b_fc
= self
._tc
.create_string_field_class()
534 c_fc
= self
._tc
.create_real_field_class()
535 self
._fc
.append_option('c', c_fc
, self
._ranges
1)
536 self
._fc
.append_option('a', a_fc
, self
._ranges
2)
537 self
._fc
.append_option('b', b_fc
, self
._ranges
3)
538 self
.assertEqual(self
._fc
.option_at_index(1).field_class
.addr
, a_fc
.addr
)
539 self
.assertEqual(self
._fc
.option_at_index(1).name
, 'a')
540 self
.assertEqual(self
._fc
.option_at_index(1).ranges
.addr
, self
._ranges
2.addr
)
542 def test_at_index_invalid(self
):
543 self
._fc
.append_option(
544 'c', self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
547 with self
.assertRaises(TypeError):
548 self
._fc
.option_at_index('yes')
550 def test_at_index_out_of_bounds_after(self
):
551 self
._fc
.append_option(
552 'c', self
._tc
.create_signed_integer_field_class(32), self
._ranges
3
555 with self
.assertRaises(IndexError):
556 self
._fc
.option_at_index(len(self
._fc
))
558 def _fill_default_fc_for_field_path_test(self
):
559 # Create something equivalent to:
561 # struct outer_struct_fc {
563 # struct inner_struct_fc {
564 # [u]int64_t selector;
567 # variant <selector> {
568 # real a; // selected with self._ranges1
569 # int21_t b; // selected with self._ranges2
570 # uint34_t c; // selected with self._ranges3
574 self
._fc
.append_option('a', self
._tc
.create_real_field_class(), self
._ranges
1)
575 self
._fc
.append_option(
576 'b', self
._tc
.create_signed_integer_field_class(21), self
._ranges
2
578 self
._fc
.append_option(
579 'c', self
._tc
.create_unsigned_integer_field_class(34), self
._ranges
3
582 foo_fc
= self
._tc
.create_real_field_class()
583 bar_fc
= self
._tc
.create_string_field_class()
584 baz_fc
= self
._tc
.create_string_field_class()
586 inner_struct_fc
= self
._tc
.create_structure_field_class()
587 inner_struct_fc
.append_member('selector', self
._selector
_fc
)
588 inner_struct_fc
.append_member('bar', bar_fc
)
589 inner_struct_fc
.append_member('baz', baz_fc
)
590 inner_struct_fc
.append_member('variant', self
._fc
)
592 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
596 outer_struct_fc
= self
._tc
.create_structure_field_class()
597 outer_struct_fc
.append_member('foo', foo_fc
)
598 outer_struct_fc
.append_member('inner_struct', inner_struct_array_fc
)
600 # The path to the selector field is resolved when the sequence is
601 # actually used, for example in a packet context.
602 self
._tc
.create_stream_class(
603 supports_packets
=True, packet_context_field_class
=outer_struct_fc
606 def test_selector_field_path_length(self
):
607 self
._fill
_default
_fc
_for
_field
_path
_test
()
608 self
.assertEqual(len(self
._fc
.selector_field_path
), 3)
610 def test_selector_field_path_iter(self
):
611 self
._fill
_default
_fc
_for
_field
_path
_test
()
612 path_items
= list(self
._fc
.selector_field_path
)
614 self
.assertEqual(len(path_items
), 3)
616 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
617 self
.assertEqual(path_items
[0].index
, 1)
619 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
621 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
622 self
.assertEqual(path_items
[2].index
, 0)
624 def test_selector_field_path_root_scope(self
):
625 self
._fill
_default
_fc
_for
_field
_path
_test
()
627 self
._fc
.selector_field_path
.root_scope
, bt2
.Scope
.PACKET_CONTEXT
631 class VariantFieldClassWithUnsignedSelectorTestCase(
632 _VariantFieldClassWithSelectorTestCase
, unittest
.TestCase
634 def _spec_set_up(self
):
635 self
._ranges
1 = bt2
.UnsignedIntegerRangeSet([(1, 4), (18, 47)])
636 self
._ranges
2 = bt2
.UnsignedIntegerRangeSet([(5, 5)])
637 self
._ranges
3 = bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
638 self
._inval
_ranges
= bt2
.SignedIntegerRangeSet([(-8, 16), (48, 99)])
639 self
._selector
_fc
= self
._tc
.create_unsigned_integer_field_class()
642 class VariantFieldClassWithSignedSelectorTestCase(
643 _VariantFieldClassWithSelectorTestCase
, unittest
.TestCase
645 def _spec_set_up(self
):
646 self
._ranges
1 = bt2
.SignedIntegerRangeSet([(-10, -4), (18, 47)])
647 self
._ranges
2 = bt2
.SignedIntegerRangeSet([(-3, -3)])
648 self
._ranges
3 = bt2
.SignedIntegerRangeSet([(8, 16), (48, 99)])
649 self
._inval
_ranges
= bt2
.UnsignedIntegerRangeSet([(8, 16), (48, 99)])
650 self
._selector
_fc
= self
._tc
.create_signed_integer_field_class()
653 class StaticArrayFieldClassTestCase(unittest
.TestCase
):
655 self
._tc
= get_default_trace_class()
656 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
658 def test_create_default(self
):
659 fc
= self
._tc
.create_static_array_field_class(self
._elem
_fc
, 45)
660 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
661 self
.assertEqual(fc
.length
, 45)
663 def test_create_invalid_elem_field_class(self
):
664 with self
.assertRaises(TypeError):
665 self
._tc
.create_static_array_field_class(object(), 45)
667 def test_create_invalid_length(self
):
668 with self
.assertRaises(ValueError):
669 self
._tc
.create_static_array_field_class(
670 self
._tc
.create_string_field_class(), -17
673 def test_create_invalid_length_type(self
):
674 with self
.assertRaises(TypeError):
675 self
._tc
.create_static_array_field_class(
676 self
._tc
.create_string_field_class(), 'the length'
680 class DynamicArrayFieldClassTestCase(unittest
.TestCase
):
682 self
._tc
= get_default_trace_class()
683 self
._elem
_fc
= self
._tc
.create_signed_integer_field_class(23)
684 self
._len
_fc
= self
._tc
.create_unsigned_integer_field_class(12)
686 def test_create_default(self
):
687 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
)
688 self
.assertEqual(fc
.element_field_class
.addr
, self
._elem
_fc
.addr
)
689 self
.assertIsNone(fc
.length_field_path
, None)
691 def _create_field_class_for_field_path_test(self
):
692 # Create something a field class that is equivalent to:
694 # struct outer_struct_fc {
696 # struct inner_struct_fc {
700 # uint23_t dyn_array[len];
704 fc
= self
._tc
.create_dynamic_array_field_class(self
._elem
_fc
, self
._len
_fc
)
706 foo_fc
= self
._tc
.create_real_field_class()
707 bar_fc
= self
._tc
.create_string_field_class()
708 baz_fc
= self
._tc
.create_string_field_class()
710 inner_struct_fc
= self
._tc
.create_structure_field_class()
711 inner_struct_fc
.append_member('bar', bar_fc
)
712 inner_struct_fc
.append_member('baz', baz_fc
)
713 inner_struct_fc
.append_member('len', self
._len
_fc
)
714 inner_struct_fc
.append_member('dyn_array', fc
)
716 inner_struct_array_fc
= self
._tc
.create_static_array_field_class(
720 outer_struct_fc
= self
._tc
.create_structure_field_class()
721 outer_struct_fc
.append_member('foo', foo_fc
)
722 outer_struct_fc
.append_member('inner_struct', inner_struct_array_fc
)
724 # The path to the length field is resolved when the sequence is
725 # actually used, for example in a packet context.
726 self
._tc
.create_stream_class(
727 packet_context_field_class
=outer_struct_fc
, supports_packets
=True
732 def test_field_path_len(self
):
733 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
734 self
.assertEqual(len(fc
.length_field_path
), 3)
736 def test_field_path_iter(self
):
737 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
738 path_items
= list(fc
.length_field_path
)
740 self
.assertEqual(len(path_items
), 3)
742 self
.assertIsInstance(path_items
[0], bt2
._IndexFieldPathItem
)
743 self
.assertEqual(path_items
[0].index
, 1)
745 self
.assertIsInstance(path_items
[1], bt2
._CurrentArrayElementFieldPathItem
)
747 self
.assertIsInstance(path_items
[2], bt2
._IndexFieldPathItem
)
748 self
.assertEqual(path_items
[2].index
, 2)
750 def test_field_path_root_scope(self
):
751 fc
= self
._create
_field
_class
_for
_field
_path
_test
()
752 self
.assertEqual(fc
.length_field_path
.root_scope
, bt2
.Scope
.PACKET_CONTEXT
)
754 def test_create_invalid_field_class(self
):
755 with self
.assertRaises(TypeError):
756 self
._tc
.create_dynamic_array_field_class(object())
758 def test_create_invalid_length_type(self
):
759 with self
.assertRaises(TypeError):
760 self
._tc
.create_dynamic_array_field_class(
761 self
._tc
.create_string_field_class(), 17
765 if __name__
== "__main__":