class UserMessageIteratorTestCase(unittest.TestCase):
@staticmethod
- def _create_graph(src_comp_cls):
+ def _create_graph(src_comp_cls, flt_comp_cls=None):
class MySink(bt2._UserSinkComponent):
def __init__(self, params):
self._add_input_port('in')
next(self._msg_iter)
def _graph_is_configured(self):
- self._msg_iter = self._input_ports['in'].create_message_iterator()
+ self._msg_iter = self._create_input_port_message_iterator(
+ self._input_ports['in']
+ )
graph = bt2.Graph()
src_comp = graph.add_component(src_comp_cls, 'src')
+
+ if flt_comp_cls is not None:
+ flt_comp = graph.add_component(flt_comp_cls, 'flt')
+
sink_comp = graph.add_component(MySink, 'sink')
- graph.connect_ports(src_comp.output_ports['out'], sink_comp.input_ports['in'])
+
+ if flt_comp_cls is not None:
+ assert flt_comp is not None
+ graph.connect_ports(
+ src_comp.output_ports['out'], flt_comp.input_ports['in']
+ )
+ out_port = flt_comp.output_ports['out']
+ else:
+ out_port = src_comp.output_ports['out']
+
+ graph.connect_ports(out_port, sink_comp.input_ports['in'])
return graph
def test_init(self):
)
self.assertEqual(the_output_port_from_iter.user_data, 'user data')
+ def test_create_from_message_iterator(self):
+ class MySourceIter(bt2._UserMessageIterator):
+ def __init__(self, self_port_output):
+ nonlocal src_iter_initialized
+ src_iter_initialized = True
+
+ class MySource(bt2._UserSourceComponent, message_iterator_class=MySourceIter):
+ def __init__(self, params):
+ self._add_output_port('out')
+
+ class MyFilterIter(bt2._UserMessageIterator):
+ def __init__(self, self_port_output):
+ nonlocal flt_iter_initialized
+ flt_iter_initialized = True
+ self._up_iter = self._create_input_port_message_iterator(
+ self._component._input_ports['in']
+ )
+
+ def __next__(self):
+ return next(self._up_iter)
+
+ class MyFilter(bt2._UserFilterComponent, message_iterator_class=MyFilterIter):
+ def __init__(self, params):
+ self._add_input_port('in')
+ self._add_output_port('out')
+
+ src_iter_initialized = False
+ flt_iter_initialized = False
+ graph = self._create_graph(MySource, MyFilter)
+ graph.run()
+ self.assertTrue(src_iter_initialized)
+ self.assertTrue(flt_iter_initialized)
+
def test_finalize(self):
class MyIter(bt2._UserMessageIterator):
def _finalize(self):
# Skip beginning messages.
msg = next(it)
- self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
+ self.assertIsInstance(msg, bt2._StreamBeginningMessage)
msg = next(it)
- self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
+ self.assertIsInstance(msg, bt2._PacketBeginningMessage)
msg_ev1 = next(it)
msg_ev2 = next(it)
- self.assertIsInstance(msg_ev1, bt2.message._EventMessage)
- self.assertIsInstance(msg_ev2, bt2.message._EventMessage)
+ self.assertIsInstance(msg_ev1, bt2._EventMessage)
+ self.assertIsInstance(msg_ev2, bt2._EventMessage)
self.assertEqual(msg_ev1.addr, msg_ev2.addr)
@staticmethod
class MyFilterIter(bt2._UserMessageIterator):
def __init__(self, port):
input_port = port.user_data
- self._upstream_iter = input_port.create_message_iterator()
+ self._upstream_iter = self._create_input_port_message_iterator(
+ input_port
+ )
def __next__(self):
return next(self._upstream_iter)
it, MySourceIter = self._setup_seek_beginning_test()
msg = next(it)
- self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
+ self.assertIsInstance(msg, bt2._StreamBeginningMessage)
msg = next(it)
- self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
+ self.assertIsInstance(msg, bt2._PacketBeginningMessage)
it.seek_beginning()
msg = next(it)
- self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
+ self.assertIsInstance(msg, bt2._StreamBeginningMessage)
# Verify that we can seek beginning after having reached the end.
#
#
# it.seek_beginning()
# msg = next(it)
- # self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
+ # self.assertIsInstance(msg, bt2._StreamBeginningMessage)
def test_seek_beginning_user_error(self):
it, MySourceIter = self._setup_seek_beginning_test()
MySourceIter._seek_beginning = _seek_beginning_error
- with self.assertRaises(bt2.Error):
+ with self.assertRaises(bt2._Error):
it.seek_beginning()
+ # Try consuming many times from an iterator that always returns TryAgain.
+ # This verifies that we are not missing an incref of Py_None, making the
+ # refcount of Py_None reach 0.
+ def test_try_again_many_times(self):
+ class MyIter(bt2._UserMessageIterator):
+ def __next__(self):
+ raise bt2.TryAgain
+
+ class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
+ def __init__(self, params):
+ self._add_output_port('out')
+
+ graph = bt2.Graph()
+ src = graph.add_component(MySource, 'src')
+ it = graph.create_output_port_message_iterator(src.output_ports['out'])
+
+ # The initial refcount of Py_None was in the 7000, so 100000 iterations
+ # should be enough to catch the bug even if there are small differences
+ # between configurations.
+ for i in range(100000):
+ with self.assertRaises(bt2.TryAgain):
+ next(it)
+
class OutputPortMessageIteratorTestCase(unittest.TestCase):
def test_component(self):
for at, msg in enumerate(msg_iter):
if at == 0:
- self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
+ self.assertIsInstance(msg, bt2._StreamBeginningMessage)
elif at == 1:
- self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
+ self.assertIsInstance(msg, bt2._PacketBeginningMessage)
elif at == 5:
- self.assertIsInstance(msg, bt2.message._PacketEndMessage)
+ self.assertIsInstance(msg, bt2._PacketEndMessage)
elif at == 6:
- self.assertIsInstance(msg, bt2.message._StreamEndMessage)
+ self.assertIsInstance(msg, bt2._StreamEndMessage)
else:
- self.assertIsInstance(msg, bt2.message._EventMessage)
+ self.assertIsInstance(msg, bt2._EventMessage)
self.assertEqual(msg.event.cls.name, 'salut')
field = msg.event.payload_field['my_int']
self.assertEqual(field, at * 3)
projects / babeltrace.git / blobdiff