[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
from utils import TestOutputPortMessageIterator


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, 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)]

                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 = TestOutputPortMessageIterator(
            self._graph, self._src_comp.output_ports['out']
        )

        for i, msg in enumerate(self._msg_iter):
            if i == 0:
                self.assertIsInstance(msg, bt2._StreamBeginningMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertIsInstance(
                    msg.default_clock_snapshot, bt2._UnknownClockSnapshot
                )
            elif i == 1:
                self.assertIsInstance(msg, bt2._PacketBeginningMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 2:
                self.assertIsInstance(msg, bt2._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._MessageIteratorInactivityMessage)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 4:
                self.assertIsInstance(msg, bt2._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._PacketEndMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
                self.assertEqual(msg.default_clock_snapshot.value, i)
            elif i == 6:
                self.assertIsInstance(msg, bt2._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._StreamEndMessage)
                self.assertEqual(msg.stream.addr, self._stream.addr)
                self.assertIsInstance(
                    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._StreamBeginningMessage)
                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._PacketBeginningMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
            elif i == 2:
                self.assertIsInstance(msg, bt2._EventMessage)
                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._DiscardedEventsMessage)
                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._PacketEndMessage)
                self.assertEqual(msg.packet.addr, self._packet.addr)
            elif i == 5:
                self.assertIsInstance(msg, bt2._DiscardedPacketsMessage)
                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._StreamEndMessage)
                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._StreamBeginningMessage)
        self.assertEqual(msg_stream_beg.default_clock_snapshot.value, 0)

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