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

# SPDX-License-Identifier: GPL-2.0-only
#
# Copyright (C) 2019 EfficiOS Inc.
#

import unittest
import bt2
import utils
from utils import TestOutputPortMessageIterator
from bt2 import clock_snapshot as bt2_clock_snapshot
from bt2 import event as bt2_event
from bt2 import event_class as bt2_event_class
from bt2 import field as bt2_field
from bt2 import packet as bt2_packet
from bt2 import stream as bt2_stream
from bt2 import stream_class as bt2_stream_class
from bt2 import trace as bt2_trace
from bt2 import trace_class as bt2_trace_class


class AllMessagesTestCase(unittest.TestCase):
    def setUp(self):
        class MyIter(bt2._UserMessageIterator):
            def __init__(self, config, 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
                            )
                        test_obj.assertIs(type(msg), bt2._StreamBeginningMessage)
                    elif self._at == 1:
                        msg = self._create_packet_beginning_message(
                            test_obj._packet, self._at
                        )
                        test_obj.assertIs(type(msg), bt2._PacketBeginningMessage)
                    elif self._at == 2:
                        msg = self._create_event_message(
                            test_obj._event_class, test_obj._packet, self._at
                        )
                        test_obj.assertIs(type(msg), bt2._EventMessage)
                    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
                        )
                        test_obj.assertIs(type(msg), bt2._DiscardedEventsMessage)
                    elif self._at == 5:
                        msg = self._create_packet_end_message(
                            test_obj._packet, self._at
                        )
                        test_obj.assertIs(type(msg), bt2._PacketEndMessage)
                    elif self._at == 6:
                        msg = self._create_discarded_packets_message(
                            test_obj._stream, 678, self._at, self._at
                        )
                        test_obj.assertIs(type(msg), bt2._DiscardedPacketsMessage)
                    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)
                        test_obj.assertIs(type(msg), bt2._StreamEndMessage)
                    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, config, params, obj):
                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)]

                # Create specific context field class
                my_int_fc = tc.create_signed_integer_field_class(32)
                specific_fc = tc.create_structure_field_class()
                specific_fc += [('my_int', my_int_fc)]

                ec = sc.create_event_class(
                    name='salut',
                    payload_field_class=payload_fc,
                    specific_context_field_class=specific_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 = TestOutputPortMessageIterator(
            self._graph, self._src_comp.output_ports['out']
        )

        for i, msg in enumerate(self._msg_iter):
            if i == 0:
                self.assertIs(type(msg), bt2._StreamBeginningMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertIsInstance(
                    msg.default_clock_snapshot, bt2._UnknownClockSnapshot
                )
            elif i == 1:
                self.assertIs(type(msg), bt2._PacketBeginningMessageConst)
                self.assertIs(type(msg.packet), bt2_packet._PacketConst)
                self.assertIs(
                    type(msg.default_clock_snapshot),
                    bt2_clock_snapshot._ClockSnapshotConst,
                )
                self.assertEqual(msg.packet.addr, self._packet.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 2:
                self.assertIs(type(msg), bt2._EventMessageConst)
                self.assertIs(type(msg.event), bt2_event._EventConst)
                self.assertIs(
                    type(msg.default_clock_snapshot),
                    bt2_clock_snapshot._ClockSnapshotConst,
                )
                self.assertIs(
                    type(msg.event.payload_field), bt2_field._StructureFieldConst
                )
                self.assertIs(
                    type(msg.event.payload_field['my_int']),
                    bt2_field._SignedIntegerFieldConst,
                )

                self.assertEqual(msg.event.cls.addr, self._event_class.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 3:
                self.assertIs(type(msg), bt2._MessageIteratorInactivityMessageConst)
                self.assertIs(
                    type(msg.clock_snapshot), bt2_clock_snapshot._ClockSnapshotConst
                )
                self.assertEqual(msg.clock_snapshot.value, i)
            elif i == 4:
                self.assertIs(type(msg), bt2._DiscardedEventsMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertIs(type(msg.stream.cls), bt2_stream_class._StreamClassConst)
                self.assertIs(
                    type(msg.beginning_default_clock_snapshot),
                    bt2_clock_snapshot._ClockSnapshotConst,
                )
                self.assertIs(
                    type(msg.end_default_clock_snapshot),
                    bt2_clock_snapshot._ClockSnapshotConst,
                )

                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.assertIs(type(msg), bt2._PacketEndMessageConst)
                self.assertIs(type(msg.packet), bt2_packet._PacketConst)
                self.assertIs(
                    type(msg.default_clock_snapshot),
                    bt2_clock_snapshot._ClockSnapshotConst,
                )
                self.assertEqual(msg.packet.addr, self._packet.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 6:
                self.assertIs(type(msg), bt2._DiscardedPacketsMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertIs(type(msg.stream.trace), bt2_trace._TraceConst)
                self.assertIs(
                    type(msg.stream.trace.cls), bt2_trace_class._TraceClassConst
                )
                self.assertIs(
                    type(msg.beginning_default_clock_snapshot),
                    bt2_clock_snapshot._ClockSnapshotConst,
                )
                self.assertIs(
                    type(msg.end_default_clock_snapshot),
                    bt2_clock_snapshot._ClockSnapshotConst,
                )
                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.assertIs(type(msg), bt2._StreamEndMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertIs(
                    type(msg.default_clock_snapshot), bt2._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 = TestOutputPortMessageIterator(
            self._graph, self._src_comp.output_ports['out']
        )

        for i, msg in enumerate(self._msg_iter):
            if i == 0:
                self.assertIsInstance(msg, bt2._StreamBeginningMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                with self.assertRaisesRegex(
                    ValueError, 'stream class has no default clock class'
                ):
                    msg.default_clock_snapshot
            elif i == 1:
                self.assertIsInstance(msg, bt2._PacketBeginningMessageConst)
                self.assertIs(type(msg.packet), bt2_packet._PacketConst)
                self.assertEqual(msg.packet.addr, self._packet.addr)
            elif i == 2:
                self.assertIsInstance(msg, bt2._EventMessageConst)
                self.assertIs(type(msg.event), bt2_event._EventConst)
                self.assertIs(type(msg.event.cls), bt2_event_class._EventClassConst)
                self.assertEqual(msg.event.cls.addr, self._event_class.addr)
                with self.assertRaisesRegex(
                    ValueError, 'stream class has no default clock class'
                ):
                    msg.default_clock_snapshot
            elif i == 3:
                self.assertIsInstance(msg, bt2._DiscardedEventsMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertIs(type(msg.stream.cls), bt2_stream_class._StreamClassConst)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertEqual(msg.count, 890)
                self.assertIsNone(msg.stream.cls.default_clock_class)
                with self.assertRaisesRegex(
                    ValueError,
                    'such a message has no clock snapshots for this stream class',
                ):
                    msg.beginning_default_clock_snapshot
                with self.assertRaisesRegex(
                    ValueError,
                    'such a message has no clock snapshots for this stream class',
                ):
                    msg.end_default_clock_snapshot
            elif i == 4:
                self.assertIsInstance(msg, bt2._PacketEndMessageConst)
                self.assertEqual(msg.packet.addr, self._packet.addr)
                self.assertIs(type(msg.packet), bt2_packet._PacketConst)
            elif i == 5:
                self.assertIsInstance(msg, bt2._DiscardedPacketsMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertIs(type(msg.stream.cls), bt2_stream_class._StreamClassConst)
                self.assertIs(
                    type(msg.stream.cls.trace_class), bt2_trace_class._TraceClassConst
                )
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertEqual(msg.count, 678)
                self.assertIsNone(msg.stream.cls.default_clock_class)
                with self.assertRaisesRegex(
                    ValueError,
                    'such a message has no clock snapshots for this stream class',
                ):
                    msg.beginning_default_clock_snapshot
                with self.assertRaisesRegex(
                    ValueError,
                    'such a message has no clock snapshots for this stream class',
                ):
                    msg.end_default_clock_snapshot
            elif i == 6:
                self.assertIsInstance(msg, bt2._StreamEndMessageConst)
                self.assertIs(type(msg.stream), bt2_stream._StreamConst)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                with self.assertRaisesRegex(
                    ValueError, 'stream class has no default clock class'
                ):
                    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 = TestOutputPortMessageIterator(
            self._graph, self._src_comp.output_ports['out']
        )
        msgs = list(self._msg_iter)

        msg_stream_beg = msgs[0]
        self.assertIsInstance(msg_stream_beg, bt2._StreamBeginningMessageConst)
        self.assertIs(
            type(msg_stream_beg.default_clock_snapshot),
            bt2_clock_snapshot._ClockSnapshotConst,
        )
        self.assertEqual(msg_stream_beg.default_clock_snapshot.value, 0)

        msg_stream_end = msgs[7]
        self.assertIsInstance(msg_stream_end, bt2._StreamEndMessageConst)
        self.assertIs(
            type(msg_stream_end.default_clock_snapshot),
            bt2_clock_snapshot._ClockSnapshotConst,
        )
        self.assertEqual(msg_stream_end.default_clock_snapshot.value, 7)

    def test_stream_beg_msg(self):
        msg = utils.get_stream_beginning_message()
        self.assertIs(type(msg.stream), bt2_stream._Stream)

    def test_stream_end_msg(self):
        msg = utils.get_stream_end_message()
        self.assertIs(type(msg.stream), bt2_stream._Stream)

    def test_packet_beg_msg(self):
        msg = utils.get_packet_beginning_message()
        self.assertIs(type(msg.packet), bt2_packet._Packet)

    def test_packet_end_msg(self):
        msg = utils.get_packet_end_message()
        self.assertIs(type(msg.packet), bt2_packet._Packet)

    def test_event_msg(self):
        msg = utils.get_event_message()
        self.assertIs(type(msg.event), bt2_event._Event)


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