tests/bindings/python/bt2/test_message.py

   1 import collections
   2 import unittest
   3 import bt2
   4
   5
   6 class AllMessagesTestCase(unittest.TestCase):
   7     def setUp(self):
   8
   9         class MyIter(bt2._UserMessageIterator):
  10             def __init__(self, self_port_output):
  11                 self._at = 0
  12
  13             def __next__(self):
  14                 if test_obj._clock_class:
  15                     if self._at == 0:
  16                         msg = self._create_stream_beginning_message(test_obj._stream)
  17                     elif self._at == 1:
  18                         msg = self._create_stream_activity_beginning_message(test_obj._stream, default_clock_snapshot=self._at)
  19                     elif self._at == 2:
  20                         msg = self._create_packet_beginning_message(test_obj._packet, self._at)
  21                     elif self._at == 3:
  22                         msg = self._create_event_message(test_obj._event_class, test_obj._packet, self._at)
  23                     elif self._at == 4:
  24                         msg = self._create_message_iterator_inactivity_message(test_obj._clock_class, self._at)
  25                     elif self._at == 5:
  26                         msg = self._create_discarded_events_message(test_obj._stream, 890, self._at, self._at)
  27                     elif self._at == 6:
  28                         msg = self._create_packet_end_message(test_obj._packet, self._at)
  29                     elif self._at == 7:
  30                         msg = self._create_discarded_packets_message(test_obj._stream, 678, self._at, self._at)
  31                     elif self._at == 8:
  32                         msg = self._create_stream_activity_end_message(test_obj._stream, default_clock_snapshot=self._at)
  33                     elif self._at == 9:
  34                         msg = self._create_stream_end_message(test_obj._stream)
  35                     elif self._at >= 10:
  36                         raise bt2.Stop
  37                 else:
  38                     if self._at == 0:
  39                         msg = self._create_stream_beginning_message(test_obj._stream)
  40                     elif self._at == 1:
  41                         msg = self._create_stream_activity_beginning_message(test_obj._stream)
  42                     elif self._at == 2:
  43                         msg = self._create_packet_beginning_message(test_obj._packet)
  44                     elif self._at == 3:
  45                         msg = self._create_event_message(test_obj._event_class, test_obj._packet)
  46                     elif self._at == 4:
  47                         msg = self._create_discarded_events_message(test_obj._stream, 890)
  48                     elif self._at == 5:
  49                         msg = self._create_packet_end_message(test_obj._packet)
  50                     elif self._at == 6:
  51                         msg = self._create_discarded_packets_message(test_obj._stream, 678)
  52                     elif self._at == 7:
  53                         msg = self._create_stream_activity_end_message(test_obj._stream)
  54                     elif self._at == 8:
  55                         msg = self._create_stream_end_message(test_obj._stream)
  56                     elif self._at >= 9:
  57                         raise bt2.Stop
  58
  59                 self._at += 1
  60                 return msg
  61
  62         class MySrc(bt2._UserSourceComponent, message_iterator_class=MyIter):
  63             def __init__(self, params):
  64                 self._add_output_port('out')
  65
  66                 with_cc = bool(params['with_cc'])
  67                 tc = self._create_trace_class()
  68                 if with_cc:
  69                     cc = self._create_clock_class()
  70                 else:
  71                     cc = None
  72
  73                 sc = tc.create_stream_class(default_clock_class=cc,
  74                                             packets_have_beginning_default_clock_snapshot=with_cc,
  75                                             packets_have_end_default_clock_snapshot=with_cc,
  76                                             supports_discarded_events=True,
  77                                             discarded_events_have_default_clock_snapshots=with_cc,
  78                                             supports_discarded_packets=True,
  79                                             discarded_packets_have_default_clock_snapshots=with_cc)
  80
  81                 # Create payload field class
  82                 my_int_fc = tc.create_signed_integer_field_class(32)
  83                 payload_fc = tc.create_structure_field_class()
  84                 payload_fc += collections.OrderedDict([
  85                     ('my_int', my_int_fc),
  86                 ])
  87
  88                 ec = sc.create_event_class(name='salut', payload_field_class=payload_fc)
  89
  90                 trace = tc()
  91                 stream = trace.create_stream(sc)
  92                 packet = stream.create_packet()
  93
  94                 test_obj._trace = trace
  95                 test_obj._stream = stream
  96                 test_obj._packet = packet
  97                 test_obj._event_class = ec
  98                 test_obj._clock_class = cc
  99
 100         test_obj = self
 101         self._graph = bt2.Graph()
 102         self._src = MySrc
 103         self._iter = MyIter
 104
 105     def test_all_msg_with_cc(self):
 106         params = {'with_cc': True}
 107         self._src_comp = self._graph.add_component(self._src, 'my_source', params)
 108         self._msg_iter = self._graph.create_output_port_message_iterator(self._src_comp.output_ports['out'])
 109
 110         for i, msg in enumerate(self._msg_iter):
 111             if i == 0:
 112                 self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
 113                 self.assertEqual(msg.stream.addr, self._stream.addr)
 114             elif i == 1:
 115                 self.assertIsInstance(msg, bt2.message._StreamActivityBeginningMessage)
 116                 self.assertEqual(msg.default_clock_snapshot.value, i)
 117             elif i == 2:
 118                 self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
 119                 self.assertEqual(msg.packet.addr, self._packet.addr)
 120                 self.assertEqual(msg.default_clock_snapshot.value, i)
 121             elif i == 3:
 122                 self.assertIsInstance(msg, bt2.message._EventMessage)
 123                 self.assertEqual(msg.event.cls.addr, self._event_class.addr)
 124                 self.assertEqual(msg.default_clock_snapshot.value, i)
 125             elif i == 4:
 126                 self.assertIsInstance(msg, bt2.message._MessageIteratorInactivityMessage)
 127                 self.assertEqual(msg.default_clock_snapshot.value, i)
 128             elif i == 5:
 129                 self.assertIsInstance(msg, bt2.message._DiscardedEventsMessage)
 130                 self.assertEqual(msg.stream.addr, self._stream.addr)
 131                 self.assertEqual(msg.count, 890)
 132                 self.assertEqual(msg.stream.cls.default_clock_class.addr, self._clock_class.addr)
 133                 self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
 134                 self.assertEqual(msg.end_default_clock_snapshot.value, i)
 135             elif i == 6:
 136                 self.assertIsInstance(msg, bt2.message._PacketEndMessage)
 137                 self.assertEqual(msg.packet.addr, self._packet.addr)
 138                 self.assertEqual(msg.default_clock_snapshot.value, i)
 139             elif i == 7:
 140                 self.assertIsInstance(msg, bt2.message._DiscardedPacketsMessage)
 141                 self.assertEqual(msg.stream.addr, self._stream.addr)
 142                 self.assertEqual(msg.count, 678)
 143                 self.assertEqual(msg.stream.cls.default_clock_class.addr, self._clock_class.addr)
 144                 self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
 145                 self.assertEqual(msg.end_default_clock_snapshot.value, i)
 146             elif i == 8:
 147                 self.assertIsInstance(msg, bt2.message._StreamActivityEndMessage)
 148                 self.assertEqual(msg.stream.addr, self._stream.addr)
 149                 self.assertEqual(msg.default_clock_snapshot.value, i)
 150             elif i == 9:
 151                 self.assertIsInstance(msg, bt2.message._StreamEndMessage)
 152                 self.assertEqual(msg.stream.addr, self._stream.addr)
 153             else:
 154                 raise Exception
 155
 156     def test_all_msg_without_cc(self):
 157         params = {'with_cc': False}
 158         self._src_comp = self._graph.add_component(self._src, 'my_source', params)
 159         self._msg_iter = self._graph.create_output_port_message_iterator(self._src_comp.output_ports['out'])
 160
 161         for i, msg in enumerate(self._msg_iter):
 162             if i == 0:
 163                 self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
 164                 self.assertEqual(msg.stream.addr, self._stream.addr)
 165             elif i == 1:
 166                 self.assertIsInstance(msg, bt2.message._StreamActivityBeginningMessage)
 167                 self.assertIsInstance(msg.default_clock_snapshot,
 168                                       bt2._UnknownClockSnapshot)
 169             elif i == 2:
 170                 self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
 171                 self.assertEqual(msg.packet.addr, self._packet.addr)
 172             elif i == 3:
 173                 self.assertIsInstance(msg, bt2.message._EventMessage)
 174                 self.assertEqual(msg.event.cls.addr, self._event_class.addr)
 175                 with self.assertRaises(bt2.NonexistentClockSnapshot):
 176                     msg.default_clock_snapshot
 177             elif i == 4:
 178                 self.assertIsInstance(msg, bt2.message._DiscardedEventsMessage)
 179                 self.assertEqual(msg.stream.addr, self._stream.addr)
 180                 self.assertEqual(msg.count, 890)
 181                 self.assertIsNone(msg.stream.cls.default_clock_class)
 182                 with self.assertRaises(bt2.NonexistentClockSnapshot):
 183                     msg.beginning_default_clock_snapshot
 184                 with self.assertRaises(bt2.NonexistentClockSnapshot):
 185                     msg.end_default_clock_snapshot
 186             elif i == 5:
 187                 self.assertIsInstance(msg, bt2.message._PacketEndMessage)
 188                 self.assertEqual(msg.packet.addr, self._packet.addr)
 189             elif i == 6:
 190                 self.assertIsInstance(msg, bt2.message._DiscardedPacketsMessage)
 191                 self.assertEqual(msg.stream.addr, self._stream.addr)
 192                 self.assertEqual(msg.count, 678)
 193                 self.assertIsNone(msg.stream.cls.default_clock_class)
 194                 with self.assertRaises(bt2.NonexistentClockSnapshot):
 195                     msg.beginning_default_clock_snapshot
 196                 with self.assertRaises(bt2.NonexistentClockSnapshot):
 197                     msg.end_default_clock_snapshot
 198             elif i == 7:
 199                 self.assertIsInstance(msg, bt2.message._StreamActivityEndMessage)
 200                 self.assertEqual(msg.stream.addr, self._stream.addr)
 201                 self.assertIsInstance(msg.default_clock_snapshot,
 202                                       bt2._UnknownClockSnapshot)
 203             elif i == 8:
 204                 self.assertIsInstance(msg, bt2.message._StreamEndMessage)
 205                 self.assertEqual(msg.stream.addr, self._stream.addr)
 206             else:
 207                 raise Exception
 208
 209
 210 class StreamActivityMessagesTestCase(unittest.TestCase):
 211     def _test_create_msg(self, with_cc, test_create_beginning_func, test_create_end_func):
 212         class MyIter(bt2._UserMessageIterator):
 213             def __init__(self, self_port_output):
 214                 self._at = 0
 215
 216             def __next__(self):
 217                 if self._at == 0:
 218                     msg = self._create_stream_beginning_message(self._component._stream)
 219                 elif self._at == 1:
 220                     msg = test_create_beginning_func(self, self._component._stream)
 221                 elif self._at == 2:
 222                     msg = test_create_end_func(self, self._component._stream)
 223                 elif self._at == 3:
 224                     msg = self._create_stream_end_message(self._component._stream)
 225                 elif self._at >= 4:
 226                     raise bt2.Stop
 227
 228                 self._at += 1
 229                 return msg
 230
 231         class MySrc(bt2._UserSourceComponent, message_iterator_class=MyIter):
 232             def __init__(self, params):
 233                 self._add_output_port('out')
 234                 tc = self._create_trace_class()
 235
 236                 if with_cc:
 237                     cc = self._create_clock_class()
 238                     sc = tc.create_stream_class(default_clock_class=cc)
 239                 else:
 240                     sc = tc.create_stream_class()
 241
 242                 # Create payload field class
 243                 trace = tc()
 244                 self._stream = trace.create_stream(sc)
 245
 246         graph = bt2.Graph()
 247         src_comp = graph.add_component(MySrc, 'src')
 248         msg_iter = graph.create_output_port_message_iterator(src_comp.output_ports['out'])
 249
 250         for msg in msg_iter:
 251             pass
 252
 253     def test_create_beginning_with_cc_with_known_default_cs(self):
 254         def create_beginning(msg_iter, stream):
 255             msg = msg_iter._create_stream_activity_beginning_message(stream, 172)
 256             self.assertEqual(msg.default_clock_snapshot.value, 172)
 257             return msg
 258
 259         def create_end(msg_iter, stream):
 260             return msg_iter._create_stream_activity_end_message(stream, 199)
 261
 262         self._test_create_msg(True, create_beginning, create_end)
 263
 264     def test_create_end_with_cc_with_known_default_cs(self):
 265         def create_beginning(msg_iter, stream):
 266             return msg_iter._create_stream_activity_beginning_message(stream, 172)
 267
 268         def create_end(msg_iter, stream):
 269             msg = msg_iter._create_stream_activity_end_message(stream, 199)
 270             self.assertEqual(msg.default_clock_snapshot.value, 199)
 271             return msg
 272
 273         self._test_create_msg(True, create_beginning, create_end)
 274
 275     def test_create_beginning_with_cc_with_unknown_default_cs(self):
 276         def create_beginning(msg_iter, stream):
 277             msg = msg_iter._create_stream_activity_beginning_message(stream,
 278                                                                      msg_iter._unknown_clock_snapshot)
 279             self.assertIsInstance(msg.default_clock_snapshot,
 280                                   bt2._UnknownClockSnapshot)
 281             return msg
 282
 283         def create_end(msg_iter, stream):
 284             return msg_iter._create_stream_activity_end_message(stream, 199)
 285
 286         self._test_create_msg(True, create_beginning, create_end)
 287
 288     def test_create_end_with_cc_with_unknown_default_cs(self):
 289         def create_beginning(msg_iter, stream):
 290             return msg_iter._create_stream_activity_beginning_message(stream, 172)
 291
 292         def create_end(msg_iter, stream):
 293             msg = msg_iter._create_stream_activity_end_message(stream,
 294                                                                msg_iter._unknown_clock_snapshot)
 295             self.assertIsInstance(msg.default_clock_snapshot,
 296                                   bt2._UnknownClockSnapshot)
 297             return msg
 298
 299         self._test_create_msg(True, create_beginning, create_end)
 300
 301     def test_create_beginning_with_cc_with_infinite_default_cs(self):
 302         def create_beginning(msg_iter, stream):
 303             msg = msg_iter._create_stream_activity_beginning_message(stream,
 304                                                                      msg_iter._infinite_clock_snapshot)
 305             self.assertIsInstance(msg.default_clock_snapshot,
 306                                   bt2._InfiniteClockSnapshot)
 307             return msg
 308
 309         def create_end(msg_iter, stream):
 310             return msg_iter._create_stream_activity_end_message(stream, 199)
 311
 312         self._test_create_msg(True, create_beginning, create_end)
 313
 314     def test_create_end_with_cc_with_infinite_default_cs(self):
 315         def create_beginning(msg_iter, stream):
 316             return msg_iter._create_stream_activity_beginning_message(stream, 172)
 317
 318         def create_end(msg_iter, stream):
 319             msg = msg_iter._create_stream_activity_end_message(stream,
 320                                                                msg_iter._infinite_clock_snapshot)
 321             self.assertIsInstance(msg.default_clock_snapshot,
 322                                   bt2._InfiniteClockSnapshot)
 323             return msg
 324
 325         self._test_create_msg(True, create_beginning, create_end)
 326
 327     def test_create_beginning_without_cc_with_known_default_cs(self):
 328         def create_beginning(msg_iter, stream):
 329             with self.assertRaises(ValueError):
 330                 msg_iter._create_stream_activity_beginning_message(stream, 172)
 331
 332             return msg_iter._create_stream_activity_beginning_message(stream)
 333
 334         def create_end(msg_iter, stream):
 335             return msg_iter._create_stream_activity_end_message(stream)
 336
 337         self._test_create_msg(False, create_beginning, create_end)
 338
 339     def test_create_end_without_cc_with_known_default_cs(self):
 340         def create_beginning(msg_iter, stream):
 341             return msg_iter._create_stream_activity_beginning_message(stream)
 342
 343         def create_end(msg_iter, stream):
 344             with self.assertRaises(ValueError):
 345                 msg_iter._create_stream_activity_end_message(stream, 199)
 346
 347             return msg_iter._create_stream_activity_end_message(stream)
 348
 349         self._test_create_msg(False, create_beginning, create_end)
 350
 351     def test_create_beginning_without_cc_with_unknown_default_cs(self):
 352         def create_beginning(msg_iter, stream):
 353             msg = msg_iter._create_stream_activity_beginning_message(stream,
 354                                                                      msg_iter._unknown_clock_snapshot)
 355             self.assertIsInstance(msg.default_clock_snapshot,
 356                                   bt2._UnknownClockSnapshot)
 357             return msg
 358
 359         def create_end(msg_iter, stream):
 360             return msg_iter._create_stream_activity_end_message(stream)
 361
 362         self._test_create_msg(False, create_beginning, create_end)
 363
 364     def test_create_end_without_cc_with_unknown_default_cs(self):
 365         def create_beginning(msg_iter, stream):
 366             return msg_iter._create_stream_activity_beginning_message(stream)
 367
 368         def create_end(msg_iter, stream):
 369             msg = msg_iter._create_stream_activity_end_message(stream,
 370                                                                msg_iter._unknown_clock_snapshot)
 371             self.assertIsInstance(msg.default_clock_snapshot,
 372                                   bt2._UnknownClockSnapshot)
 373             return msg
 374
 375         self._test_create_msg(False, create_beginning, create_end)
 376
 377     def test_create_beginning_without_cc_with_infinite_default_cs(self):
 378         def create_beginning(msg_iter, stream):
 379             msg = msg_iter._create_stream_activity_beginning_message(stream,
 380                                                                      msg_iter._infinite_clock_snapshot)
 381             self.assertIsInstance(msg.default_clock_snapshot,
 382                                   bt2._InfiniteClockSnapshot)
 383             return msg
 384
 385         def create_end(msg_iter, stream):
 386             return msg_iter._create_stream_activity_end_message(stream)
 387
 388         self._test_create_msg(False, create_beginning, create_end)
 389
 390     def test_create_end_without_cc_with_infinite_default_cs(self):
 391         def create_beginning(msg_iter, stream):
 392             return msg_iter._create_stream_activity_beginning_message(stream)
 393
 394         def create_end(msg_iter, stream):
 395             msg = msg_iter._create_stream_activity_end_message(stream,
 396                                                                msg_iter._infinite_clock_snapshot)
 397             self.assertIsInstance(msg.default_clock_snapshot,
 398                                   bt2._InfiniteClockSnapshot)
 399             return msg
 400
 401         self._test_create_msg(False, create_beginning, create_end)
 402
 403     def test_create_beginning_default_cs_wrong_type(self):
 404         def create_beginning(msg_iter, stream):
 405             with self.assertRaises(TypeError):
 406                 msg_iter._create_stream_activity_beginning_message(stream, 'infinite')
 407
 408             return msg_iter._create_stream_activity_beginning_message(stream)
 409
 410         def create_end(msg_iter, stream):
 411             return msg_iter._create_stream_activity_end_message(stream)
 412
 413         self._test_create_msg(False, create_beginning, create_end)
 414
 415     def test_create_end_without_default_cs_wrong_type(self):
 416         def create_beginning(msg_iter, stream):
 417             return msg_iter._create_stream_activity_beginning_message(stream)
 418
 419         def create_end(msg_iter, stream):
 420             with self.assertRaises(TypeError):
 421                 msg_iter._create_stream_activity_end_message(stream, 'unknown')
 422
 423             return msg_iter._create_stream_activity_end_message(stream)
 424
 425         self._test_create_msg(False, create_beginning, create_end)