tests/bindings/python/bt2/test_message.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 utils
  22 from utils import TestOutputPortMessageIterator
  23 from bt2 import clock_snapshot as bt2_clock_snapshot
  24 from bt2 import event as bt2_event
  25 from bt2 import event_class as bt2_event_class
  26 from bt2 import field as bt2_field
  27 from bt2 import packet as bt2_packet
  28 from bt2 import stream as bt2_stream
  29 from bt2 import stream_class as bt2_stream_class
  30 from bt2 import trace as bt2_trace
  31 from bt2 import trace_class as bt2_trace_class
  32
  33
  34 class AllMessagesTestCase(unittest.TestCase):
  35     def setUp(self):
  36         class MyIter(bt2._UserMessageIterator):
  37             def __init__(self, self_port_output):
  38                 self._at = 0
  39                 self._with_stream_msgs_clock_snapshots = self_port_output.user_data.get(
  40                     'with_stream_msgs_clock_snapshots', False
  41                 )
  42
  43             def __next__(self):
  44                 if test_obj._clock_class:
  45                     if self._at == 0:
  46                         if self._with_stream_msgs_clock_snapshots:
  47                             msg = self._create_stream_beginning_message(
  48                                 test_obj._stream, default_clock_snapshot=self._at
  49                             )
  50                         else:
  51                             msg = self._create_stream_beginning_message(
  52                                 test_obj._stream
  53                             )
  54                         test_obj.assertIs(type(msg), bt2._StreamBeginningMessage)
  55                     elif self._at == 1:
  56                         msg = self._create_packet_beginning_message(
  57                             test_obj._packet, self._at
  58                         )
  59                         test_obj.assertIs(type(msg), bt2._PacketBeginningMessage)
  60                     elif self._at == 2:
  61                         msg = self._create_event_message(
  62                             test_obj._event_class, test_obj._packet, self._at
  63                         )
  64                         test_obj.assertIs(type(msg), bt2._EventMessage)
  65                     elif self._at == 3:
  66                         msg = self._create_message_iterator_inactivity_message(
  67                             test_obj._clock_class, self._at
  68                         )
  69                     elif self._at == 4:
  70                         msg = self._create_discarded_events_message(
  71                             test_obj._stream, 890, self._at, self._at
  72                         )
  73                         test_obj.assertIs(type(msg), bt2._DiscardedEventsMessage)
  74                     elif self._at == 5:
  75                         msg = self._create_packet_end_message(
  76                             test_obj._packet, self._at
  77                         )
  78                         test_obj.assertIs(type(msg), bt2._PacketEndMessage)
  79                     elif self._at == 6:
  80                         msg = self._create_discarded_packets_message(
  81                             test_obj._stream, 678, self._at, self._at
  82                         )
  83                         test_obj.assertIs(type(msg), bt2._DiscardedPacketsMessage)
  84                     elif self._at == 7:
  85                         if self._with_stream_msgs_clock_snapshots:
  86                             msg = self._create_stream_end_message(
  87                                 test_obj._stream, default_clock_snapshot=self._at
  88                             )
  89                         else:
  90                             msg = self._create_stream_end_message(test_obj._stream)
  91                         test_obj.assertIs(type(msg), bt2._StreamEndMessage)
  92                     elif self._at >= 8:
  93                         raise bt2.Stop
  94                 else:
  95                     if self._at == 0:
  96                         msg = self._create_stream_beginning_message(test_obj._stream)
  97                     elif self._at == 1:
  98                         msg = self._create_packet_beginning_message(test_obj._packet)
  99                     elif self._at == 2:
 100                         msg = self._create_event_message(
 101                             test_obj._event_class, test_obj._packet
 102                         )
 103                     elif self._at == 3:
 104                         msg = self._create_discarded_events_message(
 105                             test_obj._stream, 890
 106                         )
 107                     elif self._at == 4:
 108                         msg = self._create_packet_end_message(test_obj._packet)
 109                     elif self._at == 5:
 110                         msg = self._create_discarded_packets_message(
 111                             test_obj._stream, 678
 112                         )
 113                     elif self._at == 6:
 114                         msg = self._create_stream_end_message(test_obj._stream)
 115                     elif self._at >= 7:
 116                         raise bt2.Stop
 117
 118                 self._at += 1
 119                 return msg
 120
 121         class MySrc(bt2._UserSourceComponent, message_iterator_class=MyIter):
 122             def __init__(self, params, obj):
 123                 self._add_output_port('out', params)
 124
 125                 with_cc = bool(params['with_cc'])
 126                 tc = self._create_trace_class()
 127                 if with_cc:
 128                     cc = self._create_clock_class()
 129                 else:
 130                     cc = None
 131
 132                 sc = tc.create_stream_class(
 133                     default_clock_class=cc,
 134                     supports_packets=True,
 135                     packets_have_beginning_default_clock_snapshot=with_cc,
 136                     packets_have_end_default_clock_snapshot=with_cc,
 137                     supports_discarded_events=True,
 138                     discarded_events_have_default_clock_snapshots=with_cc,
 139                     supports_discarded_packets=True,
 140                     discarded_packets_have_default_clock_snapshots=with_cc,
 141                 )
 142
 143                 # Create payload field class
 144                 my_int_fc = tc.create_signed_integer_field_class(32)
 145                 payload_fc = tc.create_structure_field_class()
 146                 payload_fc += [('my_int', my_int_fc)]
 147
 148                 # Create specific context field class
 149                 my_int_fc = tc.create_signed_integer_field_class(32)
 150                 specific_fc = tc.create_structure_field_class()
 151                 specific_fc += [('my_int', my_int_fc)]
 152
 153                 ec = sc.create_event_class(
 154                     name='salut',
 155                     payload_field_class=payload_fc,
 156                     specific_context_field_class=specific_fc,
 157                 )
 158
 159                 trace = tc()
 160                 stream = trace.create_stream(sc)
 161                 packet = stream.create_packet()
 162
 163                 test_obj._trace = trace
 164                 test_obj._stream = stream
 165                 test_obj._packet = packet
 166                 test_obj._event_class = ec
 167                 test_obj._clock_class = cc
 168
 169         test_obj = self
 170         self._graph = bt2.Graph()
 171         self._src = MySrc
 172         self._iter = MyIter
 173
 174     def test_all_msg_with_cc(self):
 175         params = {'with_cc': True}
 176         self._src_comp = self._graph.add_component(self._src, 'my_source', params)
 177         self._msg_iter = TestOutputPortMessageIterator(
 178             self._graph, self._src_comp.output_ports['out']
 179         )
 180
 181         for i, msg in enumerate(self._msg_iter):
 182             if i == 0:
 183                 self.assertIs(type(msg), bt2._StreamBeginningMessageConst)
 184                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 185                 self.assertEqual(msg.stream.addr, self._stream.addr)
 186                 self.assertIsInstance(
 187                     msg.default_clock_snapshot, bt2._UnknownClockSnapshot
 188                 )
 189             elif i == 1:
 190                 self.assertIs(type(msg), bt2._PacketBeginningMessageConst)
 191                 self.assertIs(type(msg.packet), bt2_packet._PacketConst)
 192                 self.assertIs(
 193                     type(msg.default_clock_snapshot),
 194                     bt2_clock_snapshot._ClockSnapshotConst,
 195                 )
 196                 self.assertEqual(msg.packet.addr, self._packet.addr)
 197                 self.assertEqual(msg.default_clock_snapshot.value, i)
 198             elif i == 2:
 199                 self.assertIs(type(msg), bt2._EventMessageConst)
 200                 self.assertIs(type(msg.event), bt2_event._EventConst)
 201                 self.assertIs(
 202                     type(msg.default_clock_snapshot),
 203                     bt2_clock_snapshot._ClockSnapshotConst,
 204                 )
 205                 self.assertIs(
 206                     type(msg.event.payload_field), bt2_field._StructureFieldConst
 207                 )
 208                 self.assertIs(
 209                     type(msg.event.payload_field['my_int']),
 210                     bt2_field._SignedIntegerFieldConst,
 211                 )
 212
 213                 self.assertEqual(msg.event.cls.addr, self._event_class.addr)
 214                 self.assertEqual(msg.default_clock_snapshot.value, i)
 215             elif i == 3:
 216                 self.assertIs(type(msg), bt2._MessageIteratorInactivityMessageConst)
 217                 self.assertIs(
 218                     type(msg.default_clock_snapshot),
 219                     bt2_clock_snapshot._ClockSnapshotConst,
 220                 )
 221                 self.assertEqual(msg.default_clock_snapshot.value, i)
 222             elif i == 4:
 223                 self.assertIs(type(msg), bt2._DiscardedEventsMessageConst)
 224                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 225                 self.assertIs(type(msg.stream.cls), bt2_stream_class._StreamClassConst)
 226                 self.assertIs(
 227                     type(msg.beginning_default_clock_snapshot),
 228                     bt2_clock_snapshot._ClockSnapshotConst,
 229                 )
 230                 self.assertIs(
 231                     type(msg.end_default_clock_snapshot),
 232                     bt2_clock_snapshot._ClockSnapshotConst,
 233                 )
 234
 235                 self.assertEqual(msg.stream.addr, self._stream.addr)
 236                 self.assertEqual(msg.count, 890)
 237                 self.assertEqual(
 238                     msg.stream.cls.default_clock_class.addr, self._clock_class.addr
 239                 )
 240                 self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
 241                 self.assertEqual(msg.end_default_clock_snapshot.value, i)
 242             elif i == 5:
 243                 self.assertIs(type(msg), bt2._PacketEndMessageConst)
 244                 self.assertIs(type(msg.packet), bt2_packet._PacketConst)
 245                 self.assertIs(
 246                     type(msg.default_clock_snapshot),
 247                     bt2_clock_snapshot._ClockSnapshotConst,
 248                 )
 249                 self.assertEqual(msg.packet.addr, self._packet.addr)
 250                 self.assertEqual(msg.default_clock_snapshot.value, i)
 251             elif i == 6:
 252                 self.assertIs(type(msg), bt2._DiscardedPacketsMessageConst)
 253                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 254                 self.assertIs(type(msg.stream.trace), bt2_trace._TraceConst)
 255                 self.assertIs(
 256                     type(msg.stream.trace.cls), bt2_trace_class._TraceClassConst
 257                 )
 258                 self.assertIs(
 259                     type(msg.beginning_default_clock_snapshot),
 260                     bt2_clock_snapshot._ClockSnapshotConst,
 261                 )
 262                 self.assertIs(
 263                     type(msg.end_default_clock_snapshot),
 264                     bt2_clock_snapshot._ClockSnapshotConst,
 265                 )
 266                 self.assertEqual(msg.stream.addr, self._stream.addr)
 267                 self.assertEqual(msg.count, 678)
 268                 self.assertEqual(
 269                     msg.stream.cls.default_clock_class.addr, self._clock_class.addr
 270                 )
 271                 self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
 272                 self.assertEqual(msg.end_default_clock_snapshot.value, i)
 273             elif i == 7:
 274                 self.assertIs(type(msg), bt2._StreamEndMessageConst)
 275                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 276                 self.assertEqual(msg.stream.addr, self._stream.addr)
 277                 self.assertIs(
 278                     type(msg.default_clock_snapshot), bt2._UnknownClockSnapshot
 279                 )
 280             else:
 281                 raise Exception
 282
 283     def test_all_msg_without_cc(self):
 284         params = {'with_cc': False}
 285         self._src_comp = self._graph.add_component(self._src, 'my_source', params)
 286         self._msg_iter = TestOutputPortMessageIterator(
 287             self._graph, self._src_comp.output_ports['out']
 288         )
 289
 290         for i, msg in enumerate(self._msg_iter):
 291             if i == 0:
 292                 self.assertIsInstance(msg, bt2._StreamBeginningMessageConst)
 293                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 294                 self.assertEqual(msg.stream.addr, self._stream.addr)
 295                 with self.assertRaisesRegex(
 296                     ValueError, 'stream class has no default clock class'
 297                 ):
 298                     msg.default_clock_snapshot
 299             elif i == 1:
 300                 self.assertIsInstance(msg, bt2._PacketBeginningMessageConst)
 301                 self.assertIs(type(msg.packet), bt2_packet._PacketConst)
 302                 self.assertEqual(msg.packet.addr, self._packet.addr)
 303             elif i == 2:
 304                 self.assertIsInstance(msg, bt2._EventMessageConst)
 305                 self.assertIs(type(msg.event), bt2_event._EventConst)
 306                 self.assertIs(type(msg.event.cls), bt2_event_class._EventClassConst)
 307                 self.assertEqual(msg.event.cls.addr, self._event_class.addr)
 308                 with self.assertRaisesRegex(
 309                     ValueError, 'stream class has no default clock class'
 310                 ):
 311                     msg.default_clock_snapshot
 312             elif i == 3:
 313                 self.assertIsInstance(msg, bt2._DiscardedEventsMessageConst)
 314                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 315                 self.assertIs(type(msg.stream.cls), bt2_stream_class._StreamClassConst)
 316                 self.assertEqual(msg.stream.addr, self._stream.addr)
 317                 self.assertEqual(msg.count, 890)
 318                 self.assertIsNone(msg.stream.cls.default_clock_class)
 319                 with self.assertRaisesRegex(
 320                     ValueError,
 321                     'such a message has no clock snapshots for this stream class',
 322                 ):
 323                     msg.beginning_default_clock_snapshot
 324                 with self.assertRaisesRegex(
 325                     ValueError,
 326                     'such a message has no clock snapshots for this stream class',
 327                 ):
 328                     msg.end_default_clock_snapshot
 329             elif i == 4:
 330                 self.assertIsInstance(msg, bt2._PacketEndMessageConst)
 331                 self.assertEqual(msg.packet.addr, self._packet.addr)
 332                 self.assertIs(type(msg.packet), bt2_packet._PacketConst)
 333             elif i == 5:
 334                 self.assertIsInstance(msg, bt2._DiscardedPacketsMessageConst)
 335                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 336                 self.assertIs(type(msg.stream.cls), bt2_stream_class._StreamClassConst)
 337                 self.assertIs(
 338                     type(msg.stream.cls.trace_class), bt2_trace_class._TraceClassConst
 339                 )
 340                 self.assertEqual(msg.stream.addr, self._stream.addr)
 341                 self.assertEqual(msg.count, 678)
 342                 self.assertIsNone(msg.stream.cls.default_clock_class)
 343                 with self.assertRaisesRegex(
 344                     ValueError,
 345                     'such a message has no clock snapshots for this stream class',
 346                 ):
 347                     msg.beginning_default_clock_snapshot
 348                 with self.assertRaisesRegex(
 349                     ValueError,
 350                     'such a message has no clock snapshots for this stream class',
 351                 ):
 352                     msg.end_default_clock_snapshot
 353             elif i == 6:
 354                 self.assertIsInstance(msg, bt2._StreamEndMessageConst)
 355                 self.assertIs(type(msg.stream), bt2_stream._StreamConst)
 356                 self.assertEqual(msg.stream.addr, self._stream.addr)
 357                 with self.assertRaisesRegex(
 358                     ValueError, 'stream class has no default clock class'
 359                 ):
 360                     msg.default_clock_snapshot
 361             else:
 362                 raise Exception
 363
 364     def test_msg_stream_with_clock_snapshots(self):
 365         params = {'with_cc': True, 'with_stream_msgs_clock_snapshots': True}
 366
 367         self._src_comp = self._graph.add_component(self._src, 'my_source', params)
 368         self._msg_iter = TestOutputPortMessageIterator(
 369             self._graph, self._src_comp.output_ports['out']
 370         )
 371         msgs = list(self._msg_iter)
 372
 373         msg_stream_beg = msgs[0]
 374         self.assertIsInstance(msg_stream_beg, bt2._StreamBeginningMessageConst)
 375         self.assertIs(
 376             type(msg_stream_beg.default_clock_snapshot),
 377             bt2_clock_snapshot._ClockSnapshotConst,
 378         )
 379         self.assertEqual(msg_stream_beg.default_clock_snapshot.value, 0)
 380
 381         msg_stream_end = msgs[7]
 382         self.assertIsInstance(msg_stream_end, bt2._StreamEndMessageConst)
 383         self.assertIs(
 384             type(msg_stream_end.default_clock_snapshot),
 385             bt2_clock_snapshot._ClockSnapshotConst,
 386         )
 387         self.assertEqual(msg_stream_end.default_clock_snapshot.value, 7)
 388
 389     def test_stream_beg_msg(self):
 390         msg = utils.get_stream_beginning_message()
 391         self.assertIs(type(msg.stream), bt2_stream._Stream)
 392
 393     def test_stream_end_msg(self):
 394         msg = utils.get_stream_end_message()
 395         self.assertIs(type(msg.stream), bt2_stream._Stream)
 396
 397     def test_packet_beg_msg(self):
 398         msg = utils.get_packet_beginning_message()
 399         self.assertIs(type(msg.packet), bt2_packet._Packet)
 400
 401     def test_packet_end_msg(self):
 402         msg = utils.get_packet_end_message()
 403         self.assertIs(type(msg.packet), bt2_packet._Packet)
 404
 405     def test_event_msg(self):
 406         msg = utils.get_event_message()
 407         self.assertIs(type(msg.event), bt2_event._Event)