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 | ||
cc261e29 PP |
19 | import unittest |
20 | import datetime | |
cc261e29 PP |
21 | import bt2 |
22 | import os | |
23 | import os.path | |
24 | ||
25 | ||
94e72386 | 26 | _BT_TESTS_DATADIR = os.environ['BT_TESTS_DATADIR'] |
b7c5d194 | 27 | _BT_CTF_TRACES_PATH = os.environ['BT_CTF_TRACES_PATH'] |
61d96b89 FD |
28 | _3EVENTS_INTERSECT_TRACE_PATH = os.path.join( |
29 | _BT_CTF_TRACES_PATH, 'intersection', '3eventsintersect' | |
30 | ) | |
94e72386 SM |
31 | _NOINTERSECT_TRACE_PATH = os.path.join( |
32 | _BT_CTF_TRACES_PATH, 'intersection', 'nointersect' | |
33 | ) | |
34 | _SEQUENCE_TRACE_PATH = os.path.join(_BT_CTF_TRACES_PATH, 'succeed', 'sequence') | |
35 | _AUTO_SOURCE_DISCOVERY_GROUPING_PATH = os.path.join( | |
36 | _BT_TESTS_DATADIR, 'auto-source-discovery', 'grouping' | |
37 | ) | |
38 | _AUTO_SOURCE_DISCOVERY_PARAMS_LOG_LEVEL_PATH = os.path.join( | |
39 | _BT_TESTS_DATADIR, 'auto-source-discovery', 'params-log-level' | |
40 | ) | |
cc261e29 PP |
41 | |
42 | ||
88fdcc33 | 43 | class ComponentSpecTestCase(unittest.TestCase): |
cc261e29 | 44 | def test_create_good_no_params(self): |
da35796c | 45 | bt2.ComponentSpec('plugin', 'compcls') |
cc261e29 PP |
46 | |
47 | def test_create_good_with_params(self): | |
da35796c | 48 | bt2.ComponentSpec('plugin', 'compcls', {'salut': 23}) |
cc261e29 PP |
49 | |
50 | def test_create_good_with_path_params(self): | |
88fdcc33 | 51 | spec = bt2.ComponentSpec('plugin', 'compcls', 'a path') |
a1040187 | 52 | self.assertEqual(spec.params['inputs'], ['a path']) |
cc261e29 PP |
53 | |
54 | def test_create_wrong_plugin_name_type(self): | |
55 | with self.assertRaises(TypeError): | |
da35796c | 56 | bt2.ComponentSpec(23, 'compcls') |
cc261e29 PP |
57 | |
58 | def test_create_wrong_component_class_name_type(self): | |
59 | with self.assertRaises(TypeError): | |
da35796c | 60 | bt2.ComponentSpec('plugin', 190) |
cc261e29 PP |
61 | |
62 | def test_create_wrong_params_type(self): | |
63 | with self.assertRaises(TypeError): | |
da35796c SM |
64 | bt2.ComponentSpec('dwdw', 'compcls', datetime.datetime.now()) |
65 | ||
66 | ||
67 | # Return a map, msg type -> number of messages of this type. | |
68 | ||
61d96b89 | 69 | |
da35796c SM |
70 | def _count_msgs_by_type(msgs): |
71 | res = {} | |
72 | ||
73 | for msg in msgs: | |
74 | t = type(msg) | |
75 | n = res.get(t, 0) | |
76 | res[t] = n + 1 | |
77 | ||
78 | return res | |
cc261e29 PP |
79 | |
80 | ||
fa4c33e3 | 81 | class TraceCollectionMessageIteratorTestCase(unittest.TestCase): |
cc261e29 | 82 | def test_create_wrong_stream_intersection_mode_type(self): |
88fdcc33 | 83 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
cc261e29 PP |
84 | |
85 | with self.assertRaises(TypeError): | |
da35796c | 86 | bt2.TraceCollectionMessageIterator(specs, stream_intersection_mode=23) |
cc261e29 PP |
87 | |
88 | def test_create_wrong_begin_type(self): | |
88fdcc33 | 89 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
cc261e29 PP |
90 | |
91 | with self.assertRaises(TypeError): | |
da35796c | 92 | bt2.TraceCollectionMessageIterator(specs, begin='hi') |
cc261e29 PP |
93 | |
94 | def test_create_wrong_end_type(self): | |
88fdcc33 | 95 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
cc261e29 PP |
96 | |
97 | with self.assertRaises(TypeError): | |
da35796c | 98 | bt2.TraceCollectionMessageIterator(specs, begin='lel') |
cc261e29 PP |
99 | |
100 | def test_create_no_such_plugin(self): | |
88fdcc33 | 101 | specs = [bt2.ComponentSpec('77', '101', _3EVENTS_INTERSECT_TRACE_PATH)] |
cc261e29 | 102 | |
3b2be708 | 103 | with self.assertRaises(ValueError): |
da35796c | 104 | bt2.TraceCollectionMessageIterator(specs) |
cc261e29 PP |
105 | |
106 | def test_create_begin_s(self): | |
88fdcc33 | 107 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
da35796c | 108 | bt2.TraceCollectionMessageIterator(specs, begin=19457.918232) |
cc261e29 PP |
109 | |
110 | def test_create_end_s(self): | |
88fdcc33 | 111 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
da35796c | 112 | bt2.TraceCollectionMessageIterator(specs, end=123.12312) |
cc261e29 PP |
113 | |
114 | def test_create_begin_datetime(self): | |
88fdcc33 | 115 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
da35796c | 116 | bt2.TraceCollectionMessageIterator(specs, begin=datetime.datetime.now()) |
cc261e29 PP |
117 | |
118 | def test_create_end_datetime(self): | |
88fdcc33 | 119 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
da35796c | 120 | bt2.TraceCollectionMessageIterator(specs, end=datetime.datetime.now()) |
cc261e29 PP |
121 | |
122 | def test_iter_no_intersection(self): | |
88fdcc33 | 123 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
fa4c33e3 | 124 | msg_iter = bt2.TraceCollectionMessageIterator(specs) |
da35796c | 125 | msgs = list(msg_iter) |
b7cbc799 | 126 | self.assertEqual(len(msgs), 28) |
da35796c | 127 | hist = _count_msgs_by_type(msgs) |
c946c9de | 128 | self.assertEqual(hist[bt2._EventMessage], 8) |
cc261e29 | 129 | |
da35796c | 130 | # Same as the above, but we pass a single spec instead of a spec list. |
88fdcc33 PP |
131 | def test_iter_specs_not_list(self): |
132 | spec = bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH) | |
da35796c SM |
133 | msg_iter = bt2.TraceCollectionMessageIterator(spec) |
134 | msgs = list(msg_iter) | |
b7cbc799 | 135 | self.assertEqual(len(msgs), 28) |
da35796c | 136 | hist = _count_msgs_by_type(msgs) |
c946c9de | 137 | self.assertEqual(hist[bt2._EventMessage], 8) |
88fdcc33 PP |
138 | |
139 | def test_iter_custom_filter(self): | |
140 | src_spec = bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH) | |
61d96b89 | 141 | flt_spec = bt2.ComponentSpec('utils', 'trimmer', {'end': '13515309.000000075'}) |
da35796c SM |
142 | msg_iter = bt2.TraceCollectionMessageIterator(src_spec, flt_spec) |
143 | hist = _count_msgs_by_type(msg_iter) | |
c946c9de | 144 | self.assertEqual(hist[bt2._EventMessage], 5) |
88fdcc33 | 145 | |
cc261e29 | 146 | def test_iter_intersection(self): |
88fdcc33 | 147 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
61d96b89 FD |
148 | msg_iter = bt2.TraceCollectionMessageIterator( |
149 | specs, stream_intersection_mode=True | |
150 | ) | |
da35796c | 151 | msgs = list(msg_iter) |
b7cbc799 | 152 | self.assertEqual(len(msgs), 15) |
da35796c | 153 | hist = _count_msgs_by_type(msgs) |
c946c9de | 154 | self.assertEqual(hist[bt2._EventMessage], 3) |
cc261e29 | 155 | |
a1040187 | 156 | def test_iter_intersection_no_inputs_param(self): |
88fdcc33 | 157 | specs = [bt2.ComponentSpec('text', 'dmesg', {'read-from-stdin': True})] |
cc261e29 | 158 | |
3b2be708 | 159 | with self.assertRaises(ValueError): |
da35796c | 160 | bt2.TraceCollectionMessageIterator(specs, stream_intersection_mode=True) |
cc261e29 PP |
161 | |
162 | def test_iter_no_intersection_two_traces(self): | |
88fdcc33 | 163 | spec = bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH) |
cc261e29 | 164 | specs = [spec, spec] |
fa4c33e3 | 165 | msg_iter = bt2.TraceCollectionMessageIterator(specs) |
da35796c | 166 | msgs = list(msg_iter) |
b7cbc799 | 167 | self.assertEqual(len(msgs), 56) |
da35796c | 168 | hist = _count_msgs_by_type(msgs) |
c946c9de | 169 | self.assertEqual(hist[bt2._EventMessage], 16) |
cc261e29 PP |
170 | |
171 | def test_iter_no_intersection_begin(self): | |
88fdcc33 | 172 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
da35796c SM |
173 | msg_iter = bt2.TraceCollectionMessageIterator(specs, begin=13515309.000000023) |
174 | hist = _count_msgs_by_type(msg_iter) | |
c946c9de | 175 | self.assertEqual(hist[bt2._EventMessage], 6) |
cc261e29 PP |
176 | |
177 | def test_iter_no_intersection_end(self): | |
88fdcc33 | 178 | specs = [bt2.ComponentSpec('ctf', 'fs', _3EVENTS_INTERSECT_TRACE_PATH)] |
da35796c SM |
179 | msg_iter = bt2.TraceCollectionMessageIterator(specs, end=13515309.000000075) |
180 | hist = _count_msgs_by_type(msg_iter) | |
c946c9de | 181 | self.assertEqual(hist[bt2._EventMessage], 5) |
94e72386 SM |
182 | |
183 | def test_iter_auto_source_component_spec(self): | |
184 | specs = [bt2.AutoSourceComponentSpec(_3EVENTS_INTERSECT_TRACE_PATH)] | |
185 | msg_iter = bt2.TraceCollectionMessageIterator(specs) | |
186 | msgs = list(msg_iter) | |
187 | self.assertEqual(len(msgs), 28) | |
188 | hist = _count_msgs_by_type(msgs) | |
189 | self.assertEqual(hist[bt2._EventMessage], 8) | |
190 | ||
191 | def test_iter_auto_source_component_spec_list_of_strings(self): | |
192 | msg_iter = bt2.TraceCollectionMessageIterator([_3EVENTS_INTERSECT_TRACE_PATH]) | |
193 | msgs = list(msg_iter) | |
194 | self.assertEqual(len(msgs), 28) | |
195 | hist = _count_msgs_by_type(msgs) | |
196 | self.assertEqual(hist[bt2._EventMessage], 8) | |
197 | ||
198 | def test_iter_auto_source_component_spec_string(self): | |
199 | msg_iter = bt2.TraceCollectionMessageIterator(_3EVENTS_INTERSECT_TRACE_PATH) | |
200 | msgs = list(msg_iter) | |
201 | self.assertEqual(len(msgs), 28) | |
202 | hist = _count_msgs_by_type(msgs) | |
203 | self.assertEqual(hist[bt2._EventMessage], 8) | |
204 | ||
205 | def test_iter_mixed_inputs(self): | |
206 | msg_iter = bt2.TraceCollectionMessageIterator( | |
207 | [ | |
208 | _3EVENTS_INTERSECT_TRACE_PATH, | |
209 | bt2.AutoSourceComponentSpec(_SEQUENCE_TRACE_PATH), | |
210 | bt2.ComponentSpec('ctf', 'fs', _NOINTERSECT_TRACE_PATH), | |
211 | ] | |
212 | ) | |
213 | msgs = list(msg_iter) | |
214 | self.assertEqual(len(msgs), 76) | |
215 | hist = _count_msgs_by_type(msgs) | |
216 | self.assertEqual(hist[bt2._EventMessage], 24) | |
217 | ||
218 | ||
219 | class _TestAutoDiscoverSourceComponentSpecs(unittest.TestCase): | |
220 | def setUp(self): | |
221 | self._saved_babeltrace_plugin_path = os.environ['BABELTRACE_PLUGIN_PATH'] | |
d479cff8 | 222 | os.environ['BABELTRACE_PLUGIN_PATH'] += os.pathsep + self._plugin_path |
94e72386 SM |
223 | |
224 | def tearDown(self): | |
225 | os.environ['BABELTRACE_PLUGIN_PATH'] = self._saved_babeltrace_plugin_path | |
226 | ||
227 | ||
228 | class TestAutoDiscoverSourceComponentSpecsGrouping( | |
229 | _TestAutoDiscoverSourceComponentSpecs | |
230 | ): | |
231 | _plugin_path = _AUTO_SOURCE_DISCOVERY_GROUPING_PATH | |
232 | ||
233 | def test_grouping(self): | |
234 | specs = [ | |
235 | bt2.AutoSourceComponentSpec('ABCDE'), | |
236 | bt2.AutoSourceComponentSpec(_AUTO_SOURCE_DISCOVERY_GROUPING_PATH), | |
237 | bt2.AutoSourceComponentSpec('does-not-exist'), | |
238 | ] | |
239 | it = bt2.TraceCollectionMessageIterator(specs) | |
240 | msgs = [x for x in it if type(x) is bt2._StreamBeginningMessage] | |
241 | ||
242 | self.assertEqual(len(msgs), 8) | |
243 | ||
244 | self.assertEqual(msgs[0].stream.name, 'TestSourceABCDE: ABCDE') | |
245 | self.assertEqual(msgs[1].stream.name, 'TestSourceExt: aaa1, aaa2, aaa3') | |
246 | self.assertEqual(msgs[2].stream.name, 'TestSourceExt: bbb1, bbb2') | |
247 | self.assertEqual(msgs[3].stream.name, 'TestSourceExt: ccc1') | |
248 | self.assertEqual(msgs[4].stream.name, 'TestSourceExt: ccc2') | |
249 | self.assertEqual(msgs[5].stream.name, 'TestSourceExt: ccc3') | |
250 | self.assertEqual(msgs[6].stream.name, 'TestSourceExt: ccc4') | |
251 | self.assertEqual(msgs[7].stream.name, 'TestSourceSomeDir: some-dir') | |
252 | ||
253 | ||
254 | class TestAutoDiscoverSourceComponentSpecsParamsObjLogLevel( | |
255 | _TestAutoDiscoverSourceComponentSpecs | |
256 | ): | |
257 | _plugin_path = _AUTO_SOURCE_DISCOVERY_PARAMS_LOG_LEVEL_PATH | |
258 | ||
259 | _dir_a = os.path.join(_AUTO_SOURCE_DISCOVERY_PARAMS_LOG_LEVEL_PATH, 'dir-a') | |
260 | _dir_b = os.path.join(_AUTO_SOURCE_DISCOVERY_PARAMS_LOG_LEVEL_PATH, 'dir-b') | |
261 | _dir_ab = os.path.join(_AUTO_SOURCE_DISCOVERY_PARAMS_LOG_LEVEL_PATH, 'dir-ab') | |
262 | ||
263 | def _test_two_comps_from_one_spec(self, params, obj=None, logging_level=None): | |
264 | specs = [ | |
265 | bt2.AutoSourceComponentSpec( | |
266 | self._dir_ab, params=params, obj=obj, logging_level=logging_level | |
267 | ) | |
268 | ] | |
269 | it = bt2.TraceCollectionMessageIterator(specs) | |
270 | msgs = [x for x in it if type(x) is bt2._StreamBeginningMessage] | |
271 | ||
272 | self.assertEqual(len(msgs), 2) | |
273 | ||
274 | return msgs | |
275 | ||
276 | def test_params_two_comps_from_one_spec(self): | |
277 | msgs = self._test_two_comps_from_one_spec( | |
278 | params={'test-allo': 'madame', 'what': 'test-params'} | |
279 | ) | |
280 | ||
281 | self.assertEqual(msgs[0].stream.name, "TestSourceA: ('test-allo', 'madame')") | |
282 | self.assertEqual(msgs[1].stream.name, "TestSourceB: ('test-allo', 'madame')") | |
283 | ||
284 | def test_obj_two_comps_from_one_spec(self): | |
285 | msgs = self._test_two_comps_from_one_spec( | |
286 | params={'what': 'python-obj'}, obj='deore' | |
287 | ) | |
288 | ||
289 | self.assertEqual(msgs[0].stream.name, "TestSourceA: deore") | |
290 | self.assertEqual(msgs[1].stream.name, "TestSourceB: deore") | |
291 | ||
292 | def test_log_level_two_comps_from_one_spec(self): | |
293 | msgs = self._test_two_comps_from_one_spec( | |
294 | params={'what': 'log-level'}, logging_level=bt2.LoggingLevel.DEBUG | |
295 | ) | |
296 | ||
297 | self.assertEqual( | |
298 | msgs[0].stream.name, "TestSourceA: {}".format(bt2.LoggingLevel.DEBUG) | |
299 | ) | |
300 | self.assertEqual( | |
301 | msgs[1].stream.name, "TestSourceB: {}".format(bt2.LoggingLevel.DEBUG) | |
302 | ) | |
303 | ||
304 | def _test_two_comps_from_two_specs( | |
305 | self, | |
306 | params_a=None, | |
307 | params_b=None, | |
308 | obj_a=None, | |
309 | obj_b=None, | |
310 | logging_level_a=None, | |
311 | logging_level_b=None, | |
312 | ): | |
313 | specs = [ | |
314 | bt2.AutoSourceComponentSpec( | |
315 | self._dir_a, params=params_a, obj=obj_a, logging_level=logging_level_a | |
316 | ), | |
317 | bt2.AutoSourceComponentSpec( | |
318 | self._dir_b, params=params_b, obj=obj_b, logging_level=logging_level_b | |
319 | ), | |
320 | ] | |
321 | it = bt2.TraceCollectionMessageIterator(specs) | |
322 | msgs = [x for x in it if type(x) is bt2._StreamBeginningMessage] | |
323 | ||
324 | self.assertEqual(len(msgs), 2) | |
325 | ||
326 | return msgs | |
327 | ||
328 | def test_params_two_comps_from_two_specs(self): | |
329 | msgs = self._test_two_comps_from_two_specs( | |
330 | params_a={'test-allo': 'madame', 'what': 'test-params'}, | |
331 | params_b={'test-bonjour': 'monsieur', 'what': 'test-params'}, | |
332 | ) | |
333 | ||
334 | self.assertEqual(msgs[0].stream.name, "TestSourceA: ('test-allo', 'madame')") | |
335 | self.assertEqual( | |
336 | msgs[1].stream.name, "TestSourceB: ('test-bonjour', 'monsieur')" | |
337 | ) | |
338 | ||
339 | def test_obj_two_comps_from_two_specs(self): | |
340 | msgs = self._test_two_comps_from_two_specs( | |
341 | params_a={'what': 'python-obj'}, | |
342 | params_b={'what': 'python-obj'}, | |
343 | obj_a='deore', | |
344 | obj_b='alivio', | |
345 | ) | |
346 | ||
347 | self.assertEqual(msgs[0].stream.name, "TestSourceA: deore") | |
348 | self.assertEqual(msgs[1].stream.name, "TestSourceB: alivio") | |
349 | ||
350 | def test_log_level_two_comps_from_two_specs(self): | |
351 | msgs = self._test_two_comps_from_two_specs( | |
352 | params_a={'what': 'log-level'}, | |
353 | params_b={'what': 'log-level'}, | |
354 | logging_level_a=bt2.LoggingLevel.DEBUG, | |
355 | logging_level_b=bt2.LoggingLevel.TRACE, | |
356 | ) | |
357 | ||
358 | self.assertEqual( | |
359 | msgs[0].stream.name, "TestSourceA: {}".format(bt2.LoggingLevel.DEBUG) | |
360 | ) | |
361 | self.assertEqual( | |
362 | msgs[1].stream.name, "TestSourceB: {}".format(bt2.LoggingLevel.TRACE) | |
363 | ) | |
364 | ||
365 | def _test_one_comp_from_one_spec_one_comp_from_both_1( | |
366 | self, | |
367 | params_a=None, | |
368 | params_ab=None, | |
369 | obj_a=None, | |
370 | obj_ab=None, | |
371 | logging_level_a=None, | |
372 | logging_level_ab=None, | |
373 | ): | |
374 | specs = [ | |
375 | bt2.AutoSourceComponentSpec( | |
376 | self._dir_a, params=params_a, obj=obj_a, logging_level=logging_level_a | |
377 | ), | |
378 | bt2.AutoSourceComponentSpec( | |
379 | self._dir_ab, | |
380 | params=params_ab, | |
381 | obj=obj_ab, | |
382 | logging_level=logging_level_ab, | |
383 | ), | |
384 | ] | |
385 | it = bt2.TraceCollectionMessageIterator(specs) | |
386 | msgs = [x for x in it if type(x) is bt2._StreamBeginningMessage] | |
387 | ||
388 | self.assertEqual(len(msgs), 2) | |
389 | ||
390 | return msgs | |
391 | ||
392 | def test_params_one_comp_from_one_spec_one_comp_from_both_1(self): | |
393 | msgs = self._test_one_comp_from_one_spec_one_comp_from_both_1( | |
394 | params_a={'test-allo': 'madame', 'what': 'test-params'}, | |
395 | params_ab={'test-bonjour': 'monsieur', 'what': 'test-params'}, | |
396 | ) | |
397 | ||
398 | self.assertEqual( | |
399 | msgs[0].stream.name, | |
400 | "TestSourceA: ('test-allo', 'madame'), ('test-bonjour', 'monsieur')", | |
401 | ) | |
402 | self.assertEqual( | |
403 | msgs[1].stream.name, "TestSourceB: ('test-bonjour', 'monsieur')" | |
404 | ) | |
405 | ||
406 | def test_obj_one_comp_from_one_spec_one_comp_from_both_1(self): | |
407 | msgs = self._test_one_comp_from_one_spec_one_comp_from_both_1( | |
408 | params_a={'what': 'python-obj'}, | |
409 | params_ab={'what': 'python-obj'}, | |
410 | obj_a='deore', | |
411 | obj_ab='alivio', | |
412 | ) | |
413 | ||
414 | self.assertEqual(msgs[0].stream.name, "TestSourceA: alivio") | |
415 | self.assertEqual(msgs[1].stream.name, "TestSourceB: alivio") | |
416 | ||
417 | def test_log_level_one_comp_from_one_spec_one_comp_from_both_1(self): | |
418 | msgs = self._test_one_comp_from_one_spec_one_comp_from_both_1( | |
419 | params_a={'what': 'log-level'}, | |
420 | params_ab={'what': 'log-level'}, | |
421 | logging_level_a=bt2.LoggingLevel.DEBUG, | |
422 | logging_level_ab=bt2.LoggingLevel.TRACE, | |
423 | ) | |
424 | ||
425 | self.assertEqual( | |
426 | msgs[0].stream.name, "TestSourceA: {}".format(bt2.LoggingLevel.TRACE) | |
427 | ) | |
428 | self.assertEqual( | |
429 | msgs[1].stream.name, "TestSourceB: {}".format(bt2.LoggingLevel.TRACE) | |
430 | ) | |
431 | ||
432 | def _test_one_comp_from_one_spec_one_comp_from_both_2( | |
433 | self, | |
434 | params_ab=None, | |
435 | params_a=None, | |
436 | obj_ab=None, | |
437 | obj_a=None, | |
438 | logging_level_ab=None, | |
439 | logging_level_a=None, | |
440 | ): | |
441 | specs = [ | |
442 | bt2.AutoSourceComponentSpec( | |
443 | self._dir_ab, | |
444 | params=params_ab, | |
445 | obj=obj_ab, | |
446 | logging_level=logging_level_ab, | |
447 | ), | |
448 | bt2.AutoSourceComponentSpec( | |
449 | self._dir_a, params=params_a, obj=obj_a, logging_level=logging_level_a | |
450 | ), | |
451 | ] | |
452 | it = bt2.TraceCollectionMessageIterator(specs) | |
453 | msgs = [x for x in it if type(x) is bt2._StreamBeginningMessage] | |
454 | ||
455 | self.assertEqual(len(msgs), 2) | |
456 | ||
457 | return msgs | |
458 | ||
459 | def test_params_one_comp_from_one_spec_one_comp_from_both_2(self): | |
460 | msgs = self._test_one_comp_from_one_spec_one_comp_from_both_2( | |
461 | params_ab={ | |
462 | 'test-bonjour': 'madame', | |
463 | 'test-salut': 'les amis', | |
464 | 'what': 'test-params', | |
465 | }, | |
466 | params_a={'test-bonjour': 'monsieur', 'what': 'test-params'}, | |
467 | ) | |
468 | ||
469 | self.assertEqual( | |
470 | msgs[0].stream.name, | |
471 | "TestSourceA: ('test-bonjour', 'monsieur'), ('test-salut', 'les amis')", | |
472 | ) | |
473 | self.assertEqual( | |
474 | msgs[1].stream.name, | |
475 | "TestSourceB: ('test-bonjour', 'madame'), ('test-salut', 'les amis')", | |
476 | ) | |
477 | ||
478 | def test_obj_one_comp_from_one_spec_one_comp_from_both_2(self): | |
479 | msgs = self._test_one_comp_from_one_spec_one_comp_from_both_2( | |
480 | params_ab={'what': 'python-obj'}, | |
481 | params_a={'what': 'python-obj'}, | |
482 | obj_ab='deore', | |
483 | obj_a='alivio', | |
484 | ) | |
485 | ||
486 | self.assertEqual(msgs[0].stream.name, "TestSourceA: alivio") | |
487 | self.assertEqual(msgs[1].stream.name, "TestSourceB: deore") | |
488 | ||
489 | def test_log_level_one_comp_from_one_spec_one_comp_from_both_2(self): | |
490 | msgs = self._test_one_comp_from_one_spec_one_comp_from_both_2( | |
491 | params_ab={'what': 'log-level'}, | |
492 | params_a={'what': 'log-level'}, | |
493 | logging_level_ab=bt2.LoggingLevel.DEBUG, | |
494 | logging_level_a=bt2.LoggingLevel.TRACE, | |
495 | ) | |
496 | ||
497 | self.assertEqual( | |
498 | msgs[0].stream.name, "TestSourceA: {}".format(bt2.LoggingLevel.TRACE) | |
499 | ) | |
500 | self.assertEqual( | |
501 | msgs[1].stream.name, "TestSourceB: {}".format(bt2.LoggingLevel.DEBUG) | |
502 | ) | |
503 | ||
504 | def test_obj_override_with_none(self): | |
505 | specs = [ | |
506 | bt2.AutoSourceComponentSpec( | |
507 | self._dir_ab, params={'what': 'python-obj'}, obj='deore' | |
508 | ), | |
509 | bt2.AutoSourceComponentSpec( | |
510 | self._dir_a, params={'what': 'python-obj'}, obj=None | |
511 | ), | |
512 | ] | |
513 | it = bt2.TraceCollectionMessageIterator(specs) | |
514 | msgs = [x for x in it if type(x) is bt2._StreamBeginningMessage] | |
515 | ||
516 | self.assertEqual(len(msgs), 2) | |
517 | self.assertEqual(msgs[0].stream.name, "TestSourceA: None") | |
518 | self.assertEqual(msgs[1].stream.name, "TestSourceB: deore") | |
519 | ||
520 | def test_obj_no_override_with_no_obj(self): | |
521 | specs = [ | |
522 | bt2.AutoSourceComponentSpec( | |
523 | self._dir_ab, params={'what': 'python-obj'}, obj='deore' | |
524 | ), | |
525 | bt2.AutoSourceComponentSpec(self._dir_a, params={'what': 'python-obj'}), | |
526 | ] | |
527 | it = bt2.TraceCollectionMessageIterator(specs) | |
528 | msgs = [x for x in it if type(x) is bt2._StreamBeginningMessage] | |
529 | ||
530 | self.assertEqual(len(msgs), 2) | |
531 | self.assertEqual(msgs[0].stream.name, "TestSourceA: deore") | |
532 | self.assertEqual(msgs[1].stream.name, "TestSourceB: deore") | |
533 | ||
534 | ||
535 | if __name__ == '__main__': | |
536 | unittest.main() |