X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Fbindings%2Fpython%2Fbt2%2Ftest_port.py;h=e6db06ea53c0736b3cf4facaa86e869179789483;hb=768f9bcbf4b5acd09dda85ab32c0ea30d8826136;hp=b346cbb6c272a7c7bbaa796edb3ddf6856c4999f;hpb=c4239792c6758f579fb9482ddccf336f1bbf26c4;p=babeltrace.git diff --git a/tests/bindings/python/bt2/test_port.py b/tests/bindings/python/bt2/test_port.py index b346cbb6..e6db06ea 100644 --- a/tests/bindings/python/bt2/test_port.py +++ b/tests/bindings/python/bt2/test_port.py @@ -1,10 +1,13 @@ -from bt2 import value +# SPDX-License-Identifier: GPL-2.0-only +# +# Copyright (C) 2019 EfficiOS Inc. +# + import unittest -import copy import bt2 +from bt2 import port as bt2_port -@unittest.skip("this is broken") class PortTestCase(unittest.TestCase): @staticmethod def _create_comp(comp_cls, name=None): @@ -16,68 +19,142 @@ class PortTestCase(unittest.TestCase): return graph.add_component(comp_cls, name) def test_src_add_output_port(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port = comp_self._add_output_port('out') self.assertEqual(port.name, 'out') comp = self._create_comp(MySource) self.assertEqual(len(comp.output_ports), 1) + self.assertIs(type(comp.output_ports['out']), bt2_port._OutputPortConst) + # Test adding output port with duplicate name to source. + def test_src_add_output_port_dup_name_raises(self): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): + comp_self._add_output_port('out') - def test_flt_add_output_port(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop + with self.assertRaisesRegex( + ValueError, + "source component `comp` already contains an output port named `out`", + ): + comp_self._add_output_port('out') + + nonlocal seen + seen = True - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + seen = False + self._create_comp(MySource) + self.assertTrue(seen) + + def test_flt_add_output_port(self): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port = comp_self._add_output_port('out') self.assertEqual(port.name, 'out') comp = self._create_comp(MyFilter) self.assertEqual(len(comp.output_ports), 1) - def test_flt_add_input_port(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop + # Test adding output port with duplicate name to filter. + def test_flt_add_output_port_dup_name_raises(self): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): + comp_self._add_output_port('out') + + with self.assertRaisesRegex( + ValueError, + "filter component `comp` already contains an output port named `out`", + ): + comp_self._add_output_port('out') - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + nonlocal seen + seen = True + + seen = False + self._create_comp(MyFilter) + self.assertTrue(seen) + + def test_flt_add_input_port(self): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port = comp_self._add_input_port('in') self.assertEqual(port.name, 'in') comp = self._create_comp(MyFilter) self.assertEqual(len(comp.input_ports), 1) + self.assertIs(type(comp.input_ports['in']), bt2_port._InputPortConst) + + # Test adding input port with duplicate name to filter. + def test_flt_add_input_port_dup_name_raises(self): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): + comp_self._add_input_port('in') + + with self.assertRaisesRegex( + ValueError, + "filter component `comp` already contains an input port named `in`", + ): + comp_self._add_input_port('in') + + nonlocal seen + seen = True + + seen = False + self._create_comp(MyFilter) + self.assertTrue(seen) def test_sink_add_input_port(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): port = comp_self._add_input_port('in') self.assertEqual(port.name, 'in') - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) self.assertEqual(len(comp.input_ports), 1) - def test_user_src_output_ports_getitem(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop + # Test adding input port with duplicate name to sink. + def test_sink_add_input_port_dup_name_raises(self): + class MySink(bt2._UserSinkComponent): + def __init__(comp_self, config, params, obj): + comp_self._add_input_port('in') + + with self.assertRaisesRegex( + ValueError, + "sink component `comp` already contains an input port named `in`", + ): + comp_self._add_input_port('in') + + nonlocal seen + seen = True - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + def _user_consume(self): + pass + + seen = False + self._create_comp(MySink) + self.assertTrue(seen) + + def test_user_src_output_ports_getitem(self): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') port3 = comp_self._add_output_port('insert') @@ -85,16 +162,13 @@ class PortTestCase(unittest.TestCase): self.assertEqual(port2.addr, comp_self._output_ports['print'].addr) self.assertEqual(port1.addr, comp_self._output_ports['clear'].addr) - comp = self._create_comp(MySource) + self._create_comp(MySource) def test_user_flt_output_ports_getitem(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') port3 = comp_self._add_output_port('insert') @@ -102,16 +176,13 @@ class PortTestCase(unittest.TestCase): self.assertEqual(port2.addr, comp_self._output_ports['print'].addr) self.assertEqual(port1.addr, comp_self._output_ports['clear'].addr) - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_flt_input_ports_getitem(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') port3 = comp_self._add_input_port('insert') @@ -119,11 +190,11 @@ class PortTestCase(unittest.TestCase): self.assertEqual(port2.addr, comp_self._input_ports['print'].addr) self.assertEqual(port1.addr, comp_self._input_ports['clear'].addr) - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_sink_input_ports_getitem(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') port3 = comp_self._add_input_port('insert') @@ -131,19 +202,16 @@ class PortTestCase(unittest.TestCase): self.assertEqual(port2.addr, comp_self._input_ports['print'].addr) self.assertEqual(port1.addr, comp_self._input_ports['clear'].addr) - def _consume(self): + def _user_consume(self): pass - comp = self._create_comp(MySink) + self._create_comp(MySink) def test_user_src_output_ports_getitem_invalid_key(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') @@ -151,16 +219,13 @@ class PortTestCase(unittest.TestCase): with self.assertRaises(KeyError): comp_self._output_ports['hello'] - comp = self._create_comp(MySource) + self._create_comp(MySource) def test_user_flt_output_ports_getitem_invalid_key(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') @@ -168,16 +233,13 @@ class PortTestCase(unittest.TestCase): with self.assertRaises(KeyError): comp_self._output_ports['hello'] - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_flt_input_ports_getitem_invalid_key(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') @@ -185,11 +247,11 @@ class PortTestCase(unittest.TestCase): with self.assertRaises(KeyError): comp_self._input_ports['hello'] - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_sink_input_ports_getitem_invalid_key(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') @@ -197,77 +259,65 @@ class PortTestCase(unittest.TestCase): with self.assertRaises(KeyError): comp_self._input_ports['hello'] - def _consume(self): + def _user_consume(self): pass - comp = self._create_comp(MySink) + self._create_comp(MySink) def test_user_src_output_ports_len(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') self.assertEqual(len(comp_self._output_ports), 3) - comp = self._create_comp(MySource) + self._create_comp(MySource) def test_user_flt_output_ports_len(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') self.assertEqual(len(comp_self._output_ports), 3) - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_flt_input_ports_len(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') self.assertEqual(len(comp_self._input_ports), 3) - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_sink_input_ports_len(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') self.assertEqual(len(comp_self._input_ports), 3) - def _consume(self): + def _user_consume(self): pass - comp = self._create_comp(MySink) + self._create_comp(MySink) def test_user_src_output_ports_iter(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') port3 = comp_self._add_output_port('insert') @@ -283,16 +333,13 @@ class PortTestCase(unittest.TestCase): self.assertEqual(ports[2][0], 'insert') self.assertEqual(ports[2][1].addr, port3.addr) - comp = self._create_comp(MySource) + self._create_comp(MySource) def test_user_flt_output_ports_iter(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') port3 = comp_self._add_output_port('insert') @@ -308,16 +355,13 @@ class PortTestCase(unittest.TestCase): self.assertEqual(ports[2][0], 'insert') self.assertEqual(ports[2][1].addr, port3.addr) - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_flt_input_ports_iter(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') port3 = comp_self._add_input_port('insert') @@ -333,11 +377,11 @@ class PortTestCase(unittest.TestCase): self.assertEqual(ports[2][0], 'insert') self.assertEqual(ports[2][1].addr, port3.addr) - comp = self._create_comp(MyFilter) + self._create_comp(MyFilter) def test_user_sink_input_ports_iter(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') port3 = comp_self._add_input_port('insert') @@ -353,23 +397,20 @@ class PortTestCase(unittest.TestCase): self.assertEqual(ports[2][0], 'insert') self.assertEqual(ports[2][1].addr, port3.addr) - def _consume(self): + def _user_consume(self): pass - comp = self._create_comp(MySink) + self._create_comp(MySink) def test_gen_src_output_ports_getitem(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - port1 = None port2 = None port3 = None - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') @@ -384,17 +425,14 @@ class PortTestCase(unittest.TestCase): del port3 def test_gen_flt_output_ports_getitem(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - port1 = None port2 = None port3 = None - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') @@ -409,17 +447,14 @@ class PortTestCase(unittest.TestCase): del port3 def test_gen_flt_input_ports_getitem(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - port1 = None port2 = None port3 = None - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') @@ -439,13 +474,13 @@ class PortTestCase(unittest.TestCase): port3 = None class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') port3 = comp_self._add_input_port('insert') - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) @@ -457,13 +492,10 @@ class PortTestCase(unittest.TestCase): del port3 def test_gen_src_output_ports_getitem_invalid_key(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') @@ -474,13 +506,10 @@ class PortTestCase(unittest.TestCase): comp.output_ports['hello'] def test_gen_flt_output_ports_getitem_invalid_key(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') @@ -491,13 +520,10 @@ class PortTestCase(unittest.TestCase): comp.output_ports['hello'] def test_gen_flt_input_ports_getitem_invalid_key(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') @@ -509,7 +535,7 @@ class PortTestCase(unittest.TestCase): def test_gen_sink_input_ports_getitem_invalid_key(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') @@ -517,7 +543,7 @@ class PortTestCase(unittest.TestCase): with self.assertRaises(KeyError): comp_self._input_ports['hello'] - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) @@ -526,13 +552,10 @@ class PortTestCase(unittest.TestCase): comp.input_ports['hello'] def test_gen_src_output_ports_len(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') @@ -541,13 +564,10 @@ class PortTestCase(unittest.TestCase): self.assertEqual(len(comp.output_ports), 3) def test_gen_flt_output_ports_len(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_output_port('clear') comp_self._add_output_port('print') comp_self._add_output_port('insert') @@ -556,13 +576,10 @@ class PortTestCase(unittest.TestCase): self.assertEqual(len(comp.output_ports), 3) def test_gen_flt_input_ports_len(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') @@ -572,29 +589,26 @@ class PortTestCase(unittest.TestCase): def test_gen_sink_input_ports_len(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') comp_self._add_input_port('print') comp_self._add_input_port('insert') - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) self.assertEqual(len(comp.input_ports), 3) def test_gen_src_output_ports_iter(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - port1 = None port2 = None port3 = None - class MySource(bt2._UserSourceComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MySource( + bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') @@ -617,17 +631,14 @@ class PortTestCase(unittest.TestCase): del port3 def test_gen_flt_output_ports_iter(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - port1 = None port2 = None port3 = None - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_output_port('clear') port2 = comp_self._add_output_port('print') @@ -650,17 +661,14 @@ class PortTestCase(unittest.TestCase): del port3 def test_gen_flt_input_ports_iter(self): - class MyIter(bt2._UserMessageIterator): - def __next__(self): - raise bt2.Stop - port1 = None port2 = None port3 = None - class MyFilter(bt2._UserFilterComponent, - message_iterator_class=MyIter): - def __init__(comp_self, params): + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') @@ -688,13 +696,13 @@ class PortTestCase(unittest.TestCase): port3 = None class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): nonlocal port1, port2, port3 port1 = comp_self._add_input_port('clear') port2 = comp_self._add_input_port('print') port3 = comp_self._add_input_port('insert') - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) @@ -715,32 +723,21 @@ class PortTestCase(unittest.TestCase): def test_name(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) self.assertEqual(comp.input_ports['clear'].name, 'clear') - def test_component(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - comp_self._add_input_port('clear') - - def _consume(self): - pass - - comp = self._create_comp(MySink) - self.assertEqual(comp.input_ports['clear'].component.addr, comp.addr) - def test_connection_none(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) @@ -748,142 +745,158 @@ class PortTestCase(unittest.TestCase): def test_is_connected_false(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): comp_self._add_input_port('clear') - def _consume(self): + def _user_consume(self): pass comp = self._create_comp(MySink) self.assertFalse(comp.input_ports['clear'].is_connected) - def test_eq(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - comp_self._add_input_port('clear') - - def _consume(self): - pass - - comp = self._create_comp(MySink) - self.assertEqual(comp.input_ports['clear'], - comp.input_ports['clear']) - - def test_eq_invalid(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - comp_self._add_input_port('clear') - - def _consume(self): - pass - - comp = self._create_comp(MySink) - self.assertNotEqual(comp.input_ports['clear'], 23) - - def test_disconnect_no_connection(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - port = comp_self._add_input_port('clear') - - def _consume(self): - pass - - comp = self._create_comp(MySink) - comp.input_ports['clear'].disconnect() - - def test_priv_name(self): + def test_self_name(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): port = comp_self._add_input_port('clear') self.assertEqual(port.name, 'clear') - def _consume(self): + def _user_consume(self): pass - comp = self._create_comp(MySink) - - def test_priv_component(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - port = comp_self._add_input_port('clear') - self.assertEqual(port.component, comp_self) - - def _consume(self): - pass - - comp = self._create_comp(MySink) + self._create_comp(MySink) - def test_priv_connection_none(self): + def test_self_connection_none(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): port = comp_self._add_input_port('clear') self.assertIsNone(port.connection) - def _consume(self): + def _user_consume(self): pass - comp = self._create_comp(MySink) + self._create_comp(MySink) - def test_priv_is_connected_false(self): + def test_self_is_connected_false(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): + def __init__(comp_self, config, params, obj): port = comp_self._add_input_port('clear') self.assertFalse(port.is_connected) - def _consume(self): + def _user_consume(self): pass - comp = self._create_comp(MySink) + self._create_comp(MySink) - def test_priv_eq(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - port = comp_self._add_input_port('clear') - self.assertEqual(port, port) + def test_source_self_port_user_data(self): + class MyUserData: + def __del__(self): + nonlocal objects_deleted + objects_deleted += 1 - def _consume(self): - pass + class MySource( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): + nonlocal user_datas - comp = self._create_comp(MySink) + p = comp_self._add_output_port('port1') + user_datas.append(p.user_data) + p = comp_self._add_output_port('port2', 2) + user_datas.append(p.user_data) + p = comp_self._add_output_port('port3', MyUserData()) + user_datas.append(p.user_data) - def test_priv_eq_invalid(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - port = comp_self._add_input_port('clear') - self.assertNotEqual(port, 23) + user_datas = [] + objects_deleted = 0 - def _consume(self): - pass + comp = self._create_comp(MySource) + self.assertEqual(len(user_datas), 3) + self.assertIs(user_datas[0], None) + self.assertEqual(user_datas[1], 2) + self.assertIs(type(user_datas[2]), MyUserData) + + # Verify that the user data gets freed. + self.assertEqual(objects_deleted, 0) + del user_datas + del comp + self.assertEqual(objects_deleted, 1) + + def test_filter_self_port_user_data(self): + class MyUserData: + def __del__(self): + nonlocal objects_deleted + objects_deleted += 1 + + class MyFilter( + bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator + ): + def __init__(comp_self, config, params, obj): + nonlocal user_datas + + p = comp_self._add_output_port('port1') + user_datas.append(p.user_data) + p = comp_self._add_output_port('port2', 'user data string') + user_datas.append(p.user_data) + p = comp_self._add_output_port('port3', MyUserData()) + user_datas.append(p.user_data) + + p = comp_self._add_input_port('port4') + user_datas.append(p.user_data) + p = comp_self._add_input_port('port5', user_data={'user data': 'dict'}) + user_datas.append(p.user_data) + p = comp_self._add_input_port('port6', MyUserData()) + user_datas.append(p.user_data) + + user_datas = [] + objects_deleted = 0 - comp = self._create_comp(MySink) + comp = self._create_comp(MyFilter) + self.assertEqual(len(user_datas), 6) + self.assertIs(user_datas[0], None) + self.assertEqual(user_datas[1], 'user data string') + self.assertIs(type(user_datas[2]), MyUserData) + self.assertIs(user_datas[3], None) + self.assertEqual(user_datas[4], {'user data': 'dict'}) + self.assertIs(type(user_datas[5]), MyUserData) + + # Verify that the user data gets freed. + self.assertEqual(objects_deleted, 0) + del user_datas + del comp + self.assertEqual(objects_deleted, 2) + + def test_sink_self_port_user_data(self): + class MyUserData: + def __del__(self): + nonlocal objects_deleted + objects_deleted += 1 - def test_priv_disconnect_no_connection(self): class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - port = comp_self._add_input_port('clear') - port.disconnect() + def __init__(comp_self, config, params, obj): + nonlocal user_datas - def _consume(self): - pass + p = comp_self._add_input_port('port1') + user_datas.append(p.user_data) + p = comp_self._add_input_port('port2', MyUserData()) + user_datas.append(p.user_data) - comp = self._create_comp(MySink) + def _user_consume(self): + pass - def test_priv_remove_from_component(self): - class MySink(bt2._UserSinkComponent): - def __init__(comp_self, params): - port = comp_self._add_input_port('clear') - self.assertEqual(len(comp_self._input_ports), 1) + user_datas = [] + objects_deleted = 0 - try: - port.remove_from_component() - except: - import traceback - traceback.print_exc() + comp = self._create_comp(MySink) + self.assertEqual(len(user_datas), 2) + self.assertIs(user_datas[0], None) + self.assertIs(type(user_datas[1]), MyUserData) - self.assertEqual(len(comp_self._input_ports), 0) - self.assertIsNone(port.component) + # Verify that the user data gets freed. + self.assertEqual(objects_deleted, 0) + del user_datas + del comp + self.assertEqual(objects_deleted, 1) - def _consume(self): - pass - comp = self._create_comp(MySink) +if __name__ == '__main__': + unittest.main()