8 @unittest.skip("this is broken")
9 class GraphTestCase(unittest
.TestCase
):
11 self
._graph
= bt2
.Graph()
16 def test_create_empty(self
):
19 def test_add_component_user_cls(self
):
20 class MySink(bt2
._UserSinkComponent
):
24 comp
= self
._graph
.add_component(MySink
, 'salut')
25 self
.assertEqual(comp
.name
, 'salut')
27 def test_add_component_gen_cls(self
):
28 class MySink(bt2
._UserSinkComponent
):
32 comp
= self
._graph
.add_component(MySink
, 'salut')
34 comp2
= self
._graph
.add_component(comp
.component_class
, 'salut2')
35 self
.assertEqual(comp2
.name
, 'salut2')
37 def test_add_component_params(self
):
40 class MySink(bt2
._UserSinkComponent
):
41 def __init__(self
, params
):
48 params
= {'hello': 23, 'path': '/path/to/stuff'}
49 comp
= self
._graph
.add_component(MySink
, 'salut', params
)
50 self
.assertEqual(params
, comp_params
)
53 def test_add_component_invalid_cls_type(self
):
54 with self
.assertRaises(TypeError):
55 self
._graph
.add_component(int, 'salut')
57 def test_connect_ports(self
):
58 class MyIter(bt2
._UserMessageIterator
):
62 class MySource(bt2
._UserSourceComponent
,
63 message_iterator_class
=MyIter
):
64 def __init__(self
, params
):
65 self
._add
_output
_port
('out')
67 class MySink(bt2
._UserSinkComponent
):
68 def __init__(self
, params
):
69 self
._add
_input
_port
('in')
74 src
= self
._graph
.add_component(MySource
, 'src')
75 sink
= self
._graph
.add_component(MySink
, 'sink')
76 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
77 sink
.input_ports
['in'])
78 self
.assertTrue(src
.output_ports
['out'].is_connected
)
79 self
.assertTrue(sink
.input_ports
['in'].is_connected
)
80 self
.assertEqual(src
.output_ports
['out'].connection
, conn
)
81 self
.assertEqual(sink
.input_ports
['in'].connection
, conn
)
83 def test_connect_ports_invalid_direction(self
):
84 class MyIter(bt2
._UserMessageIterator
):
88 class MySource(bt2
._UserSourceComponent
,
89 message_iterator_class
=MyIter
):
90 def __init__(self
, params
):
91 self
._add
_output
_port
('out')
93 class MySink(bt2
._UserSinkComponent
):
94 def __init__(self
, params
):
95 self
._add
_input
_port
('in')
100 src
= self
._graph
.add_component(MySource
, 'src')
101 sink
= self
._graph
.add_component(MySink
, 'sink')
103 with self
.assertRaises(TypeError):
104 conn
= self
._graph
.connect_ports(sink
.input_ports
['in'],
105 src
.output_ports
['out'])
107 def test_connect_ports_refused(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 def _accept_port_connection(self
, port
, other_port
):
127 src
= self
._graph
.add_component(MySource
, 'src')
128 sink
= self
._graph
.add_component(MySink
, 'sink')
130 with self
.assertRaises(bt2
.PortConnectionRefused
):
131 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
132 sink
.input_ports
['in'])
134 def test_connect_ports_canceled(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')
155 with self
.assertRaises(bt2
.GraphCanceled
):
156 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
157 sink
.input_ports
['in'])
159 def test_connect_ports_cannot_consume_accept(self
):
160 class MyIter(bt2
._UserMessageIterator
):
164 class MySource(bt2
._UserSourceComponent
,
165 message_iterator_class
=MyIter
):
166 def __init__(self
, params
):
167 self
._add
_output
_port
('out')
169 class MySink(bt2
._UserSinkComponent
):
170 def __init__(self
, params
):
171 self
._add
_input
_port
('in')
176 def _accept_port_connection(self
, port
, other_port
):
181 except Exception as e
:
187 src
= self
._graph
.add_component(MySource
, 'src')
188 sink
= self
._graph
.add_component(MySink
, 'sink')
189 self
._graph
.connect_ports(src
.output_ports
['out'],
190 sink
.input_ports
['in'])
191 self
.assertIs(type(exc
), bt2
.CannotConsumeGraph
)
193 def test_connect_ports_cannot_consume_connected(self
):
194 class MyIter(bt2
._UserMessageIterator
):
198 class MySource(bt2
._UserSourceComponent
,
199 message_iterator_class
=MyIter
):
200 def __init__(self
, params
):
201 self
._add
_output
_port
('out')
203 class MySink(bt2
._UserSinkComponent
):
204 def __init__(self
, params
):
205 self
._add
_input
_port
('in')
210 def _port_connected(self
, port
, other_port
):
215 except Exception as e
:
221 src
= self
._graph
.add_component(MySource
, 'src')
222 sink
= self
._graph
.add_component(MySink
, 'sink')
223 self
._graph
.connect_ports(src
.output_ports
['out'],
224 sink
.input_ports
['in'])
226 self
.assertIs(type(exc
), bt2
.CannotConsumeGraph
)
228 def test_cancel(self
):
229 self
.assertFalse(self
._graph
.is_canceled
)
231 self
.assertTrue(self
._graph
.is_canceled
)
234 class MyIter(bt2
._UserMessageIterator
):
239 def _build_meta(self
):
240 self
._trace
= bt2
.Trace()
241 self
._sc
= bt2
.StreamClass()
242 self
._ec
= bt2
.EventClass('salut')
243 self
._my
_int
_fc
= bt2
.IntegerFieldClass(32)
244 self
._ec
.payload_field_class
= bt2
.StructureFieldClass()
245 self
._ec
.payload_field_class
+= collections
.OrderedDict([
246 ('my_int', self
._my
_int
_fc
),
248 self
._sc
.add_event_class(self
._ec
)
249 self
._trace
.add_stream_class(self
._sc
)
250 self
._stream
= self
._sc
()
251 self
._packet
= self
._stream
.create_packet()
253 def _create_event(self
, value
):
255 ev
.payload_field
['my_int'] = value
256 ev
.packet
= self
._packet
263 msg
= bt2
.EventMessage(self
._create
_event
(self
._at
* 3))
267 class MySource(bt2
._UserSourceComponent
,
268 message_iterator_class
=MyIter
):
269 def __init__(self
, params
):
270 self
._add
_output
_port
('out')
272 class MySink(bt2
._UserSinkComponent
):
273 def __init__(self
, params
):
274 self
._add
_input
_port
('in')
277 def _consume(comp_self
):
278 msg
= next(comp_self
._msg
_iter
)
280 if comp_self
._at
== 0:
281 self
.assertIsInstance(msg
, bt2
.StreamBeginningMessage
)
282 elif comp_self
._at
== 1:
283 self
.assertIsInstance(msg
, bt2
.PacketBeginningMessage
)
284 elif comp_self
._at
>= 2 and comp_self
._at
<= 6:
285 self
.assertIsInstance(msg
, bt2
.EventMessage
)
286 self
.assertEqual(msg
.event
.event_class
.name
, 'salut')
287 field
= msg
.event
.payload_field
['my_int']
288 self
.assertEqual(field
, (comp_self
._at
- 2) * 3)
289 elif comp_self
._at
== 7:
290 self
.assertIsInstance(msg
, bt2
.PacketEndMessage
)
291 elif comp_self
._at
== 8:
292 self
.assertIsInstance(msg
, bt2
.StreamEndMessage
)
296 def _port_connected(self
, port
, other_port
):
297 self
._msg
_iter
= port
.connection
.create_message_iterator()
299 src
= self
._graph
.add_component(MySource
, 'src')
300 sink
= self
._graph
.add_component(MySink
, 'sink')
301 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
302 sink
.input_ports
['in'])
305 def test_run_again(self
):
306 class MyIter(bt2
._UserMessageIterator
):
311 def _build_meta(self
):
312 self
._trace
= bt2
.Trace()
313 self
._sc
= bt2
.StreamClass()
314 self
._ec
= bt2
.EventClass('salut')
315 self
._my
_int
_fc
= bt2
.IntegerFieldClass(32)
316 self
._ec
.payload_field_class
= bt2
.StructureFieldClass()
317 self
._ec
.payload_field_class
+= collections
.OrderedDict([
318 ('my_int', self
._my
_int
_fc
),
320 self
._sc
.add_event_class(self
._ec
)
321 self
._trace
.add_stream_class(self
._sc
)
322 self
._stream
= self
._sc
()
323 self
._packet
= self
._stream
.create_packet()
325 def _create_event(self
, value
):
327 ev
.payload_field
['my_int'] = value
328 ev
.packet
= self
._packet
335 msg
= bt2
.EventMessage(self
._create
_event
(self
._at
* 3))
339 class MySource(bt2
._UserSourceComponent
,
340 message_iterator_class
=MyIter
):
341 def __init__(self
, params
):
342 self
._add
_output
_port
('out')
344 class MySink(bt2
._UserSinkComponent
):
345 def __init__(self
, params
):
346 self
._add
_input
_port
('in')
349 def _consume(comp_self
):
350 if comp_self
._at
== 0:
351 msg
= next(comp_self
._msg
_iter
)
352 self
.assertIsInstance(msg
, bt2
.EventMessage
)
353 elif comp_self
._at
== 1:
354 with self
.assertRaises(bt2
.TryAgain
):
355 msg
= next(comp_self
._msg
_iter
)
361 def _port_connected(self
, port
, other_port
):
362 types
= [bt2
.EventMessage
]
363 self
._msg
_iter
= port
.connection
.create_message_iterator(types
)
365 src
= self
._graph
.add_component(MySource
, 'src')
366 sink
= self
._graph
.add_component(MySink
, 'sink')
367 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
368 sink
.input_ports
['in'])
370 with self
.assertRaises(bt2
.TryAgain
):
373 def test_run_no_sink(self
):
374 class MyIter(bt2
._UserMessageIterator
):
377 class MySource(bt2
._UserSourceComponent
,
378 message_iterator_class
=MyIter
):
379 def __init__(self
, params
):
380 self
._add
_output
_port
('out')
382 class MyFilter(bt2
._UserFilterComponent
,
383 message_iterator_class
=MyIter
):
384 def __init__(self
, params
):
385 self
._add
_output
_port
('out')
386 self
._add
_input
_port
('in')
388 src
= self
._graph
.add_component(MySource
, 'src')
389 flt
= self
._graph
.add_component(MyFilter
, 'flt')
390 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
391 flt
.input_ports
['in'])
393 with self
.assertRaises(bt2
.NoSinkComponent
):
396 def test_run_error(self
):
397 class MyIter(bt2
._UserMessageIterator
):
402 def _build_meta(self
):
403 self
._trace
= bt2
.Trace()
404 self
._sc
= bt2
.StreamClass()
405 self
._ec
= bt2
.EventClass('salut')
406 self
._my
_int
_fc
= bt2
.IntegerFieldClass(32)
407 self
._ec
.payload_field_class
= bt2
.StructureFieldClass()
408 self
._ec
.payload_field_class
+= collections
.OrderedDict([
409 ('my_int', self
._my
_int
_fc
),
411 self
._sc
.add_event_class(self
._ec
)
412 self
._trace
.add_stream_class(self
._sc
)
413 self
._stream
= self
._sc
()
414 self
._packet
= self
._stream
.create_packet()
416 def _create_event(self
, value
):
418 ev
.payload_field
['my_int'] = value
419 ev
.packet
= self
._packet
426 msg
= bt2
.EventMessage(self
._create
_event
(self
._at
* 3))
430 class MySource(bt2
._UserSourceComponent
,
431 message_iterator_class
=MyIter
):
432 def __init__(self
, params
):
433 self
._add
_output
_port
('out')
435 class MySink(bt2
._UserSinkComponent
):
436 def __init__(self
, params
):
437 self
._add
_input
_port
('in')
440 def _consume(comp_self
):
441 if comp_self
._at
== 0:
442 msg
= next(comp_self
._msg
_iter
)
443 self
.assertIsInstance(msg
, bt2
.EventMessage
)
444 elif comp_self
._at
== 1:
445 raise RuntimeError('error!')
449 def _port_connected(self
, port
, other_port
):
450 types
= [bt2
.EventMessage
]
451 self
._msg
_iter
= port
.connection
.create_message_iterator(types
)
453 src
= self
._graph
.add_component(MySource
, 'src')
454 sink
= self
._graph
.add_component(MySink
, 'sink')
455 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
456 sink
.input_ports
['in'])
458 with self
.assertRaises(bt2
.Error
):
461 def test_run_cannot_consume(self
):
462 class MyIter(bt2
._UserMessageIterator
):
465 class MySource(bt2
._UserSourceComponent
,
466 message_iterator_class
=MyIter
):
467 def __init__(self
, params
):
468 self
._add
_output
_port
('out')
470 class MySink(bt2
._UserSinkComponent
):
471 def __init__(self
, params
):
472 self
._add
_input
_port
('in')
475 def _consume(comp_self
):
480 comp_self
.graph
.run()
482 except Exception as e
:
488 src
= self
._graph
.add_component(MySource
, 'src')
489 sink
= self
._graph
.add_component(MySink
, 'sink')
490 conn
= self
._graph
.connect_ports(src
.output_ports
['out'],
491 sink
.input_ports
['in'])
493 self
.assertIs(type(exc
), bt2
.CannotConsumeGraph
)
495 def test_listeners(self
):
496 class MyIter(bt2
._UserMessageIterator
):
500 class MySource(bt2
._UserSourceComponent
,
501 message_iterator_class
=MyIter
):
502 def __init__(self
, params
):
503 self
._add
_output
_port
('out')
504 self
._add
_output
_port
('zero')
506 def _port_connected(self
, port
, other_port
):
507 self
._output
_ports
['zero'].remove_from_component()
509 class MySink(bt2
._UserSinkComponent
):
510 def __init__(self
, params
):
511 self
._add
_input
_port
('in')
516 def _port_connected(self
, port
, other_port
):
517 self
._add
_input
_port
('taste')
519 def _port_disconnected(self
, port
):
520 port
.remove_from_component()
522 def port_added_listener(port
):
524 calls
.append((port_added_listener
, port
))
526 def port_removed_listener(port
):
528 calls
.append((port_removed_listener
, port
))
530 def ports_connected_listener(upstream_port
, downstream_port
):
532 calls
.append((ports_connected_listener
, upstream_port
,
535 def ports_disconnected_listener(upstream_comp
, downstream_comp
,
536 upstream_port
, downstream_port
):
538 calls
.append((ports_disconnected_listener
, upstream_comp
,
539 downstream_comp
, upstream_port
, downstream_port
))
542 self
._graph
.add_listener(bt2
.GraphListenerType
.PORT_ADDED
,
544 self
._graph
.add_listener(bt2
.GraphListenerType
.PORT_REMOVED
,
545 port_removed_listener
)
546 self
._graph
.add_listener(bt2
.GraphListenerType
.PORTS_CONNECTED
,
547 ports_connected_listener
)
548 self
._graph
.add_listener(bt2
.GraphListenerType
.PORTS_DISCONNECTED
,
549 ports_disconnected_listener
)
550 src
= self
._graph
.add_component(MySource
, 'src')
551 sink
= self
._graph
.add_component(MySink
, 'sink')
552 self
._graph
.connect_ports(src
.output_ports
['out'],
553 sink
.input_ports
['in'])
554 sink
.input_ports
['in'].disconnect()
555 self
.assertIs(calls
[0][0], port_added_listener
)
556 self
.assertEqual(calls
[0][1].name
, 'out')
557 self
.assertIs(calls
[1][0], port_added_listener
)
558 self
.assertEqual(calls
[1][1].name
, 'zero')
559 self
.assertIs(calls
[2][0], port_added_listener
)
560 self
.assertEqual(calls
[2][1].name
, 'in')
561 self
.assertIs(calls
[3][0], port_removed_listener
)
562 self
.assertEqual(calls
[3][1].name
, 'zero')
563 self
.assertIs(calls
[4][0], port_added_listener
)
564 self
.assertEqual(calls
[4][1].name
, 'taste')
565 self
.assertIs(calls
[5][0], ports_connected_listener
)
566 self
.assertEqual(calls
[5][1].name
, 'out')
567 self
.assertEqual(calls
[5][2].name
, 'in')
568 self
.assertIs(calls
[6][0], port_removed_listener
)
569 self
.assertEqual(calls
[6][1].name
, 'in')
570 self
.assertIs(calls
[7][0], ports_disconnected_listener
)
571 self
.assertEqual(calls
[7][1].name
, 'src')
572 self
.assertEqual(calls
[7][2].name
, 'sink')
573 self
.assertEqual(calls
[7][3].name
, 'out')
574 self
.assertEqual(calls
[7][4].name
, 'in')