8 class _MyIter(bt2
._UserMessageIterator
):
9 def __init__(self
, self_output_port
):
13 def _build_meta(self
):
14 self
._tc
= self
._component
._create
_trace
_class
()
16 self
._sc
= self
._tc
.create_stream_class()
17 self
._ec
= self
._sc
.create_event_class(name
='salut')
18 self
._my
_int
_ft
= self
._tc
.create_signed_integer_field_class(32)
19 payload_ft
= self
._tc
.create_structure_field_class()
20 payload_ft
+= collections
.OrderedDict([
21 ('my_int', self
._my
_int
_ft
),
23 self
._ec
.payload_field_type
= payload_ft
24 self
._stream
= self
._t
.create_stream(self
._sc
)
25 self
._packet
= self
._stream
.create_packet()
27 def _create_event(self
, value
):
29 ev
.payload_field
['my_int'] = value
30 ev
.packet
= self
._packet
34 class GraphTestCase(unittest
.TestCase
):
36 self
._graph
= bt2
.Graph()
41 def test_create_empty(self
):
44 def test_add_component_user_cls(self
):
45 class MySink(bt2
._UserSinkComponent
):
49 comp
= self
._graph
.add_component(MySink
, 'salut')
50 self
.assertEqual(comp
.name
, 'salut')
52 def test_add_component_gen_cls(self
):
53 class MySink(bt2
._UserSinkComponent
):
57 comp
= self
._graph
.add_component(MySink
, 'salut')
59 comp2
= self
._graph
.add_component(comp
.cls
, 'salut2')
60 self
.assertEqual(comp2
.name
, 'salut2')
62 def test_add_component_params(self
):
65 class MySink(bt2
._UserSinkComponent
):
66 def __init__(self
, params
):
73 params
= {'hello': 23, 'path': '/path/to/stuff'}
74 comp
= self
._graph
.add_component(MySink
, 'salut', params
)
75 self
.assertEqual(params
, comp_params
)
78 def test_add_component_invalid_cls_type(self
):
79 with self
.assertRaises(TypeError):
80 self
._graph
.add_component(int, 'salut')
82 def test_add_component_invalid_logging_level_type(self
):
83 class MySink(bt2
._UserSinkComponent
):
87 with self
.assertRaises(TypeError):
88 self
._graph
.add_component(MySink
, 'salut', logging_level
='yo')
90 def test_add_component_invalid_logging_level_value(self
):
91 class MySink(bt2
._UserSinkComponent
):
95 with self
.assertRaises(ValueError):
96 self
._graph
.add_component(MySink
, 'salut', logging_level
=12345)
98 def test_add_component_logging_level(self
):
99 class MySink(bt2
._UserSinkComponent
):
103 comp
= self
._graph
.add_component(MySink
, 'salut',
104 logging_level
=bt2
.LoggingLevel
.DEBUG
)
105 self
.assertEqual(comp
.logging_level
, bt2
.LoggingLevel
.DEBUG
)
107 def test_connect_ports(self
):
108 class MyIter(bt2
._UserMessageIterator
):
112 class MySource(bt2
._UserSourceComponent
,
113 message_iterator_class
=MyIter
):
114 def __init__(self
, params
):
115 self
._add
_output
_port
('out')
117 class MySink(bt2
._UserSinkComponent
):
118 def __init__(self
, params
):
119 self
._add
_input
_port
('in')
124 src
= self
._graph
.add_component(MySource
, 'src')
125 sink
= self
._graph
.add_component(MySink
, 'sink')
127 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
128 sink
.input_ports
['in'])
129 self
.assertTrue(src
.output_ports
['out'].is_connected
)
130 self
.assertTrue(sink
.input_ports
['in'].is_connected
)
131 self
.assertEqual(src
.output_ports
['out'].connection
._ptr
, conn
._ptr
)
132 self
.assertEqual(sink
.input_ports
['in'].connection
._ptr
, conn
._ptr
)
134 def test_connect_ports_invalid_direction(self
):
135 class MyIter(bt2
._UserMessageIterator
):
139 class MySource(bt2
._UserSourceComponent
,
140 message_iterator_class
=MyIter
):
141 def __init__(self
, params
):
142 self
._add
_output
_port
('out')
144 class MySink(bt2
._UserSinkComponent
):
145 def __init__(self
, params
):
146 self
._add
_input
_port
('in')
151 src
= self
._graph
.add_component(MySource
, 'src')
152 sink
= self
._graph
.add_component(MySink
, 'sink')
154 with self
.assertRaises(TypeError):
155 conn
= self
._graph
.connect_ports(sink
.input_ports
['in'],
156 src
.output_ports
['out'])
158 def test_connect_ports_refused(self
):
159 class MyIter(bt2
._UserMessageIterator
):
163 class MySource(bt2
._UserSourceComponent
,
164 message_iterator_class
=MyIter
):
165 def __init__(self
, params
):
166 self
._add
_output
_port
('out')
168 class MySink(bt2
._UserSinkComponent
):
169 def __init__(self
, params
):
170 self
._add
_input
_port
('in')
175 def _accept_port_connection(self
, port
, other_port
):
178 src
= self
._graph
.add_component(MySource
, 'src')
179 sink
= self
._graph
.add_component(MySink
, 'sink')
181 with self
.assertRaises(bt2
.PortConnectionRefused
):
182 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
183 sink
.input_ports
['in'])
185 def test_cancel(self
):
186 self
.assertFalse(self
._graph
.is_canceled
)
188 self
.assertTrue(self
._graph
.is_canceled
)
190 # Test that Graph.run() raises bt2.GraphCanceled if the graph gets canceled
192 def test_cancel_while_running(self
):
193 class MyIter(_MyIter
):
195 return self
._create
_stream
_beginning
_message
(self
._stream
)
197 class MySource(bt2
._UserSourceComponent
,
198 message_iterator_class
=MyIter
):
199 def __init__(self
, params
):
200 self
._add
_output
_port
('out')
202 class MySink(bt2
._UserSinkComponent
):
203 def __init__(self
, params
):
204 self
._add
_input
_port
('in')
207 # Pretend that somebody asynchronously cancelled the graph.
211 return next(self
._msg
_iter
)
213 def _graph_is_configured(self
):
214 self
._msg
_iter
= self
._input
_ports
['in'].create_message_iterator()
217 up
= graph
.add_component(MySource
, 'down')
218 down
= graph
.add_component(MySink
, 'up')
219 graph
.connect_ports(up
.output_ports
['out'], down
.input_ports
['in'])
220 with self
.assertRaises(bt2
.GraphCanceled
):
224 class MyIter(_MyIter
):
230 msg
= self
._create
_stream
_beginning
_message
(self
._stream
)
232 msg
= self
._create
_packet
_beginning
_message
(self
._packet
)
234 msg
= self
._create
_packet
_end
_message
(self
._packet
)
236 msg
= self
._create
_stream
_end
_message
(self
._stream
)
238 msg
= self
._create
_event
_message
(self
._ec
, self
._packet
)
243 class MySource(bt2
._UserSourceComponent
,
244 message_iterator_class
=MyIter
):
245 def __init__(self
, params
):
246 self
._add
_output
_port
('out')
248 class MySink(bt2
._UserSinkComponent
):
249 def __init__(self
, params
):
250 self
._input
_port
= self
._add
_input
_port
('in')
253 def _consume(comp_self
):
254 msg
= next(comp_self
._msg
_iter
)
256 if comp_self
._at
== 0:
257 self
.assertIsInstance(msg
, bt2
.message
._StreamBeginningMessage
)
258 elif comp_self
._at
== 1:
259 self
.assertIsInstance(msg
, bt2
.message
._PacketBeginningMessage
)
260 elif comp_self
._at
>= 2 and comp_self
._at
<= 6:
261 self
.assertIsInstance(msg
, bt2
.message
._EventMessage
)
262 self
.assertEqual(msg
.event
.cls
.name
, 'salut')
263 elif comp_self
._at
== 7:
264 self
.assertIsInstance(msg
, bt2
.message
._PacketEndMessage
)
265 elif comp_self
._at
== 8:
266 self
.assertIsInstance(msg
, bt2
.message
._StreamEndMessage
)
270 def _graph_is_configured(self
):
271 self
._msg
_iter
= self
._input
_port
.create_message_iterator()
273 src
= self
._graph
.add_component(MySource
, 'src')
274 sink
= self
._graph
.add_component(MySink
, 'sink')
275 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
276 sink
.input_ports
['in'])
279 def test_run_again(self
):
280 class MyIter(_MyIter
):
286 msg
= self
._create
_stream
_beginning
_message
(self
._stream
)
288 msg
= self
._create
_packet
_beginning
_message
(self
._packet
)
290 msg
= self
._create
_event
_message
(self
._ec
, self
._packet
)
295 class MySource(bt2
._UserSourceComponent
,
296 message_iterator_class
=MyIter
):
297 def __init__(self
, params
):
298 self
._add
_output
_port
('out')
300 class MySink(bt2
._UserSinkComponent
):
301 def __init__(self
, params
):
302 self
._input
_port
= self
._add
_input
_port
('in')
305 def _consume(comp_self
):
306 msg
= next(comp_self
._msg
_iter
)
307 if comp_self
._at
== 0:
308 self
.assertIsInstance(msg
, bt2
.message
._StreamBeginningMessage
)
309 elif comp_self
._at
== 1:
310 self
.assertIsInstance(msg
, bt2
.message
._PacketBeginningMessage
)
311 elif comp_self
._at
== 2:
312 self
.assertIsInstance(msg
, bt2
.message
._EventMessage
)
319 def _graph_is_configured(self
):
320 self
._msg
_iter
= self
._input
_port
.create_message_iterator()
322 src
= self
._graph
.add_component(MySource
, 'src')
323 sink
= self
._graph
.add_component(MySink
, 'sink')
324 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
325 sink
.input_ports
['in'])
327 with self
.assertRaises(bt2
.TryAgain
):
330 def test_run_error(self
):
331 raised_in_sink
= False
333 class MyIter(_MyIter
):
335 # If this gets called after the sink raised an exception, it is
337 nonlocal raised_in_sink
338 assert raised_in_sink
is False
341 msg
= self
._create
_stream
_beginning
_message
(self
._stream
)
343 msg
= self
._create
_packet
_beginning
_message
(self
._packet
)
344 elif self
._at
== 2 or self
._at
== 3:
345 msg
= self
._create
_event
_message
(self
._ec
, self
._packet
)
351 class MySource(bt2
._UserSourceComponent
,
352 message_iterator_class
=MyIter
):
353 def __init__(self
, params
):
354 self
._add
_output
_port
('out')
356 class MySink(bt2
._UserSinkComponent
):
357 def __init__(self
, params
):
358 self
._input
_port
= self
._add
_input
_port
('in')
361 def _consume(comp_self
):
362 msg
= next(comp_self
._msg
_iter
)
363 if comp_self
._at
== 0:
364 self
.assertIsInstance(msg
, bt2
.message
._StreamBeginningMessage
)
365 elif comp_self
._at
== 1:
366 self
.assertIsInstance(msg
, bt2
.message
._PacketBeginningMessage
)
367 elif comp_self
._at
== 2:
368 self
.assertIsInstance(msg
, bt2
.message
._EventMessage
)
369 elif comp_self
._at
== 3:
370 nonlocal raised_in_sink
371 raised_in_sink
= True
372 raise RuntimeError('error!')
376 def _graph_is_configured(self
):
377 self
._msg
_iter
= self
._input
_port
.create_message_iterator()
379 src
= self
._graph
.add_component(MySource
, 'src')
380 sink
= self
._graph
.add_component(MySink
, 'sink')
381 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
382 sink
.input_ports
['in'])
384 with self
.assertRaises(bt2
.Error
):
387 def test_listeners(self
):
388 class MyIter(bt2
._UserMessageIterator
):
392 class MySource(bt2
._UserSourceComponent
,
393 message_iterator_class
=MyIter
):
394 def __init__(self
, params
):
395 self
._add
_output
_port
('out')
396 self
._add
_output
_port
('zero')
398 class MySink(bt2
._UserSinkComponent
):
399 def __init__(self
, params
):
400 self
._add
_input
_port
('in')
405 def _port_connected(self
, port
, other_port
):
406 self
._add
_input
_port
('taste')
408 def port_added_listener(component
, port
):
410 calls
.append((port_added_listener
, component
, port
))
412 def ports_connected_listener(upstream_component
, upstream_port
,
413 downstream_component
, downstream_port
):
415 calls
.append((ports_connected_listener
,
416 upstream_component
, upstream_port
,
417 downstream_component
, downstream_port
))
420 self
._graph
.add_port_added_listener(port_added_listener
)
421 self
._graph
.add_ports_connected_listener(ports_connected_listener
)
422 src
= self
._graph
.add_component(MySource
, 'src')
423 sink
= self
._graph
.add_component(MySink
, 'sink')
424 self
._graph
.connect_ports(src
.output_ports
['out'],
425 sink
.input_ports
['in'])
427 self
.assertEqual(len(calls
), 5)
429 self
.assertIs(calls
[0][0], port_added_listener
)
430 self
.assertEqual(calls
[0][1].name
, 'src')
431 self
.assertEqual(calls
[0][2].name
, 'out')
433 self
.assertIs(calls
[1][0], port_added_listener
)
434 self
.assertEqual(calls
[1][1].name
, 'src')
435 self
.assertEqual(calls
[1][2].name
, 'zero')
437 self
.assertIs(calls
[2][0], port_added_listener
)
438 self
.assertEqual(calls
[2][1].name
, 'sink')
439 self
.assertEqual(calls
[2][2].name
, 'in')
441 self
.assertIs(calls
[3][0], port_added_listener
)
442 self
.assertEqual(calls
[3][1].name
, 'sink')
443 self
.assertEqual(calls
[3][2].name
, 'taste')
445 self
.assertIs(calls
[4][0], ports_connected_listener
)
446 self
.assertEqual(calls
[4][1].name
, 'src')
447 self
.assertEqual(calls
[4][2].name
, 'out')
448 self
.assertEqual(calls
[4][3].name
, 'sink')
449 self
.assertEqual(calls
[4][4].name
, 'in')
451 def test_invalid_listeners(self
):
452 class MyIter(bt2
._UserMessageIterator
):
456 class MySource(bt2
._UserSourceComponent
,
457 message_iterator_class
=MyIter
):
458 def __init__(self
, params
):
459 self
._add
_output
_port
('out')
460 self
._add
_output
_port
('zero')
462 class MySink(bt2
._UserSinkComponent
):
463 def __init__(self
, params
):
464 self
._add
_input
_port
('in')
469 def _port_connected(self
, port
, other_port
):
470 self
._add
_input
_port
('taste')
472 with self
.assertRaises(TypeError):
473 self
._graph
.add_port_added_listener(1234)
474 with self
.assertRaises(TypeError):
475 self
._graph
.add_ports_connected_listener(1234)
477 def test_raise_in_component_init(self
):
478 class MySink(bt2
._UserSinkComponent
):
479 def __init__(self
, params
):
480 raise ValueError('oops!')
487 with self
.assertRaises(bt2
.Error
):
488 graph
.add_component(MySink
, 'comp')
490 def test_raise_in_port_added_listener(self
):
491 class MySink(bt2
._UserSinkComponent
):
492 def __init__(self
, params
):
493 self
._add
_input
_port
('in')
498 def port_added_listener(component
, port
):
499 raise ValueError('oh noes!')
502 graph
.add_port_added_listener(port_added_listener
)
504 with self
.assertRaises(bt2
.Error
):
505 graph
.add_component(MySink
, 'comp')
507 def test_raise_in_ports_connected_listener(self
):
508 class MyIter(bt2
._UserMessageIterator
):
512 class MySource(bt2
._UserSourceComponent
,
513 message_iterator_class
=MyIter
):
514 def __init__(self
, params
):
515 self
._add
_output
_port
('out')
517 class MySink(bt2
._UserSinkComponent
):
518 def __init__(self
, params
):
519 self
._add
_input
_port
('in')
524 def ports_connected_listener(upstream_component
, upstream_port
,
525 downstream_component
, downstream_port
):
526 raise ValueError('oh noes!')
529 graph
.add_ports_connected_listener(ports_connected_listener
)
530 up
= graph
.add_component(MySource
, 'down')
531 down
= graph
.add_component(MySink
, 'up')
533 with self
.assertRaises(bt2
.Error
):
534 graph
.connect_ports(up
.output_ports
['out'], down
.input_ports
['in'])
This page took 0.04211 seconds and 5 git commands to generate.