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