| OLD | NEW |
|---|
| (Empty) |
| 1 # Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 # Use of this source code is governed by a BSD-style license that can be | |
| 3 # found in the LICENSE file. | |
| 4 | |
| 5 import collections | |
| 6 import copy | |
| 7 import logging | |
| 8 import operator | |
| 9 import unittest | |
| 10 | |
| 11 import devtools_monitor | |
| 12 | |
| 13 from tracing import (Event, TracingTrack, _IntervalTree) | |
| 14 | |
| 15 | |
| 16 class TracingTrackTestCase(unittest.TestCase): | |
| 17 _MIXED_EVENTS = [ | |
| 18 {'ts': 3, 'ph': 'N', 'id': 1, 'args': {'name': 'A'}}, | |
| 19 {'ts': 5, 'ph': 'X', 'dur': 1, 'args': {'name': 'B'}}, | |
| 20 {'ts': 7, 'ph': 'D', 'id': 1}, | |
| 21 {'ts': 10, 'ph': 'B', 'args': {'name': 'D'}}, | |
| 22 {'ts': 10, 'ph': 'b', 'cat': 'X', 'id': 1, 'args': {'name': 'C'}}, | |
| 23 {'ts': 11, 'ph': 'e', 'cat': 'X', 'id': 1}, | |
| 24 {'ts': 12, 'ph': 'E'}, | |
| 25 {'ts': 12, 'ph': 'N', 'id': 1, 'args': {'name': 'E'}}, | |
| 26 {'ts': 13, 'ph': 'b', 'cat': 'X', 'id': 2, 'args': {'name': 'F'}}, | |
| 27 {'ts': 14, 'ph': 'e', 'cat': 'X', 'id': 2}, | |
| 28 {'ts': 15, 'ph': 'D', 'id': 1}] | |
| 29 | |
| 30 _EVENTS = [ | |
| 31 {'ts': 5, 'ph': 'X', 'dur': 1, 'pid': 2, 'tid': 1, 'args': {'name': 'B'}}, | |
| 32 {'ts': 3, 'ph': 'X', 'dur': 4, 'pid': 2, 'tid': 1, 'args': {'name': 'A'}}, | |
| 33 {'ts': 10, 'ph': 'X', 'dur': 1, 'pid': 2, 'tid': 2, | |
| 34 'args': {'name': 'C'}}, | |
| 35 {'ts': 10, 'ph': 'X', 'dur': 2, 'pid': 2, 'tid': 2, | |
| 36 'args': {'name': 'D'}}, | |
| 37 {'ts': 13, 'ph': 'X', 'dur': 1, 'pid': 2, 'tid': 1, | |
| 38 'args': {'name': 'F'}}, | |
| 39 {'ts': 12, 'ph': 'X', 'dur': 3, 'pid': 2, 'tid': 1, | |
| 40 'args': {'name': 'E'}}] | |
| 41 | |
| 42 def setUp(self): | |
| 43 self.tree_threshold = _IntervalTree._TRESHOLD | |
| 44 _IntervalTree._TRESHOLD = 2 # Expose more edge cases in the tree. | |
| 45 self.track = TracingTrack(None, ['A', 'B', 'C', 'D']) | |
| 46 | |
| 47 def tearDown(self): | |
| 48 _IntervalTree._TRESHOLD = self.tree_threshold | |
| 49 | |
| 50 def EventToMicroseconds(self, event): | |
| 51 result = copy.deepcopy(event) | |
| 52 if 'ts' in result: | |
| 53 result['ts'] *= 1000 | |
| 54 if 'dur' in result: | |
| 55 result['dur'] *= 1000 | |
| 56 return result | |
| 57 | |
| 58 def CheckTrack(self, timestamp, names): | |
| 59 self.track._IndexEvents(strict=True) | |
| 60 self.assertEqual( | |
| 61 set((e.args['name'] for e in self.track.EventsAt(timestamp))), | |
| 62 set(names)) | |
| 63 | |
| 64 def CheckIntervals(self, events): | |
| 65 """All tests should produce the following sequence of intervals, each | |
| 66 identified by a 'name' in the event args. | |
| 67 | |
| 68 Timestamp | |
| 69 3 | A | |
| 70 4 | | |
| 71 5 | | B | |
| 72 6 | | |
| 73 7 | |
| 74 .. | |
| 75 10 | | C, D | |
| 76 11 | | |
| 77 12 | E | |
| 78 13 | | F | |
| 79 14 | | |
| 80 """ | |
| 81 self.track.Handle('Tracing.dataCollected', | |
| 82 {'params': {'value': [self.EventToMicroseconds(e) | |
| 83 for e in events]}}) | |
| 84 self.CheckTrack(0, '') | |
| 85 self.CheckTrack(2, '') | |
| 86 self.CheckTrack(3, 'A') | |
| 87 self.CheckTrack(4, 'A') | |
| 88 self.CheckTrack(5, 'AB') | |
| 89 self.CheckTrack(6, 'A') | |
| 90 self.CheckTrack(7, '') | |
| 91 self.CheckTrack(9, '') | |
| 92 self.CheckTrack(10, 'CD') | |
| 93 self.CheckTrack(11, 'D') | |
| 94 self.CheckTrack(12, 'E') | |
| 95 self.CheckTrack(13, 'EF') | |
| 96 self.CheckTrack(14, 'E') | |
| 97 self.CheckTrack(15, '') | |
| 98 self.CheckTrack(100, '') | |
| 99 | |
| 100 def testComplete(self): | |
| 101 # These are deliberately out of order. | |
| 102 self.CheckIntervals([ | |
| 103 {'ts': 5, 'ph': 'X', 'dur': 1, 'args': {'name': 'B'}}, | |
| 104 {'ts': 3, 'ph': 'X', 'dur': 4, 'args': {'name': 'A'}}, | |
| 105 {'ts': 10, 'ph': 'X', 'dur': 1, 'args': {'name': 'C'}}, | |
| 106 {'ts': 10, 'ph': 'X', 'dur': 2, 'args': {'name': 'D'}}, | |
| 107 {'ts': 13, 'ph': 'X', 'dur': 1, 'args': {'name': 'F'}}, | |
| 108 {'ts': 12, 'ph': 'X', 'dur': 3, 'args': {'name': 'E'}}]) | |
| 109 | |
| 110 def testDuration(self): | |
| 111 self.CheckIntervals([ | |
| 112 {'ts': 3, 'ph': 'B', 'args': {'name': 'A'}}, | |
| 113 {'ts': 5, 'ph': 'B', 'args': {'name': 'B'}}, | |
| 114 {'ts': 6, 'ph': 'E'}, | |
| 115 {'ts': 7, 'ph': 'E'}, | |
| 116 # Since async intervals aren't named and must be nested, we fudge the | |
| 117 # beginning of D by a tenth to ensure it's consistently detected as the | |
| 118 # outermost event. | |
| 119 {'ts': 9.9, 'ph': 'B', 'args': {'name': 'D'}}, | |
| 120 {'ts': 10, 'ph': 'B', 'args': {'name': 'C'}}, | |
| 121 {'ts': 11, 'ph': 'E'}, | |
| 122 # End of D. As end times are exclusive this should not conflict with the | |
| 123 # start of E. | |
| 124 {'ts': 12, 'ph': 'E'}, | |
| 125 {'ts': 12, 'ph': 'B', 'args': {'name': 'E'}}, | |
| 126 {'ts': 13, 'ph': 'B', 'args': {'name': 'F'}}, | |
| 127 {'ts': 14, 'ph': 'E'}, | |
| 128 {'ts': 15, 'ph': 'E'}]) | |
| 129 | |
| 130 def testBadDurationExtraBegin(self): | |
| 131 self.assertRaises(devtools_monitor.DevToolsConnectionException, | |
| 132 self.CheckIntervals, | |
| 133 [{'ts': 3, 'ph': 'B'}, | |
| 134 {'ts': 4, 'ph': 'B'}, | |
| 135 {'ts': 5, 'ph': 'E'}]) | |
| 136 | |
| 137 def testBadDurationExtraEnd(self): | |
| 138 self.assertRaises(devtools_monitor.DevToolsConnectionException, | |
| 139 self.CheckIntervals, | |
| 140 [{'ts': 3, 'ph': 'B'}, | |
| 141 {'ts': 4, 'ph': 'E'}, | |
| 142 {'ts': 5, 'ph': 'E'}]) | |
| 143 | |
| 144 def testAsync(self): | |
| 145 self.CheckIntervals([ | |
| 146 # A, B and F have the same category/id (so that A & B nest); C-E do not. | |
| 147 {'ts': 3, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'A'}}, | |
| 148 {'ts': 5, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'B'}}, | |
| 149 # Not indexable. | |
| 150 {'ts': 4, 'ph': 'n', 'cat': 'A', 'id': 1, 'args': {'name': 'A'}}, | |
| 151 {'ts': 6, 'ph': 'e', 'cat': 'A', 'id': 1}, | |
| 152 {'ts': 7, 'ph': 'e', 'cat': 'A', 'id': 1}, | |
| 153 {'ts': 10, 'ph': 'b', 'cat': 'B', 'id': 2, 'args': {'name': 'D'}}, | |
| 154 {'ts': 10, 'ph': 'b', 'cat': 'B', 'id': 3, 'args': {'name': 'C'}}, | |
| 155 {'ts': 11, 'ph': 'e', 'cat': 'B', 'id': 3}, | |
| 156 {'ts': 12, 'ph': 'e', 'cat': 'B', 'id': 2}, | |
| 157 {'ts': 12, 'ph': 'b', 'cat': 'A', 'id': 2, 'args': {'name': 'E'}}, | |
| 158 {'ts': 13, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'F'}}, | |
| 159 {'ts': 14, 'ph': 'e', 'cat': 'A', 'id': 1}, | |
| 160 {'ts': 15, 'ph': 'e', 'cat': 'A', 'id': 2}]) | |
| 161 | |
| 162 def testBadAsyncIdMismatch(self): | |
| 163 self.assertRaises( | |
| 164 devtools_monitor.DevToolsConnectionException, | |
| 165 self.CheckIntervals, | |
| 166 [{'ts': 3, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'A'}}, | |
| 167 {'ts': 5, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'B'}}, | |
| 168 {'ts': 6, 'ph': 'e', 'cat': 'A', 'id': 2}, | |
| 169 {'ts': 7, 'ph': 'e', 'cat': 'A', 'id': 1}]) | |
| 170 | |
| 171 def testBadAsyncExtraBegin(self): | |
| 172 self.assertRaises( | |
| 173 devtools_monitor.DevToolsConnectionException, | |
| 174 self.CheckIntervals, | |
| 175 [{'ts': 3, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'A'}}, | |
| 176 {'ts': 5, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'B'}}, | |
| 177 {'ts': 6, 'ph': 'e', 'cat': 'A', 'id': 1}]) | |
| 178 | |
| 179 def testBadAsyncExtraEnd(self): | |
| 180 self.assertRaises( | |
| 181 devtools_monitor.DevToolsConnectionException, | |
| 182 self.CheckIntervals, | |
| 183 [{'ts': 3, 'ph': 'b', 'cat': 'A', 'id': 1, 'args': {'name': 'A'}}, | |
| 184 {'ts': 5, 'ph': 'e', 'cat': 'A', 'id': 1}, | |
| 185 {'ts': 6, 'ph': 'e', 'cat': 'A', 'id': 1}]) | |
| 186 | |
| 187 def testObject(self): | |
| 188 # A and E share ids, which is okay as their scopes are disjoint. | |
| 189 self.CheckIntervals([ | |
| 190 {'ts': 3, 'ph': 'N', 'id': 1, 'args': {'name': 'A'}}, | |
| 191 {'ts': 5, 'ph': 'N', 'id': 2, 'args': {'name': 'B'}}, | |
| 192 {'ts': 6, 'ph': 'D', 'id': 2}, | |
| 193 {'ts': 6, 'ph': 'O', 'id': 2}, # Ignored. | |
| 194 {'ts': 7, 'ph': 'D', 'id': 1}, | |
| 195 {'ts': 10, 'ph': 'N', 'id': 3, 'args': {'name': 'D'}}, | |
| 196 {'ts': 10, 'ph': 'N', 'id': 4, 'args': {'name': 'C'}}, | |
| 197 {'ts': 11, 'ph': 'D', 'id': 4}, | |
| 198 {'ts': 12, 'ph': 'D', 'id': 3}, | |
| 199 {'ts': 12, 'ph': 'N', 'id': 1, 'args': {'name': 'E'}}, | |
| 200 {'ts': 13, 'ph': 'N', 'id': 5, 'args': {'name': 'F'}}, | |
| 201 {'ts': 14, 'ph': 'D', 'id': 5}, | |
| 202 {'ts': 15, 'ph': 'D', 'id': 1}]) | |
| 203 | |
| 204 def testMixed(self): | |
| 205 # A and E are objects, B complete, D a duration, and C and F async. | |
| 206 self.CheckIntervals(self._MIXED_EVENTS) | |
| 207 | |
| 208 def testEventSerialization(self): | |
| 209 for e in self._MIXED_EVENTS: | |
| 210 event = Event(e) | |
| 211 json_dict = event.ToJsonDict() | |
| 212 deserialized_event = Event.FromJsonDict(json_dict) | |
| 213 self.assertEquals( | |
| 214 event.tracing_event, deserialized_event.tracing_event) | |
| 215 | |
| 216 def testTracingTrackSerialization(self): | |
| 217 self._HandleEvents(self._MIXED_EVENTS) | |
| 218 json_dict = self.track.ToJsonDict() | |
| 219 self.assertTrue('events' in json_dict) | |
| 220 deserialized_track = TracingTrack.FromJsonDict(json_dict) | |
| 221 self.assertEquals( | |
| 222 len(self.track._events), len(deserialized_track._events)) | |
| 223 for (e1, e2) in zip(self.track._events, deserialized_track._events): | |
| 224 self.assertEquals(e1.tracing_event, e2.tracing_event) | |
| 225 | |
| 226 def testEventsEndingBetween(self): | |
| 227 self._HandleEvents(self._EVENTS) | |
| 228 self.assertEqual(set('ABCDEF'), | |
| 229 set([e.args['name'] | |
| 230 for e in self.track.EventsEndingBetween(0, 100)])) | |
| 231 self.assertFalse([e.args['name'] | |
| 232 for e in self.track.EventsEndingBetween(3, 5)]) | |
| 233 self.assertTrue('B' in set([e.args['name'] | |
| 234 for e in self.track.EventsEndingBetween(3, 6)])) | |
| 235 self.assertEqual(set('B'), | |
| 236 set([e.args['name'] | |
| 237 for e in self.track.EventsEndingBetween(3, 6)])) | |
| 238 | |
| 239 def testOverlappingEvents(self): | |
| 240 self._HandleEvents(self._EVENTS) | |
| 241 self.assertEqual(set('ABCDEF'), | |
| 242 set([e.args['name'] | |
| 243 for e in self.track.OverlappingEvents(0, 100)])) | |
| 244 self.assertFalse([e.args['name'] | |
| 245 for e in self.track.OverlappingEvents(0, 2)]) | |
| 246 self.assertEqual(set('BA'), | |
| 247 set([e.args['name'] | |
| 248 for e in self.track.OverlappingEvents(4, 5.1)])) | |
| 249 self.assertEqual(set('ACD'), | |
| 250 set([e.args['name'] | |
| 251 for e in self.track.OverlappingEvents(6, 10.1)])) | |
| 252 | |
| 253 def testEventFromStep(self): | |
| 254 events = [ | |
| 255 {'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 256 'name': 'B'}, | |
| 257 {'ts': 5, 'ph': 'X', 'dur': 2, 'pid': 2, 'tid': 1, 'id': '0x12343', | |
| 258 'name': 'A'}] | |
| 259 step_events = [{'ts': 6, 'ph': 'T', 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 260 'name': 'B', 'args': {'step': 'Bla'}}, | |
| 261 {'ts': 4, 'ph': 'T', 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 262 'name': 'B', 'args': {'step': 'Bla'}}, | |
| 263 {'ts': 6, 'ph': 'T', 'pid': 12, 'tid': 1, 'id': '0x123', | |
| 264 'name': 'B', 'args': {'step': 'Bla'}}, | |
| 265 {'ts': 6, 'ph': 'T', 'pid': 2, 'tid': 1, 'id': '0x1234', | |
| 266 'name': 'B', 'args': {'step': 'Bla'}}, | |
| 267 {'ts': 6, 'ph': 'T', 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 268 'name': 'A', 'args': {'step': 'Bla'}}, | |
| 269 {'ts': 6, 'ph': 'n', 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 270 'name': 'B', 'args': {'step': 'Bla'}}, | |
| 271 {'ts': 6, 'ph': 'n', 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 272 'name': 'B', 'args': {}}] | |
| 273 self._HandleEvents(events + step_events) | |
| 274 trace_events = self.track.GetEvents() | |
| 275 self.assertEquals(9, len(trace_events)) | |
| 276 # pylint: disable=unbalanced-tuple-unpacking | |
| 277 (event, _, step_event, outside, wrong_pid, wrong_id, wrong_name, | |
| 278 wrong_phase, no_step) = trace_events | |
| 279 self.assertEquals(event, self.track.EventFromStep(step_event)) | |
| 280 self.assertIsNone(self.track.EventFromStep(outside)) | |
| 281 self.assertIsNone(self.track.EventFromStep(wrong_pid)) | |
| 282 self.assertIsNone(self.track.EventFromStep(wrong_id)) | |
| 283 self.assertIsNone(self.track.EventFromStep(wrong_name)) | |
| 284 # Invalid events | |
| 285 with self.assertRaises(AssertionError): | |
| 286 self.track.EventFromStep(wrong_phase) | |
| 287 with self.assertRaises(AssertionError): | |
| 288 self.track.EventFromStep(no_step) | |
| 289 | |
| 290 def testFilterPidTid(self): | |
| 291 self._HandleEvents(self._EVENTS) | |
| 292 tracing_track = self.track.Filter(2, 1) | |
| 293 self.assertTrue(tracing_track is not self.track) | |
| 294 self.assertEquals(4, len(tracing_track.GetEvents())) | |
| 295 tracing_track = self.track.Filter(2, 42) | |
| 296 self.assertEquals(0, len(tracing_track.GetEvents())) | |
| 297 | |
| 298 def testGetMainFrameID(self): | |
| 299 _MAIN_FRAME_ID = 0xffff | |
| 300 _SUBFRAME_ID = 0xaaaa | |
| 301 events = [ | |
| 302 {'ts': 7, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 303 'name': 'navigationStart', 'cat': 'blink.user_timing', | |
| 304 'args': {'frame': _SUBFRAME_ID}}, | |
| 305 {'ts': 8, 'ph': 'X', 'dur': 2, 'pid': 2, 'tid': 1, 'id': '0x12343', | |
| 306 'name': 'A'}, | |
| 307 {'ts': 3, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'id': '0x125', | |
| 308 'name': 'navigationStart', 'cat': 'blink.user_timing', | |
| 309 'args': {'frame': _MAIN_FRAME_ID}}, | |
| 310 ] | |
| 311 self._HandleEvents(events) | |
| 312 self.assertEquals(_MAIN_FRAME_ID, self.track.GetMainFrameID()) | |
| 313 | |
| 314 def testGetMatchingEvents(self): | |
| 315 _MAIN_FRAME_ID = 0xffff | |
| 316 _SUBFRAME_ID = 0xaaaa | |
| 317 events = [ | |
| 318 {'ts': 7, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'id': '0x123', | |
| 319 'name': 'navigationStart', 'cat': 'blink.user_timing', | |
| 320 'args': {'frame': _SUBFRAME_ID}}, | |
| 321 {'ts': 8, 'ph': 'X', 'dur': 2, 'pid': 2, 'tid': 1, 'id': '0x12343', | |
| 322 'name': 'A'}, | |
| 323 {'ts': 3, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'id': '0x125', | |
| 324 'name': 'navigationStart', 'cat': 'blink.user_timing', | |
| 325 'args': {'frame': _MAIN_FRAME_ID}}, | |
| 326 ] | |
| 327 self._HandleEvents(events) | |
| 328 matching_events = self.track.GetMatchingEvents('blink.user_timing', | |
| 329 'navigationStart') | |
| 330 self.assertEquals(2, len(matching_events)) | |
| 331 self.assertListEqual([self.track.GetEvents()[0], | |
| 332 self.track.GetEvents()[2]], matching_events) | |
| 333 | |
| 334 matching_main_frame_events = self.track.GetMatchingMainFrameEvents( | |
| 335 'blink.user_timing', 'navigationStart') | |
| 336 self.assertEquals(1, len(matching_main_frame_events)) | |
| 337 self.assertListEqual([self.track.GetEvents()[2]], | |
| 338 matching_main_frame_events) | |
| 339 | |
| 340 def testFilterCategories(self): | |
| 341 events = [ | |
| 342 {'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'cat': 'A'}, | |
| 343 {'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'cat': 'B'}, | |
| 344 {'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'cat': 'C,D'}, | |
| 345 {'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 2, 'tid': 1, 'cat': 'A,B,C,D'}] | |
| 346 self._HandleEvents(events) | |
| 347 tracing_events = self.track.GetEvents() | |
| 348 self.assertEquals(4, len(tracing_events)) | |
| 349 filtered_events = self.track.Filter(categories=None).GetEvents() | |
| 350 self.assertListEqual(tracing_events, filtered_events) | |
| 351 filtered_events = self.track.Filter(categories=set(['A'])).GetEvents() | |
| 352 self.assertEquals(2, len(filtered_events)) | |
| 353 self.assertListEqual([tracing_events[0], tracing_events[3]], | |
| 354 filtered_events) | |
| 355 filtered_events = self.track.Filter(categories=set(['Z'])).GetEvents() | |
| 356 self.assertEquals(0, len(filtered_events)) | |
| 357 filtered_events = self.track.Filter(categories=set(['B', 'C'])).GetEvents() | |
| 358 self.assertEquals(3, len(filtered_events)) | |
| 359 self.assertListEqual(tracing_events[1:], filtered_events) | |
| 360 self.assertSetEqual( | |
| 361 set('A'), self.track.Filter(categories=set('A')).Categories()) | |
| 362 | |
| 363 def testHasLoadingSucceeded(self): | |
| 364 cat = 'navigation' | |
| 365 on_navigate = 'RenderFrameImpl::OnNavigate' | |
| 366 fail_provisional = 'RenderFrameImpl::didFailProvisionalLoad' | |
| 367 fail_load = 'RenderFrameImpl::didFailLoad' | |
| 368 | |
| 369 track = TracingTrack.FromJsonDict({'categories': [cat], 'events': []}) | |
| 370 with self.assertRaises(AssertionError): | |
| 371 track.HasLoadingSucceeded() | |
| 372 | |
| 373 track = TracingTrack.FromJsonDict({'categories': [cat], 'events': [ | |
| 374 {'cat': cat, 'name': on_navigate, 'args': {'id': 1}, | |
| 375 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}]}) | |
| 376 self.assertTrue(track.HasLoadingSucceeded()) | |
| 377 | |
| 378 track = TracingTrack.FromJsonDict({'categories': [cat], 'events': [ | |
| 379 {'cat': cat, 'name': on_navigate, 'args': {'id': 1}, | |
| 380 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}, | |
| 381 {'cat': cat, 'name': on_navigate, 'args': {'id': 2}, | |
| 382 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}, | |
| 383 {'cat': cat, 'name': fail_provisional, 'args': {'id': 2}, | |
| 384 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}]}) | |
| 385 self.assertTrue(track.HasLoadingSucceeded()) | |
| 386 | |
| 387 track = TracingTrack.FromJsonDict({'categories': [cat], 'events': [ | |
| 388 {'cat': cat, 'name': on_navigate, 'args': {'id': 1}, | |
| 389 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}, | |
| 390 {'cat': cat, 'name': fail_provisional, 'args': {'id': 1}, | |
| 391 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}]}) | |
| 392 self.assertFalse(track.HasLoadingSucceeded()) | |
| 393 | |
| 394 track = TracingTrack.FromJsonDict({'categories': [cat], 'events': [ | |
| 395 {'cat': cat, 'name': on_navigate, 'args': {'id': 1}, | |
| 396 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}, | |
| 397 {'cat': cat, 'name': fail_load, 'args': {'id': 1}, | |
| 398 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}]}) | |
| 399 self.assertFalse(track.HasLoadingSucceeded()) | |
| 400 | |
| 401 track = TracingTrack.FromJsonDict({'categories': [cat], 'events': [ | |
| 402 {'cat': cat, 'name': on_navigate, 'args': {'id': 1}, | |
| 403 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}, | |
| 404 {'cat': cat, 'name': fail_load, 'args': {'id': 1}, | |
| 405 'ts': 5, 'ph': 'X', 'dur': 10, 'pid': 1, 'tid': 1}]}) | |
| 406 self.assertFalse(track.HasLoadingSucceeded()) | |
| 407 | |
| 408 def _HandleEvents(self, events): | |
| 409 self.track.Handle('Tracing.dataCollected', {'params': {'value': [ | |
| 410 self.EventToMicroseconds(e) for e in events]}}) | |
| 411 | |
| 412 | |
| 413 class IntervalTreeTestCase(unittest.TestCase): | |
| 414 class FakeEvent(object): | |
| 415 def __init__(self, start_msec, end_msec): | |
| 416 self.start_msec = start_msec | |
| 417 self.end_msec = end_msec | |
| 418 | |
| 419 def __eq__(self, o): | |
| 420 return self.start_msec == o.start_msec and self.end_msec == o.end_msec | |
| 421 | |
| 422 _COUNT = 1000 | |
| 423 | |
| 424 def testCreateTree(self): | |
| 425 events = [self.FakeEvent(100 * i, 100 * (i + 1)) | |
| 426 for i in range(self._COUNT)] | |
| 427 tree = _IntervalTree.FromEvents(events) | |
| 428 self.assertEquals(0, tree.start) | |
| 429 self.assertEquals(100 * self._COUNT, tree.end) | |
| 430 self.assertFalse(tree._IsLeaf()) | |
| 431 | |
| 432 def testEventsAt(self): | |
| 433 events = ([self.FakeEvent(100 * i, 100 * (i + 1)) | |
| 434 for i in range(self._COUNT)] | |
| 435 + [self.FakeEvent(100 * i + 50, 100 * i + 150) | |
| 436 for i in range(self._COUNT)]) | |
| 437 tree = _IntervalTree.FromEvents(events) | |
| 438 self.assertEquals(0, tree.start) | |
| 439 self.assertEquals(100 * self._COUNT + 50, tree.end) | |
| 440 self.assertFalse(tree._IsLeaf()) | |
| 441 for i in range(self._COUNT): | |
| 442 self.assertEquals(2, len(tree.EventsAt(100 * i + 75))) | |
| 443 # Add instant events, check that they are excluded. | |
| 444 events += [self.FakeEvent(100 * i + 75, 100 * i + 75) | |
| 445 for i in range(self._COUNT)] | |
| 446 tree = _IntervalTree.FromEvents(events) | |
| 447 self.assertEquals(3 * self._COUNT, len(tree._events)) | |
| 448 for i in range(self._COUNT): | |
| 449 self.assertEquals(2, len(tree.EventsAt(100 * i + 75))) | |
| 450 | |
| 451 def testOverlappingEvents(self): | |
| 452 events = ([self.FakeEvent(100 * i, 100 * (i + 1)) | |
| 453 for i in range(self._COUNT)] | |
| 454 + [self.FakeEvent(100 * i + 50, 100 * i + 150) | |
| 455 for i in range(self._COUNT)]) | |
| 456 tree = _IntervalTree.FromEvents(events) | |
| 457 self.assertEquals(0, tree.start) | |
| 458 self.assertEquals(100 * self._COUNT + 50, tree.end) | |
| 459 self.assertFalse(tree._IsLeaf()) | |
| 460 # 400 -> 500, 450 -> 550, 500 -> 600 | |
| 461 self.assertEquals(3, len(tree.OverlappingEvents(450, 550))) | |
| 462 overlapping = sorted( | |
| 463 tree.OverlappingEvents(450, 550), key=operator.attrgetter('start_msec')) | |
| 464 self.assertEquals(self.FakeEvent(400, 500), overlapping[0]) | |
| 465 self.assertEquals(self.FakeEvent(450, 550), overlapping[1]) | |
| 466 self.assertEquals(self.FakeEvent(500, 600), overlapping[2]) | |
| 467 self.assertEquals(8, len(tree.OverlappingEvents(450, 800))) | |
| 468 # Add instant events, check that they are included. | |
| 469 events += [self.FakeEvent(500, 500) for i in range(10)] | |
| 470 tree = _IntervalTree.FromEvents(events) | |
| 471 self.assertEquals(3 + 10, len(tree.OverlappingEvents(450, 550))) | |
| 472 self.assertEquals(8 + 10, len(tree.OverlappingEvents(450, 800))) | |
| 473 | |
| 474 def testEventMatches(self): | |
| 475 event = Event({'name': 'foo', | |
| 476 'cat': 'bar', | |
| 477 'ph': 'X', | |
| 478 'ts': 0, 'dur': 0}) | |
| 479 self.assertTrue(event.Matches('bar', 'foo')) | |
| 480 self.assertFalse(event.Matches('bar', 'biz')) | |
| 481 self.assertFalse(event.Matches('biz', 'foo')) | |
| 482 | |
| 483 event = Event({'name': 'foo', | |
| 484 'cat': 'bar,baz,bizbiz', | |
| 485 'ph': 'X', | |
| 486 'ts': 0, 'dur': 0}) | |
| 487 self.assertTrue(event.Matches('bar', 'foo')) | |
| 488 self.assertTrue(event.Matches('baz', 'foo')) | |
| 489 self.assertFalse(event.Matches('bar', 'biz')) | |
| 490 self.assertFalse(event.Matches('biz', 'foo')) | |
| 491 | |
| 492 if __name__ == '__main__': | |
| 493 unittest.main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2763733002:
tools/android/loading: rename tracing to tracing_track (Closed)
