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

#
# Copyright (C) 2019 EfficiOS Inc.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; only version 2
# of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#

import collections
import unittest
import bt2


class AllMessagesTestCase(unittest.TestCase):
    def setUp(self):
        class MyIter(bt2._UserMessageIterator):
            def __init__(self, self_port_output):
                self._at = 0
                self._with_stream_msgs_clock_snapshots = self_port_output.user_data.get(
                    'with_stream_msgs_clock_snapshots', False
                )

            def __next__(self):
                if test_obj._clock_class:
                    if self._at == 0:
                        if self._with_stream_msgs_clock_snapshots:
                            msg = self._create_stream_beginning_message(
                                test_obj._stream, default_clock_snapshot=self._at
                            )
                        else:
                            msg = self._create_stream_beginning_message(
                                test_obj._stream
                            )
                    elif self._at == 1:
                        msg = self._create_packet_beginning_message(
                            test_obj._packet, self._at
                        )
                    elif self._at == 2:
                        msg = self._create_event_message(
                            test_obj._event_class, test_obj._packet, self._at
                        )
                    elif self._at == 3:
                        msg = self._create_message_iterator_inactivity_message(
                            test_obj._clock_class, self._at
                        )
                    elif self._at == 4:
                        msg = self._create_discarded_events_message(
                            test_obj._stream, 890, self._at, self._at
                        )
                    elif self._at == 5:
                        msg = self._create_packet_end_message(
                            test_obj._packet, self._at
                        )
                    elif self._at == 6:
                        msg = self._create_discarded_packets_message(
                            test_obj._stream, 678, self._at, self._at
                        )
                    elif self._at == 7:
                        if self._with_stream_msgs_clock_snapshots:
                            msg = self._create_stream_end_message(
                                test_obj._stream, default_clock_snapshot=self._at
                            )
                        else:
                            msg = self._create_stream_end_message(test_obj._stream)
                    elif self._at >= 8:
                        raise bt2.Stop
                else:
                    if self._at == 0:
                        msg = self._create_stream_beginning_message(test_obj._stream)
                    elif self._at == 1:
                        msg = self._create_packet_beginning_message(test_obj._packet)
                    elif self._at == 2:
                        msg = self._create_event_message(
                            test_obj._event_class, test_obj._packet
                        )
                    elif self._at == 3:
                        msg = self._create_discarded_events_message(
                            test_obj._stream, 890
                        )
                    elif self._at == 4:
                        msg = self._create_packet_end_message(test_obj._packet)
                    elif self._at == 5:
                        msg = self._create_discarded_packets_message(
                            test_obj._stream, 678
                        )
                    elif self._at == 6:
                        msg = self._create_stream_end_message(test_obj._stream)
                    elif self._at >= 7:
                        raise bt2.Stop

                self._at += 1
                return msg

        class MySrc(bt2._UserSourceComponent, message_iterator_class=MyIter):
            def __init__(self, params):
                self._add_output_port('out', params)

                with_cc = bool(params['with_cc'])
                tc = self._create_trace_class()
                if with_cc:
                    cc = self._create_clock_class()
                else:
                    cc = None

                sc = tc.create_stream_class(
                    default_clock_class=cc,
                    supports_packets=True,
                    packets_have_beginning_default_clock_snapshot=with_cc,
                    packets_have_end_default_clock_snapshot=with_cc,
                    supports_discarded_events=True,
                    discarded_events_have_default_clock_snapshots=with_cc,
                    supports_discarded_packets=True,
                    discarded_packets_have_default_clock_snapshots=with_cc,
                )

                # Create payload field class
                my_int_fc = tc.create_signed_integer_field_class(32)
                payload_fc = tc.create_structure_field_class()
                payload_fc += [('my_int', my_int_fc)]

                ec = sc.create_event_class(name='salut', payload_field_class=payload_fc)

                trace = tc()
                stream = trace.create_stream(sc)
                packet = stream.create_packet()

                test_obj._trace = trace
                test_obj._stream = stream
                test_obj._packet = packet
                test_obj._event_class = ec
                test_obj._clock_class = cc

        test_obj = self
        self._graph = bt2.Graph()
        self._src = MySrc
        self._iter = MyIter

    def test_all_msg_with_cc(self):
        params = {'with_cc': True}
        self._src_comp = self._graph.add_component(self._src, 'my_source', params)
        self._msg_iter = self._graph.create_output_port_message_iterator(
            self._src_comp.output_ports['out']
        )

        for i, msg in enumerate(self._msg_iter):
            if i == 0:
                self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertIsInstance(
                    msg.default_clock_snapshot, bt2.clock_snapshot._UnknownClockSnapshot
                )
            elif i == 1:
                self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 2:
                self.assertIsInstance(msg, bt2.message._EventMessage)
                self.assertEqual(msg.event.cls.addr, self._event_class.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 3:
                self.assertIsInstance(
                    msg, bt2.message._MessageIteratorInactivityMessage
                )
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 4:
                self.assertIsInstance(msg, bt2.message._DiscardedEventsMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertEqual(msg.count, 890)
                self.assertEqual(
                    msg.stream.cls.default_clock_class.addr, self._clock_class.addr
                )
                self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
                self.assertEqual(msg.end_default_clock_snapshot.value, i)
            elif i == 5:
                self.assertIsInstance(msg, bt2.message._PacketEndMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 6:
                self.assertIsInstance(msg, bt2.message._DiscardedPacketsMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertEqual(msg.count, 678)
                self.assertEqual(
                    msg.stream.cls.default_clock_class.addr, self._clock_class.addr
                )
                self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
                self.assertEqual(msg.end_default_clock_snapshot.value, i)
            elif i == 7:
                self.assertIsInstance(msg, bt2.message._StreamEndMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertIsInstance(
                    msg.default_clock_snapshot, bt2.clock_snapshot._UnknownClockSnapshot
                )
            else:
                raise Exception

    def test_all_msg_without_cc(self):
        params = {'with_cc': False}
        self._src_comp = self._graph.add_component(self._src, 'my_source', params)
        self._msg_iter = self._graph.create_output_port_message_iterator(
            self._src_comp.output_ports['out']
        )

        for i, msg in enumerate(self._msg_iter):
            if i == 0:
                self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                with self.assertRaises(bt2.NonexistentClockSnapshot):
                    msg.default_clock_snapshot
            elif i == 1:
                self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
            elif i == 2:
                self.assertIsInstance(msg, bt2.message._EventMessage)
                self.assertEqual(msg.event.cls.addr, self._event_class.addr)
                with self.assertRaises(bt2.NonexistentClockSnapshot):
                    msg.default_clock_snapshot
            elif i == 3:
                self.assertIsInstance(msg, bt2.message._DiscardedEventsMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertEqual(msg.count, 890)
                self.assertIsNone(msg.stream.cls.default_clock_class)
                with self.assertRaises(bt2.NonexistentClockSnapshot):
                    msg.beginning_default_clock_snapshot
                with self.assertRaises(bt2.NonexistentClockSnapshot):
                    msg.end_default_clock_snapshot
            elif i == 4:
                self.assertIsInstance(msg, bt2.message._PacketEndMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
            elif i == 5:
                self.assertIsInstance(msg, bt2.message._DiscardedPacketsMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertEqual(msg.count, 678)
                self.assertIsNone(msg.stream.cls.default_clock_class)
                with self.assertRaises(bt2.NonexistentClockSnapshot):
                    msg.beginning_default_clock_snapshot
                with self.assertRaises(bt2.NonexistentClockSnapshot):
                    msg.end_default_clock_snapshot
            elif i == 6:
                self.assertIsInstance(msg, bt2.message._StreamEndMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                with self.assertRaises(bt2.NonexistentClockSnapshot):
                    msg.default_clock_snapshot
            else:
                raise Exception

    def test_msg_stream_with_clock_snapshots(self):
        params = {'with_cc': True, 'with_stream_msgs_clock_snapshots': True}

        self._src_comp = self._graph.add_component(self._src, 'my_source', params)
        self._msg_iter = self._graph.create_output_port_message_iterator(
            self._src_comp.output_ports['out']
        )
        msgs = list(self._msg_iter)

        msg_stream_beg = msgs[0]
        self.assertIsInstance(msg_stream_beg, bt2.message._StreamBeginningMessage)
        self.assertEqual(msg_stream_beg.default_clock_snapshot.value, 0)

        msg_stream_end = msgs[7]
        self.assertIsInstance(msg_stream_end, bt2.message._StreamEndMessage)
        self.assertEqual(msg_stream_end.default_clock_snapshot.value, 7)
Commit	Line	Data
d2d857a8 MJ	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
811644b8 PP	19	import collections
811644b8 PP	20	import unittest
811644b8 PP	21	import bt2
	22
	23
9ec609ec	24	class AllMessagesTestCase(unittest.TestCase):
811644b8	25	def setUp(self):
5602ef81	26	class MyIter(bt2._UserMessageIterator):
c5f330cd	27	def __init__(self, self_port_output):
9ec609ec	28	self._at = 0
cfbd7cf3 FD	29	self._with_stream_msgs_clock_snapshots = self_port_output.user_data.get(
	30	'with_stream_msgs_clock_snapshots', False
	31	)
811644b8 PP	32
811644b8 PP	33	def __next__(self):
9ec609ec SM	34	if test_obj._clock_class:
9ec609ec SM	35	if self._at == 0:
188edac1	36	if self._with_stream_msgs_clock_snapshots:
cfbd7cf3 FD	37	msg = self._create_stream_beginning_message(
	38	test_obj._stream, default_clock_snapshot=self._at
	39	)
188edac1	40	else:
cfbd7cf3 FD	41	msg = self._create_stream_beginning_message(
	42	test_obj._stream
	43	)
9ec609ec	44	elif self._at == 1:
cfbd7cf3 FD	45	msg = self._create_packet_beginning_message(
	46	test_obj._packet, self._at
	47	)
188edac1	48	elif self._at == 2:
cfbd7cf3 FD	49	msg = self._create_event_message(
	50	test_obj._event_class, test_obj._packet, self._at
	51	)
188edac1	52	elif self._at == 3:
cfbd7cf3 FD	53	msg = self._create_message_iterator_inactivity_message(
	54	test_obj._clock_class, self._at
	55	)
188edac1	56	elif self._at == 4:
cfbd7cf3 FD	57	msg = self._create_discarded_events_message(
	58	test_obj._stream, 890, self._at, self._at
	59	)
188edac1	60	elif self._at == 5:
cfbd7cf3 FD	61	msg = self._create_packet_end_message(
	62	test_obj._packet, self._at
	63	)
188edac1	64	elif self._at == 6:
cfbd7cf3 FD	65	msg = self._create_discarded_packets_message(
	66	test_obj._stream, 678, self._at, self._at
	67	)
188edac1 SM	68	elif self._at == 7:
188edac1 SM	69	if self._with_stream_msgs_clock_snapshots:
cfbd7cf3 FD	70	msg = self._create_stream_end_message(
	71	test_obj._stream, default_clock_snapshot=self._at
	72	)
188edac1 SM	73	else:
	74	msg = self._create_stream_end_message(test_obj._stream)
	75	elif self._at >= 8:
9ec609ec	76	raise bt2.Stop
811644b8	77	else:
9ec609ec SM	78	if self._at == 0:
	79	msg = self._create_stream_beginning_message(test_obj._stream)
	80	elif self._at == 1:
9ec609ec	81	msg = self._create_packet_beginning_message(test_obj._packet)
188edac1	82	elif self._at == 2:
cfbd7cf3 FD	83	msg = self._create_event_message(
	84	test_obj._event_class, test_obj._packet
	85	)
188edac1	86	elif self._at == 3:
cfbd7cf3 FD	87	msg = self._create_discarded_events_message(
	88	test_obj._stream, 890
	89	)
188edac1	90	elif self._at == 4:
9ec609ec	91	msg = self._create_packet_end_message(test_obj._packet)
188edac1	92	elif self._at == 5:
cfbd7cf3 FD	93	msg = self._create_discarded_packets_message(
	94	test_obj._stream, 678
	95	)
188edac1	96	elif self._at == 6:
9ec609ec	97	msg = self._create_stream_end_message(test_obj._stream)
188edac1	98	elif self._at >= 7:
9ec609ec	99	raise bt2.Stop
811644b8 PP	100
811644b8 PP	101	self._at += 1
5602ef81	102	return msg
811644b8	103
9ec609ec	104	class MySrc(bt2._UserSourceComponent, message_iterator_class=MyIter):
811644b8	105	def __init__(self, params):
188edac1	106	self._add_output_port('out', params)
811644b8	107
2e90378a	108	with_cc = bool(params['with_cc'])
9ec609ec SM	109	tc = self._create_trace_class()
	110	if with_cc:
	111	cc = self._create_clock_class()
811644b8	112	else:
9ec609ec	113	cc = None
9ec609ec	114
cfbd7cf3 FD	115	sc = tc.create_stream_class(
	116	default_clock_class=cc,
	117	supports_packets=True,
	118	packets_have_beginning_default_clock_snapshot=with_cc,
	119	packets_have_end_default_clock_snapshot=with_cc,
	120	supports_discarded_events=True,
	121	discarded_events_have_default_clock_snapshots=with_cc,
	122	supports_discarded_packets=True,
	123	discarded_packets_have_default_clock_snapshots=with_cc,
	124	)
9ec609ec SM	125
	126	# Create payload field class
	127	my_int_fc = tc.create_signed_integer_field_class(32)
	128	payload_fc = tc.create_structure_field_class()
cfbd7cf3	129	payload_fc += [('my_int', my_int_fc)]
9ec609ec SM	130
	131	ec = sc.create_event_class(name='salut', payload_field_class=payload_fc)
	132
	133	trace = tc()
	134	stream = trace.create_stream(sc)
	135	packet = stream.create_packet()
	136
	137	test_obj._trace = trace
	138	test_obj._stream = stream
	139	test_obj._packet = packet
	140	test_obj._event_class = ec
	141	test_obj._clock_class = cc
	142
	143	test_obj = self
	144	self._graph = bt2.Graph()
	145	self._src = MySrc
	146	self._iter = MyIter
	147
	148	def test_all_msg_with_cc(self):
	149	params = {'with_cc': True}
	150	self._src_comp = self._graph.add_component(self._src, 'my_source', params)
cfbd7cf3 FD	151	self._msg_iter = self._graph.create_output_port_message_iterator(
	152	self._src_comp.output_ports['out']
	153	)
9ec609ec SM	154
	155	for i, msg in enumerate(self._msg_iter):
	156	if i == 0:
	157	self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
	158	self.assertEqual(msg.stream.addr, self._stream.addr)
cfbd7cf3 FD	159	self.assertIsInstance(
	160	msg.default_clock_snapshot, bt2.clock_snapshot._UnknownClockSnapshot
	161	)
9ec609ec	162	elif i == 1:
9ec609ec SM	163	self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
	164	self.assertEqual(msg.packet.addr, self._packet.addr)
	165	self.assertEqual(msg.default_clock_snapshot.value, i)
188edac1	166	elif i == 2:
9ec609ec	167	self.assertIsInstance(msg, bt2.message._EventMessage)
e8ac1aae	168	self.assertEqual(msg.event.cls.addr, self._event_class.addr)
9ec609ec	169	self.assertEqual(msg.default_clock_snapshot.value, i)
188edac1	170	elif i == 3:
cfbd7cf3 FD	171	self.assertIsInstance(
	172	msg, bt2.message._MessageIteratorInactivityMessage
	173	)
9ec609ec	174	self.assertEqual(msg.default_clock_snapshot.value, i)
188edac1	175	elif i == 4:
9ec609ec SM	176	self.assertIsInstance(msg, bt2.message._DiscardedEventsMessage)
	177	self.assertEqual(msg.stream.addr, self._stream.addr)
	178	self.assertEqual(msg.count, 890)
cfbd7cf3 FD	179	self.assertEqual(
	180	msg.stream.cls.default_clock_class.addr, self._clock_class.addr
	181	)
9ec609ec SM	182	self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
9ec609ec SM	183	self.assertEqual(msg.end_default_clock_snapshot.value, i)
188edac1	184	elif i == 5:
9ec609ec SM	185	self.assertIsInstance(msg, bt2.message._PacketEndMessage)
	186	self.assertEqual(msg.packet.addr, self._packet.addr)
	187	self.assertEqual(msg.default_clock_snapshot.value, i)
188edac1	188	elif i == 6:
9ec609ec SM	189	self.assertIsInstance(msg, bt2.message._DiscardedPacketsMessage)
	190	self.assertEqual(msg.stream.addr, self._stream.addr)
	191	self.assertEqual(msg.count, 678)
cfbd7cf3 FD	192	self.assertEqual(
	193	msg.stream.cls.default_clock_class.addr, self._clock_class.addr
	194	)
9ec609ec SM	195	self.assertEqual(msg.beginning_default_clock_snapshot.value, i)
9ec609ec SM	196	self.assertEqual(msg.end_default_clock_snapshot.value, i)
188edac1	197	elif i == 7:
9ec609ec SM	198	self.assertIsInstance(msg, bt2.message._StreamEndMessage)
9ec609ec SM	199	self.assertEqual(msg.stream.addr, self._stream.addr)
cfbd7cf3 FD	200	self.assertIsInstance(
	201	msg.default_clock_snapshot, bt2.clock_snapshot._UnknownClockSnapshot
	202	)
9ec609ec SM	203	else:
	204	raise Exception
	205
	206	def test_all_msg_without_cc(self):
	207	params = {'with_cc': False}
	208	self._src_comp = self._graph.add_component(self._src, 'my_source', params)
cfbd7cf3 FD	209	self._msg_iter = self._graph.create_output_port_message_iterator(
	210	self._src_comp.output_ports['out']
	211	)
9ec609ec SM	212
	213	for i, msg in enumerate(self._msg_iter):
	214	if i == 0:
	215	self.assertIsInstance(msg, bt2.message._StreamBeginningMessage)
	216	self.assertEqual(msg.stream.addr, self._stream.addr)
188edac1 SM	217	with self.assertRaises(bt2.NonexistentClockSnapshot):
188edac1 SM	218	msg.default_clock_snapshot
9ec609ec	219	elif i == 1:
9ec609ec SM	220	self.assertIsInstance(msg, bt2.message._PacketBeginningMessage)
9ec609ec SM	221	self.assertEqual(msg.packet.addr, self._packet.addr)
188edac1	222	elif i == 2:
9ec609ec	223	self.assertIsInstance(msg, bt2.message._EventMessage)
e8ac1aae	224	self.assertEqual(msg.event.cls.addr, self._event_class.addr)
2e90378a	225	with self.assertRaises(bt2.NonexistentClockSnapshot):
9ec609ec	226	msg.default_clock_snapshot
188edac1	227	elif i == 3:
9ec609ec SM	228	self.assertIsInstance(msg, bt2.message._DiscardedEventsMessage)
	229	self.assertEqual(msg.stream.addr, self._stream.addr)
	230	self.assertEqual(msg.count, 890)
e8ac1aae	231	self.assertIsNone(msg.stream.cls.default_clock_class)
2e90378a	232	with self.assertRaises(bt2.NonexistentClockSnapshot):
9ec609ec	233	msg.beginning_default_clock_snapshot
2e90378a	234	with self.assertRaises(bt2.NonexistentClockSnapshot):
9ec609ec	235	msg.end_default_clock_snapshot
188edac1	236	elif i == 4:
9ec609ec SM	237	self.assertIsInstance(msg, bt2.message._PacketEndMessage)
9ec609ec SM	238	self.assertEqual(msg.packet.addr, self._packet.addr)
188edac1	239	elif i == 5:
9ec609ec SM	240	self.assertIsInstance(msg, bt2.message._DiscardedPacketsMessage)
	241	self.assertEqual(msg.stream.addr, self._stream.addr)
	242	self.assertEqual(msg.count, 678)
e8ac1aae	243	self.assertIsNone(msg.stream.cls.default_clock_class)
2e90378a	244	with self.assertRaises(bt2.NonexistentClockSnapshot):
9ec609ec	245	msg.beginning_default_clock_snapshot
2e90378a	246	with self.assertRaises(bt2.NonexistentClockSnapshot):
9ec609ec	247	msg.end_default_clock_snapshot
188edac1	248	elif i == 6:
9ec609ec SM	249	self.assertIsInstance(msg, bt2.message._StreamEndMessage)
9ec609ec SM	250	self.assertEqual(msg.stream.addr, self._stream.addr)
188edac1 SM	251	with self.assertRaises(bt2.NonexistentClockSnapshot):
188edac1 SM	252	msg.default_clock_snapshot
9ec609ec SM	253	else:
9ec609ec SM	254	raise Exception
811644b8	255
188edac1	256	def test_msg_stream_with_clock_snapshots(self):
cfbd7cf3	257	params = {'with_cc': True, 'with_stream_msgs_clock_snapshots': True}
c6af194f	258
188edac1	259	self._src_comp = self._graph.add_component(self._src, 'my_source', params)
cfbd7cf3 FD	260	self._msg_iter = self._graph.create_output_port_message_iterator(
	261	self._src_comp.output_ports['out']
	262	)
188edac1	263	msgs = list(self._msg_iter)
c6af194f	264
188edac1 SM	265	msg_stream_beg = msgs[0]
	266	self.assertIsInstance(msg_stream_beg, bt2.message._StreamBeginningMessage)
	267	self.assertEqual(msg_stream_beg.default_clock_snapshot.value, 0)
c6af194f	268
188edac1 SM	269	msg_stream_end = msgs[7]
	270	self.assertIsInstance(msg_stream_end, bt2.message._StreamEndMessage)
	271	self.assertEqual(msg_stream_end.default_clock_snapshot.value, 7)