X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Fplugins%2Fsrc.ctf.fs%2Fquery%2Ftest_query_trace_info.py;h=41b2b83121206ef8938451174d65c4e88519ecd9;hb=5f2a1585bf407f3f3aa7e63d9041b75390cf8563;hp=a63fe04f1f86ca14eb374157b1ba42617be24747;hpb=f2bad367743dbcfae25a8b05141ab84b042a6904;p=babeltrace.git diff --git a/tests/plugins/src.ctf.fs/query/test_query_trace_info.py b/tests/plugins/src.ctf.fs/query/test_query_trace_info.py index a63fe04f..41b2b831 100644 --- a/tests/plugins/src.ctf.fs/query/test_query_trace_info.py +++ b/tests/plugins/src.ctf.fs/query/test_query_trace_info.py @@ -26,10 +26,7 @@ test_ctf_traces_path = os.environ['BT_CTF_TRACES_PATH'] # Key to sort streams in a predictable order. def sort_predictably(stream): - if 'range-ns' in stream: - return stream['range-ns']['begin'] - else: - return stream['paths'][0] + return stream['port-name'] class QueryTraceInfoClockOffsetTestCase(unittest.TestCase): @@ -37,101 +34,97 @@ class QueryTraceInfoClockOffsetTestCase(unittest.TestCase): ctf = bt2.find_plugin('ctf') self._fs = ctf.source_component_classes['fs'] - self._paths = [ + self._inputs = [ os.path.join(test_ctf_traces_path, 'intersection', '3eventsintersect') ] - self._executor = bt2.QueryExecutor() def _check(self, trace, offset): - self.assertEqual(trace['range-ns']['begin'], 13515309000000000 + offset) - self.assertEqual(trace['range-ns']['end'], 13515309000000120 + offset) - self.assertEqual( - trace['intersection-range-ns']['begin'], 13515309000000070 + offset - ) - self.assertEqual( - trace['intersection-range-ns']['end'], 13515309000000100 + offset - ) - - streams = sorted(trace['streams'], key=sort_predictably) + streams = sorted(trace['stream-infos'], key=sort_predictably) self.assertEqual(streams[0]['range-ns']['begin'], 13515309000000000 + offset) self.assertEqual(streams[0]['range-ns']['end'], 13515309000000100 + offset) self.assertEqual(streams[1]['range-ns']['begin'], 13515309000000070 + offset) self.assertEqual(streams[1]['range-ns']['end'], 13515309000000120 + offset) # Test various cominations of the clock-class-offset-s and - # clock-class-offset-ns parameters to trace-info queries. + # clock-class-offset-ns parameters to babeltrace.trace-infos queries. # Without clock class offset def test_no_clock_class_offset(self): - res = self._executor.query(self._fs, 'trace-info', {'paths': self._paths}) + res = bt2.QueryExecutor( + self._fs, 'babeltrace.trace-infos', {'inputs': self._inputs} + ).query() trace = res[0] self._check(trace, 0) # With clock-class-offset-s def test_clock_class_offset_s(self): - res = self._executor.query( - self._fs, 'trace-info', {'paths': self._paths, 'clock-class-offset-s': 2} - ) + res = bt2.QueryExecutor( + self._fs, + 'babeltrace.trace-infos', + {'inputs': self._inputs, 'clock-class-offset-s': 2}, + ).query() trace = res[0] self._check(trace, 2000000000) # With clock-class-offset-ns def test_clock_class_offset_ns(self): - res = self._executor.query( - self._fs, 'trace-info', {'paths': self._paths, 'clock-class-offset-ns': 2} - ) + res = bt2.QueryExecutor( + self._fs, + 'babeltrace.trace-infos', + {'inputs': self._inputs, 'clock-class-offset-ns': 2}, + ).query() trace = res[0] self._check(trace, 2) # With both, negative def test_clock_class_offset_both(self): - res = self._executor.query( + res = bt2.QueryExecutor( self._fs, - 'trace-info', + 'babeltrace.trace-infos', { - 'paths': self._paths, + 'inputs': self._inputs, 'clock-class-offset-s': -2, 'clock-class-offset-ns': -2, }, - ) + ).query() trace = res[0] self._check(trace, -2000000002) def test_clock_class_offset_s_wrong_type(self): - with self.assertRaises(bt2.InvalidParams): - self._executor.query( + with self.assertRaises(bt2._Error): + bt2.QueryExecutor( self._fs, - 'trace-info', - {'paths': self._paths, 'clock-class-offset-s': "2"}, - ) + 'babeltrace.trace-infos', + {'inputs': self._inputs, 'clock-class-offset-s': "2"}, + ).query() def test_clock_class_offset_s_wrong_type_none(self): - with self.assertRaises(bt2.InvalidParams): - self._executor.query( + with self.assertRaises(bt2._Error): + bt2.QueryExecutor( self._fs, - 'trace-info', - {'paths': self._paths, 'clock-class-offset-s': None}, - ) + 'babeltrace.trace-infos', + {'inputs': self._inputs, 'clock-class-offset-s': None}, + ).query() def test_clock_class_offset_ns_wrong_type(self): - with self.assertRaises(bt2.InvalidParams): - self._executor.query( + with self.assertRaises(bt2._Error): + bt2.QueryExecutor( self._fs, - 'trace-info', - {'paths': self._paths, 'clock-class-offset-ns': "2"}, - ) + 'babeltrace.trace-infos', + {'inputs': self._inputs, 'clock-class-offset-ns': "2"}, + ).query() def test_clock_class_offset_ns_wrong_type_none(self): - with self.assertRaises(bt2.InvalidParams): - self._executor.query( + with self.assertRaises(bt2._Error): + bt2.QueryExecutor( self._fs, - 'trace-info', - {'paths': self._paths, 'clock-class-offset-ns': None}, - ) + 'babeltrace.trace-infos', + {'inputs': self._inputs, 'clock-class-offset-ns': None}, + ).query() class QueryTraceInfoPortNameTestCase(unittest.TestCase): @@ -139,20 +132,18 @@ class QueryTraceInfoPortNameTestCase(unittest.TestCase): ctf = bt2.find_plugin("ctf") self._fs = ctf.source_component_classes["fs"] - self._executor = bt2.QueryExecutor() - def test_trace_uuid_stream_class_id_no_stream_id(self): - res = self._executor.query( + res = bt2.QueryExecutor( self._fs, - "trace-info", + "babeltrace.trace-infos", { - "paths": [ + "inputs": [ os.path.join( test_ctf_traces_path, "intersection", "3eventsintersect" ) ] }, - ) + ).query() os_stream_path = PurePosixPath( '/tests/data/ctf-traces/intersection/3eventsintersect/' @@ -162,7 +153,7 @@ class QueryTraceInfoPortNameTestCase(unittest.TestCase): self.assertEqual(len(res), 1) trace = res[0] - streams = sorted(trace["streams"], key=sort_predictably) + streams = sorted(trace["stream-infos"], key=sort_predictably) self.assertEqual(len(streams), 2) self.assertRegexpMatches( str(streams[0]["port-name"]), @@ -178,11 +169,11 @@ class QueryTraceInfoPortNameTestCase(unittest.TestCase): ) def test_trace_uuid_no_stream_class_id_no_stream_id(self): - res = self._executor.query( + res = bt2.QueryExecutor( self._fs, - "trace-info", - {"paths": [os.path.join(test_ctf_traces_path, "succeed", "succeed1")]}, - ) + "babeltrace.trace-infos", + {"inputs": [os.path.join(test_ctf_traces_path, "succeed", "succeed1")]}, + ).query() os_stream_path = PurePosixPath( '/tests/data/ctf-traces/succeed/succeed1/dummystream' @@ -192,7 +183,7 @@ class QueryTraceInfoPortNameTestCase(unittest.TestCase): self.assertEqual(len(res), 1) trace = res[0] - streams = sorted(trace["streams"], key=sort_predictably) + streams = sorted(trace["stream-infos"], key=sort_predictably) self.assertEqual(len(streams), 1) self.assertRegexpMatches( str(streams[0]["port-name"]), @@ -207,27 +198,59 @@ class QueryTraceInfoRangeTestCase(unittest.TestCase): ctf = bt2.find_plugin("ctf") self._fs = ctf.source_component_classes["fs"] - self._executor = bt2.QueryExecutor() - def test_trace_no_range(self): - # This trace has no `timestamp_begin` and `timestamp_end` in its packet - # context. The `trace-info` query should omit the `range-ns` fields in - # the `trace` and `stream` data structures. + # This trace has no `timestamp_begin` and `timestamp_end` in its + # packet context. The `babeltrace.trace-infos` query should omit + # the `range-ns` fields in the `trace` and `stream` data + # structures. - res = self._executor.query( + res = bt2.QueryExecutor( self._fs, - "trace-info", - {"paths": [os.path.join(test_ctf_traces_path, "succeed", "succeed1")]}, - ) + "babeltrace.trace-infos", + {"inputs": [os.path.join(test_ctf_traces_path, "succeed", "succeed1")]}, + ).query() self.assertEqual(len(res), 1) trace = res[0] - streams = trace["streams"] + streams = trace["stream-infos"] self.assertEqual(len(streams), 1) self.assertRaises(KeyError, lambda: trace['range-ns']) self.assertRaises(KeyError, lambda: streams[0]['range-ns']) +class QueryTraceInfoPacketTimestampQuirksTestCase(unittest.TestCase): + def setUp(self): + ctf = bt2.find_plugin('ctf') + self._fs = ctf.source_component_classes['fs'] + self._path = os.path.join(test_ctf_traces_path, 'succeed') + + def _test_lttng_quirks(self, trace_name): + res = bt2.QueryExecutor( + self._fs, + "babeltrace.trace-infos", + {"inputs": [os.path.join(self._path, trace_name)]}, + ).query() + + self.assertEqual(len(res), 1) + return res[0] + + def test_event_after_packet(self): + trace = self._test_lttng_quirks("lttng-event-after-packet") + streams = trace["stream-infos"] + self.assertEqual(len(streams), 1) + + self.assertEqual(streams[0]['range-ns']['begin'], 1565957300948091100) + self.assertEqual(streams[0]['range-ns']['end'], 1565957302180016069) + + def test_lttng_crash(self): + trace = self._test_lttng_quirks("lttng-crash") + streams = trace["stream-infos"] + self.assertEqual(len(streams), 1) + + self.assertEqual(streams[0]['range-ns']['begin'], 1565891729288866738) + self.assertEqual(streams[0]['range-ns']['end'], 1565891729293526525) + + if __name__ == '__main__': unittest.main()