bt2: prepend `_user` to overridable protected methods

[babeltrace.git] / tests / bindings / python / bt2 / test_message_iterator.py

diff --git a/tests/bindings/python/bt2/test_message_iterator.py b/tests/bindings/python/bt2/test_message_iterator.py
index 72003da701710ce91e19e015149fc5a933825a68..08be7d008dd908306dcc5581486618a516e80b88 100644 (file)
--- a/tests/bindings/python/bt2/test_message_iterator.py
+++ b/tests/bindings/python/bt2/test_message_iterator.py
@@ -25,21 +25,37 @@ import bt2
 
 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')
 
-            def _consume(self):
+            def _user_consume(self):
                 next(self._msg_iter)
 
-            def _graph_is_configured(self):
-                self._msg_iter = self._input_ports['in'].create_message_iterator()
+            def _user_graph_is_configured(self):
+                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):
@@ -67,9 +83,42 @@ class UserMessageIteratorTestCase(unittest.TestCase):
         )
         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):
+            def _user_finalize(self):
                 nonlocal finalized
                 finalized = True
 
@@ -151,15 +200,15 @@ class UserMessageIteratorTestCase(unittest.TestCase):
 
         # 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
@@ -186,7 +235,7 @@ class UserMessageIteratorTestCase(unittest.TestCase):
                 ]
                 self._at = 0
 
-            def _seek_beginning(self):
+            def _user_seek_beginning(self):
                 self._at = 0
 
             def __next__(self):
@@ -208,16 +257,18 @@ class UserMessageIteratorTestCase(unittest.TestCase):
         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)
 
-            def _seek_beginning(self):
+            def _user_seek_beginning(self):
                 self._upstream_iter.seek_beginning()
 
             @property
-            def _can_seek_beginning(self):
+            def _user_can_seek_beginning(self):
                 return self._upstream_iter.can_seek_beginning
 
         class MyFilter(bt2._UserFilterComponent, message_iterator_class=MyFilterIter):
@@ -236,11 +287,11 @@ class UserMessageIteratorTestCase(unittest.TestCase):
     def test_can_seek_beginning(self):
         it, MySourceIter = self._setup_seek_beginning_test()
 
-        def _can_seek_beginning(self):
+        def _user_can_seek_beginning(self):
             nonlocal can_seek_beginning
             return can_seek_beginning
 
-        MySourceIter._can_seek_beginning = property(_can_seek_beginning)
+        MySourceIter._user_can_seek_beginning = property(_user_can_seek_beginning)
 
         can_seek_beginning = True
         self.assertTrue(it.can_seek_beginning)
@@ -254,24 +305,24 @@ class UserMessageIteratorTestCase(unittest.TestCase):
         # Remove the _can_seek_beginning method, we now rely on the presence of
         # a _seek_beginning method to know whether the iterator can seek to
         # beginning or not.
-        del MySourceIter._can_seek_beginning
+        del MySourceIter._user_can_seek_beginning
         self.assertTrue(it.can_seek_beginning)
 
-        del MySourceIter._seek_beginning
+        del MySourceIter._user_seek_beginning
         self.assertFalse(it.can_seek_beginning)
 
     def test_seek_beginning(self):
         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.
         #
@@ -287,17 +338,17 @@ class UserMessageIteratorTestCase(unittest.TestCase):
         #
         # 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()
 
-        def _seek_beginning_error(self):
+        def _user_seek_beginning_error(self):
             raise ValueError('ouch')
 
-        MySourceIter._seek_beginning = _seek_beginning_error
+        MySourceIter._user_seek_beginning = _user_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.
@@ -382,15 +433,15 @@ class OutputPortMessageIteratorTestCase(unittest.TestCase):
 
         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)