tests/bindings/python/bt2/test_message_iterator.py

   1 #
   2 # Copyright (C) 2019 EfficiOS Inc.
   3 #
   4 # This program is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU General Public License
   6 # as published by the Free Software Foundation; only version 2
   7 # of the License.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17 #
  18
  19 import unittest
  20 import bt2
  21 import sys
  22 from utils import TestOutputPortMessageIterator
  23 from bt2 import port as bt2_port
  24 from bt2 import message_iterator as bt2_message_iterator
  25
  26
  27 class SimpleSink(bt2._UserSinkComponent):
  28     # Straightforward sink that creates one input port (`in`) and consumes from
  29     # it.
  30
  31     def __init__(self, config, params, obj):
  32         self._add_input_port('in')
  33
  34     def _user_consume(self):
  35         next(self._msg_iter)
  36
  37     def _user_graph_is_configured(self):
  38         self._msg_iter = self._create_input_port_message_iterator(
  39             self._input_ports['in']
  40         )
  41
  42
  43 def _create_graph(src_comp_cls, sink_comp_cls, flt_comp_cls=None):
  44     graph = bt2.Graph()
  45
  46     src_comp = graph.add_component(src_comp_cls, 'src')
  47     sink_comp = graph.add_component(sink_comp_cls, 'sink')
  48
  49     if flt_comp_cls is not None:
  50         flt_comp = graph.add_component(flt_comp_cls, 'flt')
  51         graph.connect_ports(src_comp.output_ports['out'], flt_comp.input_ports['in'])
  52         graph.connect_ports(flt_comp.output_ports['out'], sink_comp.input_ports['in'])
  53     else:
  54         graph.connect_ports(src_comp.output_ports['out'], sink_comp.input_ports['in'])
  55
  56     return graph
  57
  58
  59 class UserMessageIteratorTestCase(unittest.TestCase):
  60     def test_init(self):
  61         the_output_port_from_source = None
  62         the_output_port_from_iter = None
  63
  64         class MyIter(bt2._UserMessageIterator):
  65             def __init__(self, config, self_port_output):
  66                 nonlocal initialized
  67                 nonlocal the_output_port_from_iter
  68                 initialized = True
  69                 the_output_port_from_iter = self_port_output
  70
  71         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
  72             def __init__(self, config, params, obj):
  73                 nonlocal the_output_port_from_source
  74                 the_output_port_from_source = self._add_output_port('out', 'user data')
  75
  76         initialized = False
  77         graph = _create_graph(MySource, SimpleSink)
  78         graph.run()
  79         self.assertTrue(initialized)
  80         self.assertEqual(
  81             the_output_port_from_source.addr, the_output_port_from_iter.addr
  82         )
  83         self.assertEqual(the_output_port_from_iter.user_data, 'user data')
  84
  85     def test_create_from_message_iterator(self):
  86         class MySourceIter(bt2._UserMessageIterator):
  87             def __init__(self, config, self_port_output):
  88                 nonlocal src_iter_initialized
  89                 src_iter_initialized = True
  90
  91         class MySource(bt2._UserSourceComponent, message_iterator_class=MySourceIter):
  92             def __init__(self, config, params, obj):
  93                 self._add_output_port('out')
  94
  95         class MyFilterIter(bt2._UserMessageIterator):
  96             def __init__(self, config, self_port_output):
  97                 nonlocal flt_iter_initialized
  98                 flt_iter_initialized = True
  99                 self._up_iter = self._create_input_port_message_iterator(
 100                     self._component._input_ports['in']
 101                 )
 102
 103             def __next__(self):
 104                 return next(self._up_iter)
 105
 106         class MyFilter(bt2._UserFilterComponent, message_iterator_class=MyFilterIter):
 107             def __init__(self, config, params, obj):
 108                 self._add_input_port('in')
 109                 self._add_output_port('out')
 110
 111         src_iter_initialized = False
 112         flt_iter_initialized = False
 113         graph = _create_graph(MySource, SimpleSink, MyFilter)
 114         graph.run()
 115         self.assertTrue(src_iter_initialized)
 116         self.assertTrue(flt_iter_initialized)
 117
 118     def test_create_user_error(self):
 119         # This tests both error handling by
 120         # _UserSinkComponent._create_input_port_message_iterator
 121         # and _UserMessageIterator._create_input_port_message_iterator, as they
 122         # are both used in the graph.
 123         class MySourceIter(bt2._UserMessageIterator):
 124             def __init__(self, config, self_port_output):
 125                 raise ValueError('Very bad error')
 126
 127         class MySource(bt2._UserSourceComponent, message_iterator_class=MySourceIter):
 128             def __init__(self, config, params, obj):
 129                 self._add_output_port('out')
 130
 131         class MyFilterIter(bt2._UserMessageIterator):
 132             def __init__(self, config, self_port_output):
 133                 # This is expected to raise because of the error in
 134                 # MySourceIter.__init__.
 135                 self._create_input_port_message_iterator(
 136                     self._component._input_ports['in']
 137                 )
 138
 139         class MyFilter(bt2._UserFilterComponent, message_iterator_class=MyFilterIter):
 140             def __init__(self, config, params, obj):
 141                 self._add_input_port('in')
 142                 self._add_output_port('out')
 143
 144         graph = _create_graph(MySource, SimpleSink, MyFilter)
 145
 146         with self.assertRaises(bt2._Error) as ctx:
 147             graph.run()
 148
 149         exc = ctx.exception
 150         cause = exc[0]
 151
 152         self.assertIsInstance(cause, bt2._MessageIteratorErrorCause)
 153         self.assertEqual(cause.component_name, 'src')
 154         self.assertEqual(cause.component_output_port_name, 'out')
 155         self.assertIn('ValueError: Very bad error', cause.message)
 156
 157     def test_finalize(self):
 158         class MyIter(bt2._UserMessageIterator):
 159             def _user_finalize(self):
 160                 nonlocal finalized
 161                 finalized = True
 162
 163         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 164             def __init__(self, config, params, obj):
 165                 self._add_output_port('out')
 166
 167         finalized = False
 168         graph = _create_graph(MySource, SimpleSink)
 169         graph.run()
 170         del graph
 171         self.assertTrue(finalized)
 172
 173     def test_config_parameter(self):
 174         class MyIter(bt2._UserMessageIterator):
 175             def __init__(self, config, port):
 176                 nonlocal config_type
 177                 config_type = type(config)
 178
 179         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 180             def __init__(self, config, params, obj):
 181                 self._add_output_port('out')
 182
 183         config_type = None
 184         graph = _create_graph(MySource, SimpleSink)
 185         graph.run()
 186         self.assertIs(config_type, bt2_message_iterator._MessageIteratorConfiguration)
 187
 188     def _test_config_can_seek_forward(self, set_can_seek_forward):
 189         class MyIter(bt2._UserMessageIterator):
 190             def __init__(self, config, port):
 191                 if set_can_seek_forward:
 192                     config.can_seek_forward = True
 193
 194         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 195             def __init__(self, config, params, obj):
 196                 self._add_output_port('out')
 197
 198         class MySink(bt2._UserSinkComponent):
 199             def __init__(self, config, params, obj):
 200                 self._add_input_port('in')
 201
 202             def _user_graph_is_configured(self):
 203                 self._msg_iter = self._create_input_port_message_iterator(
 204                     self._input_ports['in']
 205                 )
 206
 207             def _user_consume(self):
 208                 nonlocal can_seek_forward
 209                 can_seek_forward = self._msg_iter.can_seek_forward
 210
 211         can_seek_forward = None
 212         graph = _create_graph(MySource, MySink)
 213         graph.run_once()
 214         self.assertIs(can_seek_forward, set_can_seek_forward)
 215
 216     def test_config_can_seek_forward_default(self):
 217         self._test_config_can_seek_forward(False)
 218
 219     def test_config_can_seek_forward(self):
 220         self._test_config_can_seek_forward(True)
 221
 222     def test_config_can_seek_forward_wrong_type(self):
 223         class MyIter(bt2._UserMessageIterator):
 224             def __init__(self, config, port):
 225                 config.can_seek_forward = 1
 226
 227         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 228             def __init__(self, config, params, obj):
 229                 self._add_output_port('out')
 230
 231         graph = _create_graph(MySource, SimpleSink)
 232         with self.assertRaises(bt2._Error) as ctx:
 233             graph.run()
 234
 235         root_cause = ctx.exception[0]
 236         self.assertIn("TypeError: 'int' is not a 'bool' object", root_cause.message)
 237
 238     def test_component(self):
 239         class MyIter(bt2._UserMessageIterator):
 240             def __init__(self, config, self_port_output):
 241                 nonlocal salut
 242                 salut = self._component._salut
 243
 244         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 245             def __init__(self, config, params, obj):
 246                 self._add_output_port('out')
 247                 self._salut = 23
 248
 249         salut = None
 250         graph = _create_graph(MySource, SimpleSink)
 251         graph.run()
 252         self.assertEqual(salut, 23)
 253
 254     def test_port(self):
 255         class MyIter(bt2._UserMessageIterator):
 256             def __init__(self_iter, config, self_port_output):
 257                 nonlocal called
 258                 called = True
 259                 port = self_iter._port
 260                 self.assertIs(type(self_port_output), bt2_port._UserComponentOutputPort)
 261                 self.assertIs(type(port), bt2_port._UserComponentOutputPort)
 262                 self.assertEqual(self_port_output.addr, port.addr)
 263
 264         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 265             def __init__(self, config, params, obj):
 266                 self._add_output_port('out')
 267
 268         called = False
 269         graph = _create_graph(MySource, SimpleSink)
 270         graph.run()
 271         self.assertTrue(called)
 272
 273     def test_addr(self):
 274         class MyIter(bt2._UserMessageIterator):
 275             def __init__(self, config, self_port_output):
 276                 nonlocal addr
 277                 addr = self.addr
 278
 279         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 280             def __init__(self, config, params, obj):
 281                 self._add_output_port('out')
 282
 283         addr = None
 284         graph = _create_graph(MySource, SimpleSink)
 285         graph.run()
 286         self.assertIsNotNone(addr)
 287         self.assertNotEqual(addr, 0)
 288
 289     # Test that messages returned by _UserMessageIterator.__next__ remain valid
 290     # and can be re-used.
 291     def test_reuse_message(self):
 292         class MyIter(bt2._UserMessageIterator):
 293             def __init__(self, config, port):
 294                 tc, sc, ec = port.user_data
 295                 trace = tc()
 296                 stream = trace.create_stream(sc)
 297                 packet = stream.create_packet()
 298
 299                 # This message will be returned twice by __next__.
 300                 event_message = self._create_event_message(ec, packet)
 301
 302                 self._msgs = [
 303                     self._create_stream_beginning_message(stream),
 304                     self._create_packet_beginning_message(packet),
 305                     event_message,
 306                     event_message,
 307                 ]
 308
 309             def __next__(self):
 310                 return self._msgs.pop(0)
 311
 312         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 313             def __init__(self, config, params, obj):
 314                 tc = self._create_trace_class()
 315                 sc = tc.create_stream_class(supports_packets=True)
 316                 ec = sc.create_event_class()
 317                 self._add_output_port('out', (tc, sc, ec))
 318
 319         graph = bt2.Graph()
 320         src = graph.add_component(MySource, 'src')
 321         it = TestOutputPortMessageIterator(graph, src.output_ports['out'])
 322
 323         # Skip beginning messages.
 324         msg = next(it)
 325         self.assertIs(type(msg), bt2._StreamBeginningMessageConst)
 326         msg = next(it)
 327         self.assertIs(type(msg), bt2._PacketBeginningMessageConst)
 328
 329         msg_ev1 = next(it)
 330         msg_ev2 = next(it)
 331
 332         self.assertIs(type(msg_ev1), bt2._EventMessageConst)
 333         self.assertIs(type(msg_ev2), bt2._EventMessageConst)
 334         self.assertEqual(msg_ev1.addr, msg_ev2.addr)
 335
 336     # Try consuming many times from an iterator that always returns TryAgain.
 337     # This verifies that we are not missing an incref of Py_None, making the
 338     # refcount of Py_None reach 0.
 339     def test_try_again_many_times(self):
 340         class MyIter(bt2._UserMessageIterator):
 341             def __next__(self):
 342                 raise bt2.TryAgain
 343
 344         class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter):
 345             def __init__(self, config, params, obj):
 346                 self._add_output_port('out')
 347
 348         class MyFilterIter(bt2._UserMessageIterator):
 349             def __init__(self, port):
 350                 input_port = port.user_data
 351                 self._upstream_iter = self._create_input_port_message_iterator(
 352                     input_port
 353                 )
 354
 355             def __next__(self):
 356                 return next(self._upstream_iter)
 357
 358             def _user_seek_beginning(self):
 359                 self._upstream_iter.seek_beginning()
 360
 361             def _user_can_seek_beginning(self):
 362                 return self._upstream_iter.can_seek_beginning()
 363
 364         class MyFilter(bt2._UserFilterComponent, message_iterator_class=MyFilterIter):
 365             def __init__(self, config, params, obj):
 366                 input_port = self._add_input_port('in')
 367                 self._add_output_port('out', input_port)
 368
 369         graph = bt2.Graph()
 370         src = graph.add_component(MySource, 'src')
 371         it = TestOutputPortMessageIterator(graph, src.output_ports['out'])
 372
 373         # Three times the initial ref count of `None` iterations should
 374         # be enough to catch the bug even if there are small differences
 375         # between configurations.
 376         none_ref_count = sys.getrefcount(None) * 3
 377
 378         for i in range(none_ref_count):
 379             with self.assertRaises(bt2.TryAgain):
 380                 next(it)
 381
 382
 383 def _setup_seek_test(
 384     sink_cls,
 385     user_seek_beginning=None,
 386     user_can_seek_beginning=None,
 387     user_seek_ns_from_origin=None,
 388     user_can_seek_ns_from_origin=None,
 389     can_seek_forward=False,
 390 ):
 391     class MySourceIter(bt2._UserMessageIterator):
 392         def __init__(self, config, port):
 393             tc, sc, ec = port.user_data
 394             trace = tc()
 395             stream = trace.create_stream(sc)
 396             packet = stream.create_packet()
 397
 398             self._msgs = [
 399                 self._create_stream_beginning_message(stream),
 400                 self._create_packet_beginning_message(packet),
 401                 self._create_event_message(ec, packet),
 402                 self._create_event_message(ec, packet),
 403                 self._create_packet_end_message(packet),
 404                 self._create_stream_end_message(stream),
 405             ]
 406             self._at = 0
 407             config.can_seek_forward = can_seek_forward
 408
 409         def __next__(self):
 410             if self._at < len(self._msgs):
 411                 msg = self._msgs[self._at]
 412                 self._at += 1
 413                 return msg
 414             else:
 415                 raise StopIteration
 416
 417     if user_seek_beginning is not None:
 418         MySourceIter._user_seek_beginning = user_seek_beginning
 419
 420     if user_can_seek_beginning is not None:
 421         MySourceIter._user_can_seek_beginning = user_can_seek_beginning
 422
 423     if user_seek_ns_from_origin is not None:
 424         MySourceIter._user_seek_ns_from_origin = user_seek_ns_from_origin
 425
 426     if user_can_seek_ns_from_origin is not None:
 427         MySourceIter._user_can_seek_ns_from_origin = user_can_seek_ns_from_origin
 428
 429     class MySource(bt2._UserSourceComponent, message_iterator_class=MySourceIter):
 430         def __init__(self, config, params, obj):
 431             tc = self._create_trace_class()
 432             sc = tc.create_stream_class(supports_packets=True)
 433             ec = sc.create_event_class()
 434
 435             self._add_output_port('out', (tc, sc, ec))
 436
 437     class MyFilterIter(bt2._UserMessageIterator):
 438         def __init__(self, config, port):
 439             self._upstream_iter = self._create_input_port_message_iterator(
 440                 self._component._input_ports['in']
 441             )
 442             config.can_seek_forward = self._upstream_iter.can_seek_forward
 443
 444         def __next__(self):
 445             return next(self._upstream_iter)
 446
 447         def _user_can_seek_beginning(self):
 448             return self._upstream_iter.can_seek_beginning()
 449
 450         def _user_seek_beginning(self):
 451             self._upstream_iter.seek_beginning()
 452
 453         def _user_can_seek_ns_from_origin(self, ns_from_origin):
 454             return self._upstream_iter.can_seek_ns_from_origin(ns_from_origin)
 455
 456         def _user_seek_ns_from_origin(self, ns_from_origin):
 457             self._upstream_iter.seek_ns_from_origin(ns_from_origin)
 458
 459     class MyFilter(bt2._UserFilterComponent, message_iterator_class=MyFilterIter):
 460         def __init__(self, config, params, obj):
 461             self._add_input_port('in')
 462             self._add_output_port('out')
 463
 464     return _create_graph(MySource, sink_cls, flt_comp_cls=MyFilter)
 465
 466
 467 class UserMessageIteratorSeekBeginningTestCase(unittest.TestCase):
 468     def test_can_seek_beginning_without_seek_beginning(self):
 469         with self.assertRaisesRegex(
 470             bt2._IncompleteUserClass,
 471             "cannot create component class 'MySource': message iterator class implements _user_can_seek_beginning but not _user_seek_beginning",
 472         ):
 473             _setup_seek_test(SimpleSink, user_can_seek_beginning=lambda: None)
 474
 475     def test_can_seek_beginning(self):
 476         class MySink(bt2._UserSinkComponent):
 477             def __init__(self, config, params, obj):
 478                 self._add_input_port('in')
 479
 480             def _user_graph_is_configured(self):
 481                 self._msg_iter = self._create_input_port_message_iterator(
 482                     self._input_ports['in']
 483                 )
 484
 485             def _user_consume(self):
 486                 nonlocal can_seek_beginning
 487                 can_seek_beginning = self._msg_iter.can_seek_beginning()
 488
 489         def _user_can_seek_beginning(self):
 490             nonlocal input_port_iter_can_seek_beginning
 491             return input_port_iter_can_seek_beginning
 492
 493         graph = _setup_seek_test(
 494             MySink,
 495             user_can_seek_beginning=_user_can_seek_beginning,
 496             user_seek_beginning=lambda: None,
 497         )
 498
 499         input_port_iter_can_seek_beginning = True
 500         can_seek_beginning = None
 501         graph.run_once()
 502         self.assertIs(can_seek_beginning, True)
 503
 504         input_port_iter_can_seek_beginning = False
 505         can_seek_beginning = None
 506         graph.run_once()
 507         self.assertIs(can_seek_beginning, False)
 508
 509     def test_no_can_seek_beginning_with_seek_beginning(self):
 510         # Test an iterator without a _user_can_seek_beginning method, but with
 511         # a _user_seek_beginning method.
 512         class MySink(bt2._UserSinkComponent):
 513             def __init__(self, config, params, obj):
 514                 self._add_input_port('in')
 515
 516             def _user_graph_is_configured(self):
 517                 self._msg_iter = self._create_input_port_message_iterator(
 518                     self._input_ports['in']
 519                 )
 520
 521             def _user_consume(self):
 522                 nonlocal can_seek_beginning
 523                 can_seek_beginning = self._msg_iter.can_seek_beginning()
 524
 525         def _user_seek_beginning(self):
 526             pass
 527
 528         graph = _setup_seek_test(MySink, user_seek_beginning=_user_seek_beginning)
 529         can_seek_beginning = None
 530         graph.run_once()
 531         self.assertIs(can_seek_beginning, True)
 532
 533     def test_no_can_seek_beginning(self):
 534         # Test an iterator without a _user_can_seek_beginning method, without
 535         # a _user_seek_beginning method.
 536         class MySink(bt2._UserSinkComponent):
 537             def __init__(self, config, params, obj):
 538                 self._add_input_port('in')
 539
 540             def _user_graph_is_configured(self):
 541                 self._msg_iter = self._create_input_port_message_iterator(
 542                     self._input_ports['in']
 543                 )
 544
 545             def _user_consume(self):
 546                 nonlocal can_seek_beginning
 547                 can_seek_beginning = self._msg_iter.can_seek_beginning()
 548
 549         graph = _setup_seek_test(MySink)
 550         can_seek_beginning = None
 551         graph.run_once()
 552         self.assertIs(can_seek_beginning, False)
 553
 554     def test_can_seek_beginning_user_error(self):
 555         class MySink(bt2._UserSinkComponent):
 556             def __init__(self, config, params, obj):
 557                 self._add_input_port('in')
 558
 559             def _user_graph_is_configured(self):
 560                 self._msg_iter = self._create_input_port_message_iterator(
 561                     self._input_ports['in']
 562                 )
 563
 564             def _user_consume(self):
 565                 # This is expected to raise.
 566                 self._msg_iter.can_seek_beginning()
 567
 568         def _user_can_seek_beginning(self):
 569             raise ValueError('moustiquaire')
 570
 571         graph = _setup_seek_test(
 572             MySink,
 573             user_can_seek_beginning=_user_can_seek_beginning,
 574             user_seek_beginning=lambda: None,
 575         )
 576
 577         with self.assertRaises(bt2._Error) as ctx:
 578             graph.run_once()
 579
 580         cause = ctx.exception[0]
 581         self.assertIn('ValueError: moustiquaire', cause.message)
 582
 583     def test_can_seek_beginning_wrong_return_value(self):
 584         class MySink(bt2._UserSinkComponent):
 585             def __init__(self, config, params, obj):
 586                 self._add_input_port('in')
 587
 588             def _user_graph_is_configured(self):
 589                 self._msg_iter = self._create_input_port_message_iterator(
 590                     self._input_ports['in']
 591                 )
 592
 593             def _user_consume(self):
 594                 # This is expected to raise.
 595                 self._msg_iter.can_seek_beginning()
 596
 597         def _user_can_seek_beginning(self):
 598             return 'Amqui'
 599
 600         graph = _setup_seek_test(
 601             MySink,
 602             user_can_seek_beginning=_user_can_seek_beginning,
 603             user_seek_beginning=lambda: None,
 604         )
 605
 606         with self.assertRaises(bt2._Error) as ctx:
 607             graph.run_once()
 608
 609         cause = ctx.exception[0]
 610         self.assertIn("TypeError: 'str' is not a 'bool' object", cause.message)
 611
 612     def test_seek_beginning(self):
 613         class MySink(bt2._UserSinkComponent):
 614             def __init__(self, config, params, obj):
 615                 self._add_input_port('in')
 616
 617             def _user_graph_is_configured(self):
 618                 self._msg_iter = self._create_input_port_message_iterator(
 619                     self._input_ports['in']
 620                 )
 621
 622             def _user_consume(self):
 623                 nonlocal do_seek_beginning
 624                 nonlocal msg
 625
 626                 if do_seek_beginning:
 627                     self._msg_iter.seek_beginning()
 628                     return
 629
 630                 msg = next(self._msg_iter)
 631
 632         def _user_seek_beginning(self):
 633             self._at = 0
 634
 635         msg = None
 636         graph = _setup_seek_test(MySink, user_seek_beginning=_user_seek_beginning)
 637
 638         # Consume message.
 639         do_seek_beginning = False
 640         graph.run_once()
 641         self.assertIs(type(msg), bt2._StreamBeginningMessageConst)
 642
 643         # Consume message.
 644         graph.run_once()
 645         self.assertIs(type(msg), bt2._PacketBeginningMessageConst)
 646
 647         # Seek beginning.
 648         do_seek_beginning = True
 649         graph.run_once()
 650
 651         # Consume message.
 652         do_seek_beginning = False
 653         graph.run_once()
 654         self.assertIs(type(msg), bt2._StreamBeginningMessageConst)
 655
 656     def test_seek_beginning_user_error(self):
 657         class MySink(bt2._UserSinkComponent):
 658             def __init__(self, config, params, obj):
 659                 self._add_input_port('in')
 660
 661             def _user_graph_is_configured(self):
 662                 self._msg_iter = self._create_input_port_message_iterator(
 663                     self._input_ports['in']
 664                 )
 665
 666             def _user_consume(self):
 667                 self._msg_iter.seek_beginning()
 668
 669         def _user_seek_beginning(self):
 670             raise ValueError('ouch')
 671
 672         graph = _setup_seek_test(MySink, user_seek_beginning=_user_seek_beginning)
 673
 674         with self.assertRaises(bt2._Error):
 675             graph.run_once()
 676
 677
 678 class UserMessageIteratorSeekNsFromOriginTestCase(unittest.TestCase):
 679     def test_can_seek_ns_from_origin_without_seek_ns_from_origin(self):
 680         # Test the case where:
 681         #
 682         #   - can_seek_ns_from_origin: Returns True (don't really care, as long
 683         #     as it's provided)
 684         #   - seek_ns_from_origin provided: No
 685         #   - can the iterator seek beginning: Don't care
 686         #   - can the iterator seek forward: Don't care
 687         for can_seek_ns_from_origin in (False, True):
 688             for iter_can_seek_beginning in (False, True):
 689                 for iter_can_seek_forward in (False, True):
 690                     with self.assertRaisesRegex(
 691                         bt2._IncompleteUserClass,
 692                         "cannot create component class 'MySource': message iterator class implements _user_can_seek_ns_from_origin but not _user_seek_ns_from_origin",
 693                     ):
 694                         self._can_seek_ns_from_origin_test(
 695                             None,
 696                             user_can_seek_ns_from_origin_ret_val=True,
 697                             user_seek_ns_from_origin_provided=False,
 698                             iter_can_seek_beginning=iter_can_seek_beginning,
 699                             iter_can_seek_forward=iter_can_seek_forward,
 700                         )
 701
 702     def test_can_seek_ns_from_origin_returns_true(self):
 703         # Test the case where:
 704         #
 705         #   - can_seek_ns_from_origin: returns True
 706         #   - seek_ns_from_origin provided: Yes
 707         #   - can the iterator seek beginning: Don't care
 708         #   - can the iterator seek forward: Don't care
 709         #
 710         # We expect iter.can_seek_ns_from_origin to return True.
 711         for iter_can_seek_beginning in (False, True):
 712             for iter_can_seek_forward in (False, True):
 713                 self._can_seek_ns_from_origin_test(
 714                     expected_outcome=True,
 715                     user_can_seek_ns_from_origin_ret_val=True,
 716                     user_seek_ns_from_origin_provided=True,
 717                     iter_can_seek_beginning=iter_can_seek_beginning,
 718                     iter_can_seek_forward=iter_can_seek_forward,
 719                 )
 720
 721     def test_can_seek_ns_from_origin_returns_false_can_seek_beginning_forward_seekable(
 722         self
 723     ):
 724         # Test the case where:
 725         #
 726         #   - can_seek_ns_from_origin: returns False
 727         #   - seek_ns_from_origin provided: Yes
 728         #   - can the iterator seek beginning: Yes
 729         #   - can the iterator seek forward: Yes
 730         #
 731         # We expect iter.can_seek_ns_from_origin to return True.
 732         self._can_seek_ns_from_origin_test(
 733             expected_outcome=True,
 734             user_can_seek_ns_from_origin_ret_val=False,
 735             user_seek_ns_from_origin_provided=True,
 736             iter_can_seek_beginning=True,
 737             iter_can_seek_forward=True,
 738         )
 739
 740     def test_can_seek_ns_from_origin_returns_false_can_seek_beginning_not_forward_seekable(
 741         self
 742     ):
 743         # Test the case where:
 744         #
 745         #   - can_seek_ns_from_origin: returns False
 746         #   - seek_ns_from_origin provided: Yes
 747         #   - can the iterator seek beginning: Yes
 748         #   - can the iterator seek forward: No
 749         #
 750         # We expect iter.can_seek_ns_from_origin to return False.
 751         self._can_seek_ns_from_origin_test(
 752             expected_outcome=False,
 753             user_can_seek_ns_from_origin_ret_val=False,
 754             user_seek_ns_from_origin_provided=True,
 755             iter_can_seek_beginning=True,
 756             iter_can_seek_forward=False,
 757         )
 758
 759     def test_can_seek_ns_from_origin_returns_false_cant_seek_beginning_forward_seekable(
 760         self
 761     ):
 762         # Test the case where:
 763         #
 764         #   - can_seek_ns_from_origin: returns False
 765         #   - seek_ns_from_origin provided: Yes
 766         #   - can the iterator seek beginning: No
 767         #   - can the iterator seek forward: Yes
 768         #
 769         # We expect iter.can_seek_ns_from_origin to return False.
 770         self._can_seek_ns_from_origin_test(
 771             expected_outcome=False,
 772             user_can_seek_ns_from_origin_ret_val=False,
 773             user_seek_ns_from_origin_provided=True,
 774             iter_can_seek_beginning=False,
 775             iter_can_seek_forward=True,
 776         )
 777
 778     def test_can_seek_ns_from_origin_returns_false_cant_seek_beginning_not_forward_seekable(
 779         self
 780     ):
 781         # Test the case where:
 782         #
 783         #   - can_seek_ns_from_origin: returns False
 784         #   - seek_ns_from_origin provided: Yes
 785         #   - can the iterator seek beginning: No
 786         #   - can the iterator seek forward: No
 787         #
 788         # We expect iter.can_seek_ns_from_origin to return False.
 789         self._can_seek_ns_from_origin_test(
 790             expected_outcome=False,
 791             user_can_seek_ns_from_origin_ret_val=False,
 792             user_seek_ns_from_origin_provided=True,
 793             iter_can_seek_beginning=False,
 794             iter_can_seek_forward=False,
 795         )
 796
 797     def test_no_can_seek_ns_from_origin_seek_ns_from_origin(self):
 798         # Test the case where:
 799         #
 800         #   - can_seek_ns_from_origin: Not provided
 801         #   - seek_ns_from_origin provided: Yes
 802         #   - can the iterator seek beginning: Don't care
 803         #   - can the iterator seek forward: Don't care
 804         #
 805         # We expect iter.can_seek_ns_from_origin to return True.
 806         for iter_can_seek_beginning in (False, True):
 807             for iter_can_seek_forward in (False, True):
 808                 self._can_seek_ns_from_origin_test(
 809                     expected_outcome=True,
 810                     user_can_seek_ns_from_origin_ret_val=None,
 811                     user_seek_ns_from_origin_provided=True,
 812                     iter_can_seek_beginning=iter_can_seek_beginning,
 813                     iter_can_seek_forward=iter_can_seek_forward,
 814                 )
 815
 816     def test_no_can_seek_ns_from_origin_no_seek_ns_from_origin_can_seek_beginning_forward_seekable(
 817         self
 818     ):
 819         # Test the case where:
 820         #
 821         #   - can_seek_ns_from_origin: Not provided
 822         #   - seek_ns_from_origin provided: Not provided
 823         #   - can the iterator seek beginning: Yes
 824         #   - can the iterator seek forward: Yes
 825         #
 826         # We expect iter.can_seek_ns_from_origin to return True.
 827         self._can_seek_ns_from_origin_test(
 828             expected_outcome=True,
 829             user_can_seek_ns_from_origin_ret_val=None,
 830             user_seek_ns_from_origin_provided=False,
 831             iter_can_seek_beginning=True,
 832             iter_can_seek_forward=True,
 833         )
 834
 835     def test_no_can_seek_ns_from_origin_no_seek_ns_from_origin_can_seek_beginning_not_forward_seekable(
 836         self
 837     ):
 838         # Test the case where:
 839         #
 840         #   - can_seek_ns_from_origin: Not provided
 841         #   - seek_ns_from_origin provided: Not provided
 842         #   - can the iterator seek beginning: Yes
 843         #   - can the iterator seek forward: No
 844         #
 845         # We expect iter.can_seek_ns_from_origin to return False.
 846         self._can_seek_ns_from_origin_test(
 847             expected_outcome=False,
 848             user_can_seek_ns_from_origin_ret_val=None,
 849             user_seek_ns_from_origin_provided=False,
 850             iter_can_seek_beginning=True,
 851             iter_can_seek_forward=False,
 852         )
 853
 854     def test_no_can_seek_ns_from_origin_no_seek_ns_from_origin_cant_seek_beginning_forward_seekable(
 855         self
 856     ):
 857         # Test the case where:
 858         #
 859         #   - can_seek_ns_from_origin: Not provided
 860         #   - seek_ns_from_origin provided: Not provided
 861         #   - can the iterator seek beginning: No
 862         #   - can the iterator seek forward: Yes
 863         #
 864         # We expect iter.can_seek_ns_from_origin to return False.
 865         self._can_seek_ns_from_origin_test(
 866             expected_outcome=False,
 867             user_can_seek_ns_from_origin_ret_val=None,
 868             user_seek_ns_from_origin_provided=False,
 869             iter_can_seek_beginning=False,
 870             iter_can_seek_forward=True,
 871         )
 872
 873     def test_no_can_seek_ns_from_origin_no_seek_ns_from_origin_cant_seek_beginning_not_forward_seekable(
 874         self
 875     ):
 876         # Test the case where:
 877         #
 878         #   - can_seek_ns_from_origin: Not provided
 879         #   - seek_ns_from_origin provided: Not provided
 880         #   - can the iterator seek beginning: No
 881         #   - can the iterator seek forward: No
 882         #
 883         # We expect iter.can_seek_ns_from_origin to return False.
 884         self._can_seek_ns_from_origin_test(
 885             expected_outcome=False,
 886             user_can_seek_ns_from_origin_ret_val=None,
 887             user_seek_ns_from_origin_provided=False,
 888             iter_can_seek_beginning=False,
 889             iter_can_seek_forward=False,
 890         )
 891
 892     def _can_seek_ns_from_origin_test(
 893         self,
 894         expected_outcome,
 895         user_can_seek_ns_from_origin_ret_val,
 896         user_seek_ns_from_origin_provided,
 897         iter_can_seek_beginning,
 898         iter_can_seek_forward,
 899     ):
 900         class MySink(bt2._UserSinkComponent):
 901             def __init__(self, config, params, obj):
 902                 self._add_input_port('in')
 903
 904             def _user_graph_is_configured(self):
 905                 self._msg_iter = self._create_input_port_message_iterator(
 906                     self._input_ports['in']
 907                 )
 908
 909             def _user_consume(self):
 910                 nonlocal can_seek_ns_from_origin
 911                 can_seek_ns_from_origin = self._msg_iter.can_seek_ns_from_origin(
 912                     passed_ns_from_origin
 913                 )
 914
 915         if user_can_seek_ns_from_origin_ret_val is not None:
 916
 917             def user_can_seek_ns_from_origin(self, ns_from_origin):
 918                 nonlocal received_ns_from_origin
 919                 received_ns_from_origin = ns_from_origin
 920                 return user_can_seek_ns_from_origin_ret_val
 921
 922         else:
 923             user_can_seek_ns_from_origin = None
 924
 925         if user_seek_ns_from_origin_provided:
 926
 927             def user_seek_ns_from_origin(self, ns_from_origin):
 928                 pass
 929
 930         else:
 931             user_seek_ns_from_origin = None
 932
 933         if iter_can_seek_beginning:
 934
 935             def user_seek_beginning(self):
 936                 pass
 937
 938         else:
 939             user_seek_beginning = None
 940
 941         graph = _setup_seek_test(
 942             MySink,
 943             user_can_seek_ns_from_origin=user_can_seek_ns_from_origin,
 944             user_seek_ns_from_origin=user_seek_ns_from_origin,
 945             user_seek_beginning=user_seek_beginning,
 946             can_seek_forward=iter_can_seek_forward,
 947         )
 948
 949         passed_ns_from_origin = 77
 950         received_ns_from_origin = None
 951         can_seek_ns_from_origin = None
 952         graph.run_once()
 953         self.assertIs(can_seek_ns_from_origin, expected_outcome)
 954
 955         if user_can_seek_ns_from_origin_ret_val is not None:
 956             self.assertEqual(received_ns_from_origin, passed_ns_from_origin)
 957
 958     def test_can_seek_ns_from_origin_user_error(self):
 959         class MySink(bt2._UserSinkComponent):
 960             def __init__(self, config, params, obj):
 961                 self._add_input_port('in')
 962
 963             def _user_graph_is_configured(self):
 964                 self._msg_iter = self._create_input_port_message_iterator(
 965                     self._input_ports['in']
 966                 )
 967
 968             def _user_consume(self):
 969                 # This is expected to raise.
 970                 self._msg_iter.can_seek_ns_from_origin(2)
 971
 972         def _user_can_seek_ns_from_origin(self, ns_from_origin):
 973             raise ValueError('Joutel')
 974
 975         graph = _setup_seek_test(
 976             MySink,
 977             user_can_seek_ns_from_origin=_user_can_seek_ns_from_origin,
 978             user_seek_ns_from_origin=lambda: None,
 979         )
 980
 981         with self.assertRaises(bt2._Error) as ctx:
 982             graph.run_once()
 983
 984         cause = ctx.exception[0]
 985         self.assertIn('ValueError: Joutel', cause.message)
 986
 987     def test_can_seek_ns_from_origin_wrong_return_value(self):
 988         class MySink(bt2._UserSinkComponent):
 989             def __init__(self, config, params, obj):
 990                 self._add_input_port('in')
 991
 992             def _user_graph_is_configured(self):
 993                 self._msg_iter = self._create_input_port_message_iterator(
 994                     self._input_ports['in']
 995                 )
 996
 997             def _user_consume(self):
 998                 # This is expected to raise.
 999                 self._msg_iter.can_seek_ns_from_origin(2)
