Commit | Line | Data |
---|---|---|
0235b0db | 1 | # SPDX-License-Identifier: GPL-2.0-only |
d2d857a8 MJ |
2 | # |
3 | # Copyright (C) 2019 EfficiOS Inc. | |
4 | # | |
d2d857a8 | 5 | |
9cf643d1 | 6 | import uuid |
5995b304 SM |
7 | import unittest |
8 | ||
9cf643d1 | 9 | import bt2 |
f0a42b33 | 10 | import utils |
eddea575 FD |
11 | from bt2 import value as bt2_value |
12 | from bt2 import clock_class as bt2_clock_class | |
5995b304 | 13 | from utils import TestOutputPortMessageIterator, run_in_component_init |
9cf643d1 PP |
14 | |
15 | ||
16 | class ClockClassOffsetTestCase(unittest.TestCase): | |
17 | def test_create_default(self): | |
18 | cco = bt2.ClockClassOffset() | |
19 | self.assertEqual(cco.seconds, 0) | |
20 | self.assertEqual(cco.cycles, 0) | |
21 | ||
22 | def test_create(self): | |
23 | cco = bt2.ClockClassOffset(23, 4871232) | |
24 | self.assertEqual(cco.seconds, 23) | |
25 | self.assertEqual(cco.cycles, 4871232) | |
26 | ||
27 | def test_create_kwargs(self): | |
28 | cco = bt2.ClockClassOffset(seconds=23, cycles=4871232) | |
29 | self.assertEqual(cco.seconds, 23) | |
30 | self.assertEqual(cco.cycles, 4871232) | |
31 | ||
32 | def test_create_invalid_seconds(self): | |
33 | with self.assertRaises(TypeError): | |
f5567ea8 | 34 | bt2.ClockClassOffset("hello", 4871232) |
9cf643d1 PP |
35 | |
36 | def test_create_invalid_cycles(self): | |
37 | with self.assertRaises(TypeError): | |
f5567ea8 | 38 | bt2.ClockClassOffset(23, "hello") |
9cf643d1 PP |
39 | |
40 | def test_eq(self): | |
41 | cco1 = bt2.ClockClassOffset(23, 42) | |
42 | cco2 = bt2.ClockClassOffset(23, 42) | |
43 | self.assertEqual(cco1, cco2) | |
44 | ||
45 | def test_ne_seconds(self): | |
46 | cco1 = bt2.ClockClassOffset(23, 42) | |
47 | cco2 = bt2.ClockClassOffset(24, 42) | |
48 | self.assertNotEqual(cco1, cco2) | |
49 | ||
50 | def test_ne_cycles(self): | |
51 | cco1 = bt2.ClockClassOffset(23, 42) | |
52 | cco2 = bt2.ClockClassOffset(23, 43) | |
53 | self.assertNotEqual(cco1, cco2) | |
54 | ||
55 | def test_eq_invalid(self): | |
56 | self.assertFalse(bt2.ClockClassOffset() == 23) | |
57 | ||
58 | ||
59 | class ClockClassTestCase(unittest.TestCase): | |
be7bbff9 SM |
60 | def assertRaisesInComponentInit(self, expected_exc_type, user_code): |
61 | def f(comp_self): | |
62 | try: | |
63 | user_code(comp_self) | |
64 | except Exception as exc: | |
65 | return type(exc) | |
811644b8 | 66 | |
be7bbff9 SM |
67 | exc_type = run_in_component_init(f) |
68 | self.assertIsNotNone(exc_type) | |
69 | self.assertEqual(exc_type, expected_exc_type) | |
9cf643d1 PP |
70 | |
71 | def test_create_default(self): | |
be7bbff9 | 72 | cc = run_in_component_init(lambda comp_self: comp_self._create_clock_class()) |
9cf643d1 | 73 | |
be7bbff9 SM |
74 | self.assertIsNone(cc.name) |
75 | self.assertEqual(cc.frequency, 1000000000) | |
76 | self.assertIsNone(cc.description) | |
77 | self.assertEqual(cc.precision, 0) | |
78 | self.assertEqual(cc.offset, bt2.ClockClassOffset()) | |
79 | self.assertTrue(cc.origin_is_unix_epoch) | |
80 | self.assertIsNone(cc.uuid) | |
5783664e | 81 | self.assertEqual(len(cc.user_attributes), 0) |
9cf643d1 | 82 | |
be7bbff9 SM |
83 | def test_create_name(self): |
84 | def f(comp_self): | |
f5567ea8 | 85 | return comp_self._create_clock_class(name="the_clock") |
9cf643d1 | 86 | |
be7bbff9 | 87 | cc = run_in_component_init(f) |
f5567ea8 | 88 | self.assertEqual(cc.name, "the_clock") |
9cf643d1 | 89 | |
be7bbff9 SM |
90 | def test_create_invalid_name(self): |
91 | def f(comp_self): | |
92 | comp_self._create_clock_class(name=23) | |
9cf643d1 | 93 | |
be7bbff9 | 94 | self.assertRaisesInComponentInit(TypeError, f) |
9cf643d1 | 95 | |
be7bbff9 SM |
96 | def test_create_description(self): |
97 | def f(comp_self): | |
f5567ea8 | 98 | return comp_self._create_clock_class(description="hi people") |
9cf643d1 | 99 | |
be7bbff9 | 100 | cc = run_in_component_init(f) |
f5567ea8 | 101 | self.assertEqual(cc.description, "hi people") |
9cf643d1 | 102 | |
be7bbff9 SM |
103 | def test_create_invalid_description(self): |
104 | def f(comp_self): | |
105 | return comp_self._create_clock_class(description=23) | |
9cf643d1 | 106 | |
be7bbff9 | 107 | self.assertRaisesInComponentInit(TypeError, f) |
9cf643d1 | 108 | |
be7bbff9 SM |
109 | def test_create_frequency(self): |
110 | def f(comp_self): | |
111 | return comp_self._create_clock_class(frequency=987654321) | |
9cf643d1 | 112 | |
be7bbff9 SM |
113 | cc = run_in_component_init(f) |
114 | self.assertEqual(cc.frequency, 987654321) | |
9cf643d1 | 115 | |
be7bbff9 SM |
116 | def test_create_invalid_frequency(self): |
117 | def f(comp_self): | |
f5567ea8 | 118 | return comp_self._create_clock_class(frequency="lel") |
9cf643d1 | 119 | |
be7bbff9 | 120 | self.assertRaisesInComponentInit(TypeError, f) |
9cf643d1 | 121 | |
be7bbff9 SM |
122 | def test_create_precision(self): |
123 | def f(comp_self): | |
124 | return comp_self._create_clock_class(precision=12) | |
9cf643d1 | 125 | |
be7bbff9 SM |
126 | cc = run_in_component_init(f) |
127 | self.assertEqual(cc.precision, 12) | |
9cf643d1 | 128 | |
be7bbff9 SM |
129 | def test_create_invalid_precision(self): |
130 | def f(comp_self): | |
f5567ea8 | 131 | return comp_self._create_clock_class(precision="lel") |
9cf643d1 | 132 | |
be7bbff9 | 133 | self.assertRaisesInComponentInit(TypeError, f) |
9cf643d1 | 134 | |
be7bbff9 SM |
135 | def test_create_offset(self): |
136 | def f(comp_self): | |
137 | return comp_self._create_clock_class(offset=bt2.ClockClassOffset(12, 56)) | |
9cf643d1 | 138 | |
be7bbff9 SM |
139 | cc = run_in_component_init(f) |
140 | self.assertEqual(cc.offset, bt2.ClockClassOffset(12, 56)) | |
141 | ||
142 | def test_create_invalid_offset(self): | |
143 | def f(comp_self): | |
144 | return comp_self._create_clock_class(offset=object()) | |
145 | ||
146 | self.assertRaisesInComponentInit(TypeError, f) | |
147 | ||
148 | def test_create_origin_is_unix_epoch(self): | |
149 | def f(comp_self): | |
150 | return comp_self._create_clock_class(origin_is_unix_epoch=False) | |
151 | ||
152 | cc = run_in_component_init(f) | |
153 | self.assertEqual(cc.origin_is_unix_epoch, False) | |
154 | ||
155 | def test_create_invalid_origin_is_unix_epoch(self): | |
156 | def f(comp_self): | |
157 | return comp_self._create_clock_class(origin_is_unix_epoch=23) | |
158 | ||
159 | self.assertRaisesInComponentInit(TypeError, f) | |
160 | ||
161 | def test_cycles_to_ns_from_origin(self): | |
162 | def f(comp_self): | |
cfbd7cf3 | 163 | return comp_self._create_clock_class( |
768f9bcb | 164 | frequency=10**8, origin_is_unix_epoch=True |
cfbd7cf3 | 165 | ) |
be7bbff9 SM |
166 | |
167 | cc = run_in_component_init(f) | |
168 | self.assertEqual(cc.cycles_to_ns_from_origin(112), 1120) | |
169 | ||
170 | def test_cycles_to_ns_from_origin_overflow(self): | |
171 | def f(comp_self): | |
172 | return comp_self._create_clock_class(frequency=1000) | |
173 | ||
174 | cc = run_in_component_init(f) | |
cb06aa27 | 175 | with self.assertRaises(bt2._OverflowError): |
768f9bcb | 176 | cc.cycles_to_ns_from_origin(2**63) |
be7bbff9 SM |
177 | |
178 | def test_create_uuid(self): | |
179 | def f(comp_self): | |
cfbd7cf3 | 180 | return comp_self._create_clock_class( |
f5567ea8 | 181 | uuid=uuid.UUID("b43372c32ef0be28444dfc1c5cdafd33") |
cfbd7cf3 | 182 | ) |
be7bbff9 SM |
183 | |
184 | cc = run_in_component_init(f) | |
f5567ea8 | 185 | self.assertEqual(cc.uuid, uuid.UUID("b43372c32ef0be28444dfc1c5cdafd33")) |
be7bbff9 SM |
186 | |
187 | def test_create_invalid_uuid(self): | |
188 | def f(comp_self): | |
189 | return comp_self._create_clock_class(uuid=23) | |
190 | ||
191 | self.assertRaisesInComponentInit(TypeError, f) | |
9cf643d1 | 192 | |
5783664e PP |
193 | def test_create_user_attributes(self): |
194 | def f(comp_self): | |
f5567ea8 | 195 | return comp_self._create_clock_class(user_attributes={"salut": 23}) |
5783664e PP |
196 | |
197 | cc = run_in_component_init(f) | |
f5567ea8 | 198 | self.assertEqual(cc.user_attributes, {"salut": 23}) |
eddea575 | 199 | self.assertIs(type(cc.user_attributes), bt2_value.MapValue) |
5783664e PP |
200 | |
201 | def test_create_invalid_user_attributes(self): | |
202 | def f(comp_self): | |
203 | return comp_self._create_clock_class(user_attributes=object()) | |
204 | ||
205 | self.assertRaisesInComponentInit(TypeError, f) | |
206 | ||
207 | def test_create_invalid_user_attributes_value_type(self): | |
208 | def f(comp_self): | |
209 | return comp_self._create_clock_class(user_attributes=23) | |
210 | ||
211 | self.assertRaisesInComponentInit(TypeError, f) | |
212 | ||
f0a42b33 FD |
213 | def test_const_user_attributes(self): |
214 | cc = utils.get_const_event_message().default_clock_snapshot.clock_class | |
215 | self.assertIs(type(cc.user_attributes), bt2_value._MapValueConst) | |
216 | ||
9cf643d1 | 217 | |
4b552f8b | 218 | class ClockSnapshotTestCase(unittest.TestCase): |
9cf643d1 | 219 | def setUp(self): |
be7bbff9 | 220 | def f(comp_self): |
cfbd7cf3 | 221 | cc = comp_self._create_clock_class( |
f5567ea8 | 222 | 1000, "my_cc", offset=bt2.ClockClassOffset(45, 354) |
cfbd7cf3 | 223 | ) |
be7bbff9 SM |
224 | tc = comp_self._create_trace_class() |
225 | ||
226 | return (cc, tc) | |
227 | ||
228 | _cc, _tc = run_in_component_init(f) | |
229 | _trace = _tc() | |
26fc5aed | 230 | _sc = _tc.create_stream_class(default_clock_class=_cc) |
f5567ea8 | 231 | _ec = _sc.create_event_class(name="salut") |
be7bbff9 | 232 | _stream = _trace.create_stream(_sc) |
be7bbff9 SM |
233 | self._stream = _stream |
234 | self._ec = _ec | |
235 | self._cc = _cc | |
236 | ||
237 | class MyIter(bt2._UserMessageIterator): | |
8d8b141d | 238 | def __init__(self, config, self_port_output): |
be7bbff9 SM |
239 | self._at = 0 |
240 | ||
241 | def __next__(self): | |
242 | if self._at == 0: | |
243 | notif = self._create_stream_beginning_message(_stream) | |
244 | elif self._at == 1: | |
26fc5aed | 245 | notif = self._create_event_message(_ec, _stream, 123) |
be7bbff9 | 246 | elif self._at == 2: |
768f9bcb | 247 | notif = self._create_event_message(_ec, _stream, 2**63) |
be7bbff9 | 248 | elif self._at == 3: |
be7bbff9 SM |
249 | notif = self._create_stream_end_message(_stream) |
250 | else: | |
251 | raise bt2.Stop | |
252 | ||
253 | self._at += 1 | |
254 | return notif | |
255 | ||
256 | class MySrc(bt2._UserSourceComponent, message_iterator_class=MyIter): | |
59225a3e | 257 | def __init__(self, config, params, obj): |
f5567ea8 | 258 | self._add_output_port("out") |
be7bbff9 SM |
259 | |
260 | self._graph = bt2.Graph() | |
f5567ea8 | 261 | self._src_comp = self._graph.add_component(MySrc, "my_source") |
6c373cc9 | 262 | self._msg_iter = TestOutputPortMessageIterator( |
f5567ea8 | 263 | self._graph, self._src_comp.output_ports["out"] |
cfbd7cf3 | 264 | ) |
be7bbff9 SM |
265 | |
266 | for i, msg in enumerate(self._msg_iter): | |
26fc5aed | 267 | if i == 1: |
be7bbff9 | 268 | self._msg = msg |
26fc5aed | 269 | elif i == 2: |
be7bbff9 SM |
270 | self._msg_clock_overflow = msg |
271 | break | |
811644b8 PP |
272 | |
273 | def tearDown(self): | |
274 | del self._cc | |
be7bbff9 | 275 | del self._msg |
9cf643d1 PP |
276 | |
277 | def test_create_default(self): | |
be7bbff9 | 278 | self.assertEqual( |
cfbd7cf3 FD |
279 | self._msg.default_clock_snapshot.clock_class.addr, self._cc.addr |
280 | ) | |
be7bbff9 | 281 | self.assertEqual(self._msg.default_clock_snapshot.value, 123) |
9cf643d1 | 282 | |
be7bbff9 | 283 | def test_clock_class(self): |
eddea575 FD |
284 | cc = self._msg.default_clock_snapshot.clock_class |
285 | self.assertEqual(cc.addr, self._cc.addr) | |
286 | self.assertIs(type(cc), bt2_clock_class._ClockClassConst) | |
9cf643d1 | 287 | |
be7bbff9 SM |
288 | def test_ns_from_origin(self): |
289 | s_from_origin = 45 + ((354 + 123) / 1000) | |
290 | ns_from_origin = int(s_from_origin * 1e9) | |
291 | self.assertEqual( | |
cfbd7cf3 FD |
292 | self._msg.default_clock_snapshot.ns_from_origin, ns_from_origin |
293 | ) | |
9cf643d1 | 294 | |
be7bbff9 | 295 | def test_ns_from_origin_overflow(self): |
cb06aa27 | 296 | with self.assertRaises(bt2._OverflowError): |
be7bbff9 | 297 | self._msg_clock_overflow.default_clock_snapshot.ns_from_origin |
9cf643d1 | 298 | |
811644b8 | 299 | def test_eq_int(self): |
be7bbff9 | 300 | self.assertEqual(self._msg.default_clock_snapshot, 123) |
9cf643d1 PP |
301 | |
302 | def test_eq_invalid(self): | |
be7bbff9 SM |
303 | self.assertFalse(self._msg.default_clock_snapshot == 23) |
304 | ||
305 | def test_comparison(self): | |
306 | self.assertTrue(self._msg.default_clock_snapshot > 100) | |
307 | self.assertFalse(self._msg.default_clock_snapshot > 200) | |
9cf643d1 | 308 | |
be7bbff9 SM |
309 | self.assertTrue(self._msg.default_clock_snapshot >= 123) |
310 | self.assertFalse(self._msg.default_clock_snapshot >= 200) | |
9cf643d1 | 311 | |
be7bbff9 SM |
312 | self.assertTrue(self._msg.default_clock_snapshot < 200) |
313 | self.assertFalse(self._msg.default_clock_snapshot < 100) | |
9cf643d1 | 314 | |
be7bbff9 SM |
315 | self.assertTrue(self._msg.default_clock_snapshot <= 123) |
316 | self.assertFalse(self._msg.default_clock_snapshot <= 100) | |
d14ddbba SM |
317 | |
318 | ||
f5567ea8 | 319 | if __name__ == "__main__": |
d14ddbba | 320 | unittest.main() |