1000
1001         def _user_can_seek_ns_from_origin(self, ns_from_origin):
1002             return 'Nitchequon'
1003
1004         graph = _setup_seek_test(
1005             MySink,
1006             user_can_seek_ns_from_origin=_user_can_seek_ns_from_origin,
1007             user_seek_ns_from_origin=lambda: None,
1008         )
1009
1010         with self.assertRaises(bt2._Error) as ctx:
1011             graph.run_once()
1012
1013         cause = ctx.exception[0]
1014         self.assertIn("TypeError: 'str' is not a 'bool' object", cause.message)
1015
1016     def test_seek_ns_from_origin(self):
1017         class MySink(bt2._UserSinkComponent):
1018             def __init__(self, config, params, obj):
1019                 self._add_input_port('in')
1020
1021             def _user_graph_is_configured(self):
1022                 self._msg_iter = self._create_input_port_message_iterator(
1023                     self._input_ports['in']
1024                 )
1025
1026             def _user_consume(self):
1027                 self._msg_iter.seek_ns_from_origin(17)
1028
1029         def _user_seek_ns_from_origin(self, ns_from_origin):
1030             nonlocal actual_ns_from_origin
1031             actual_ns_from_origin = ns_from_origin
1032
1033         graph = _setup_seek_test(
1034             MySink, user_seek_ns_from_origin=_user_seek_ns_from_origin
1035         )
1036
1037         actual_ns_from_origin = None
1038         graph.run_once()
1039         self.assertEqual(actual_ns_from_origin, 17)
1040
1041
1042 if __name__ == '__main__':
1043     unittest.main()