def testTraceValue(self): results = page_test_results.PageTestResults() results.WillRunPage(self.pages[0]) results.AddValue(trace.TraceValue( None, trace_data.CreateTraceDataFromRawData([[{'test': 1}]]))) results.DidRunPage(self.pages[0]) results.WillRunPage(self.pages[1]) results.AddValue(trace.TraceValue( None, trace_data.CreateTraceDataFromRawData([[{'test': 2}]]))) results.DidRunPage(self.pages[1]) results.PrintSummary() values = results.FindAllTraceValues() self.assertEquals(2, len(values))
def testNestedParsing(self): events = [ {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'tts': 2, 'cat': 'foo', 'tid': 1, 'ph': 'B'}, {'name': 'b', 'args': {}, 'pid': 1, 'ts': 3, 'tts': 3, 'cat': 'bar', 'tid': 1, 'ph': 'B'}, {'name': 'b', 'args': {}, 'pid': 1, 'ts': 5, 'tts': 4, 'cat': 'bar', 'tid': 1, 'ph': 'E'}, {'name': 'a', 'args': {}, 'pid': 1, 'ts': 7, 'tts': 5, 'cat': 'foo', 'tid': 1, 'ph': 'E'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data, shift_world_to_zero=False) t = m.GetAllProcesses()[0].threads[1] slice_a = FindEventNamed(t.all_slices, 'a') slice_b = FindEventNamed(t.all_slices, 'b') self.assertEqual('a', slice_a.name) self.assertEqual('foo', slice_a.category) self.assertAlmostEqual(0.001, slice_a.start) self.assertAlmostEqual(0.006, slice_a.duration) self.assertAlmostEqual(0.002, slice_a.thread_start) self.assertAlmostEqual(0.003, slice_a.thread_duration) self.assertEqual('b', slice_b.name) self.assertEqual('bar', slice_b.category) self.assertAlmostEqual(0.003, slice_b.start) self.assertAlmostEqual(0.002, slice_b.duration) self.assertAlmostEqual(0.003, slice_b.thread_start) self.assertAlmostEqual(0.001, slice_b.thread_duration)
def testNestedAutoclosing(self): events = [ # Tasks that don't finish. {'name': 'a1', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo', 'tid': 1, 'ph': 'B'}, {'name': 'a2', 'args': {}, 'pid': 1, 'ts': 1.5, 'cat': 'foo', 'tid': 1, 'ph': 'B'}, # Slice that does finish to give an 'end time' to make autoclosing work. {'name': 'b', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo', 'tid': 2, 'ph': 'B'}, {'name': 'b', 'args': {}, 'pid': 1, 'ts': 2, 'cat': 'foo', 'tid': 2, 'ph': 'E'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data, shift_world_to_zero=False) t1 = m.GetAllProcesses()[0].threads[1] t2 = m.GetAllProcesses()[0].threads[2] slice_a1 = FindEventNamed(t1.all_slices, 'a1') slice_a2 = FindEventNamed(t1.all_slices, 'a2') FindEventNamed(t2.all_slices, 'b') self.assertAlmostEqual(0.002, slice_a1.end) self.assertAlmostEqual(0.002, slice_a2.end)
def testStartFinishOneSliceOneThread(self): events = [ # Time is intentionally out of order. {'name': 'a', 'args': {}, 'pid': 52, 'ts': 560, 'cat': 'cat', 'tid': 53, 'ph': 'F', 'id': 72}, {'name': 'a', 'pid': 52, 'ts': 524, 'cat': 'cat', 'tid': 53, 'ph': 'S', 'id': 72, 'args': {'foo': 'bar'}} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) events = list(m.IterAllEvents()) self.assertEqual(2, len(events)) processes = m.GetAllProcesses() t = processes[0].threads[53] slices = t.async_slices self.assertEqual(1, len(slices)) self.assertEqual('a', slices[0].name) self.assertEqual('cat', slices[0].category) self.assertEqual(72, slices[0].id) self.assertEqual('bar', slices[0].args['foo']) self.assertEqual(0, slices[0].start) self.assertAlmostEqual((60 - 24) / 1000.0, slices[0].duration) self.assertEqual(t, slices[0].start_thread) self.assertEqual(t, slices[0].end_thread)
def testMultiCounter(self): events = [ {'name': 'ctr', 'args': {'value1': 0, 'value2': 7}, 'pid': 1, 'ts': 0, 'cat': 'foo', 'tid': 1, 'ph': 'C'}, {'name': 'ctr', 'args': {'value1': 10, 'value2': 4}, 'pid': 1, 'ts': 10, 'cat': 'foo', 'tid': 1, 'ph': 'C'}, {'name': 'ctr', 'args': {'value1': 0, 'value2': 1}, 'pid': 1, 'ts': 20, 'cat': 'foo', 'tid': 1, 'ph': 'C'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) p = m.GetAllProcesses()[0] ctr = p.counters['foo.ctr'] self.assertEqual('ctr', ctr.name) self.assertEqual('ctr', ctr.name) self.assertEqual('foo', ctr.category) self.assertEqual(3, ctr.num_samples) self.assertEqual(2, ctr.num_series) self.assertEqual(sorted(['value1', 'value2']), sorted(ctr.series_names)) self.assertEqual(sorted([0, 0.01, 0.02]), sorted(ctr.timestamps)) self.assertEqual(sorted([0, 7, 10, 4, 0, 1]), sorted(ctr.samples)) # We can't check ctr.totals here because it can change depending on # the order in which the series names are added. self.assertEqual(14, ctr.max_total)
def testFindTraceParts(self): raw_data = { 'powerTraceAsString': 'BattOr Data', 'traceEvents': [{'trace': 1}], 'tabIds': 'Tab Data', } data = trace_data.CreateTraceDataFromRawData(raw_data) v = trace.TraceValue(None, data) tempdir = tempfile.mkdtemp() temp_path = os.path.join(tempdir, 'test.json') battor_seen = False chrome_seen = False tabs_seen = False try: with codecs.open(v.filename, mode='r', encoding='utf-8') as f: trace_files = html2trace.CopyTraceDataFromHTMLFilePath(f, temp_path) for f in trace_files: with open(f, 'r') as trace_file: d = trace_file.read() if d == raw_data['powerTraceAsString']: self.assertFalse(battor_seen) battor_seen = True elif d == json.dumps({'traceEvents': raw_data['traceEvents']}): self.assertFalse(chrome_seen) chrome_seen = True elif d == raw_data['tabIds']: self.assertFalse(tabs_seen) tabs_seen = True self.assertTrue(battor_seen) self.assertTrue(chrome_seen) self.assertTrue(tabs_seen) finally: shutil.rmtree(tempdir) os.remove(v.filename)
def testImportMarkEvent(self): events = [ {'name': 'a', 'pid': 52, 'ts': 629, 'cat': 'baz', 'tid': 53, 'ph': 'R'}, {'name': 'b', 'pid': 52, 'ts': 730, 'cat': 'foo', 'tid': 53, 'ph': 'R'}, {'name': 'c', 'pid': 52, 'ts': 740, 'cat': 'baz', 'tid': 53, 'ph': 'R'}, ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) p = m.GetAllProcesses()[0] t = p.threads[53] self.assertEqual(3, len(t.all_slices)) slice_event = t.all_slices[0] self.assertEqual('a', slice_event.name) self.assertEqual('baz', slice_event.category) self.assertAlmostEqual(0.0, slice_event.start) self.assertFalse(slice_event.did_not_finish) self.assertEqual(0, len(slice_event.sub_slices)) slice_event = t.all_slices[1] self.assertEqual('b', slice_event.name) self.assertEqual('foo', slice_event.category) self.assertAlmostEqual((730 - 629) / 1000.0, slice_event.start) self.assertFalse(slice_event.did_not_finish) self.assertEqual(0, len(slice_event.sub_slices)) slice_event = t.all_slices[2] self.assertEqual('c', slice_event.name) self.assertEqual('baz', slice_event.category) self.assertAlmostEqual((740 - 629) / 1000.0, slice_event.start) self.assertFalse(slice_event.did_not_finish) self.assertEqual(0, len(slice_event.sub_slices))
def testNoLeakedTempFileOnImplicitCleanUp(self): with trace.TraceValue( None, trace_data.CreateTraceDataFromRawData([{ 'test': 1 }])): pass self.assertTrue(_IsEmptyDir(self.temp_test_dir))
def testNoLeakedTempFileWhenUploadingTrace(self): v = trace.TraceValue( None, trace_data.CreateTraceDataFromRawData([{ 'test': 1 }])) v.CleanUp() self.assertTrue(_IsEmptyDir(self.temp_test_dir))
def testMultiplePagesAndValues(self, cs_insert_mock): cs_insert_mock.return_value = 'https://cloud_storage_url/foo' trace_value = trace.TraceValue( None, trace_data.CreateTraceDataFromRawData('{"traceEvents": []}')) trace_value.UploadToCloud(bucket='foo') self.SimulateBenchmarkRun([ (self._story_set[0], [ scalar.ScalarValue( None, 'foo', 'seconds', 4, improvement_direction=improvement_direction.DOWN)]), (self._story_set[1], [ scalar.ScalarValue( None, 'foo', 'seconds', 3.4, improvement_direction=improvement_direction.DOWN), trace_value, scalar.ScalarValue( None, 'bar', 'km', 10, improvement_direction=improvement_direction.DOWN), scalar.ScalarValue( None, 'baz', 'count', 5, improvement_direction=improvement_direction.DOWN)])]) # Parse CSV output into list of lists. csv_string = self.Format() lines = csv_string.split('\r\n') values = [s.split(',') for s in lines[1:-1]] values.sort() self.assertEquals(len(values), 4) self.assertEquals(len(set((v[1] for v in values))), 2) # 2 pages. self.assertEquals(len(set((v[2] for v in values))), 4) # 4 value names. self.assertEquals(values[2], [ 'foo', 'ms', '3400', '1', '3400', '3400', '0', '3400', '', 'benchmark', '2017-07-14 02:40:00', '', '', 'benchmark 2017-07-14 02:40:00', '', '', '', '', '', 'http://www.bar.com/', '', ''])
def testImportMemoryDumpEvents(self): events = [ {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 123, 'id': '1234ABCD'}, {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 54, 'ts': 134, 'id': '1234ABCD'}, {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 144, 'id': '1234ABCD'}, {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 245, 'id': '1234ABDF'}, {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 54, 'ts': 256, 'id': '1234ABDF'}, {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 233, 'id': '1234ABDF'}, ] expected_processes = set([52, 54]) expected_results = [['1234ABCD', 0, 21], ['1234ABDF', 110, 23]] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) assert set(p.pid for p in m.GetAllProcesses()) == expected_processes memory_dumps = list(m.IterGlobalMemoryDumps()) self.assertEqual(len(expected_results), len(memory_dumps)) for memory_dump, test_values in zip(memory_dumps, expected_results): assert len(list(memory_dump.IterProcessMemoryDumps())) == len( expected_processes) dump_id, start, duration = test_values self.assertEquals(dump_id, memory_dump.dump_id) self.assertAlmostEqual(start / 1000.0, memory_dump.start) self.assertAlmostEqual(duration / 1000.0, memory_dump.duration)
def testAsDictWithTraceValue(self): tempdir = tempfile.mkdtemp() try: results = page_test_results.PageTestResults() results.WillRunPage(self._story_set[0]) v0 = trace.TraceValue(results.current_page, trace_data.CreateTraceDataFromRawData([{ 'event': 'test' }]), file_path=os.path.join( tempdir, 'testAsDictWithTraceValue.html')) results.AddValue(v0) results.DidRunPage(self._story_set[0]) results._SerializeTracesToDirPath() d = json_output_formatter.ResultsAsDict( results, self._formatter.benchmark_metadata) self.assertTrue(_HasPage(d['pages'], self._story_set[0])) self.assertTrue(_HasValueNamed(d['per_page_values'], 'trace')) self.assertEquals(len(d['files']), 1) output_trace_path = d['files'].values()[0] self.assertTrue(output_trace_path.startswith(tempdir)) self.assertTrue(os.path.exists(output_trace_path)) finally: shutil.rmtree(tempdir)
def testNoTracesLeftAfterCleanUp(self): results = page_test_results.PageTestResults() v0 = trace.TraceValue(None, trace_data.CreateTraceDataFromRawData([{'test': 1}])) v1 = trace.TraceValue(None, trace_data.CreateTraceDataFromRawData([{'test': 2}])) results.WillRunPage(self.pages[0]) results.AddValue(v0) results.DidRunPage(self.pages[0]) results.WillRunPage(self.pages[1]) results.AddValue(v1) results.DidRunPage(self.pages[1]) results.CleanUp() self.assertFalse(results.FindAllTraceValues())
def testBasicSingleThreadNonnestedParsing(self): events = [ {'name': 'a', 'args': {}, 'pid': 52, 'ts': 520, 'tts': 280, 'cat': 'foo', 'tid': 53, 'ph': 'B'}, {'name': 'a', 'args': {}, 'pid': 52, 'ts': 560, 'tts': 310, 'cat': 'foo', 'tid': 53, 'ph': 'E'}, {'name': 'b', 'args': {}, 'pid': 52, 'ts': 629, 'tts': 356, 'cat': 'bar', 'tid': 53, 'ph': 'B'}, {'name': 'b', 'args': {}, 'pid': 52, 'ts': 631, 'tts': 357, 'cat': 'bar', 'tid': 53, 'ph': 'E'}, {'name': 'c', 'args': {}, 'pid': 52, 'ts': 633, 'cat': 'baz', 'tid': 53, 'ph': 'B'}, {'name': 'c', 'args': {}, 'pid': 52, 'ts': 637, 'cat': 'baz', 'tid': 53, 'ph': 'E'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) processes = m.GetAllProcesses() self.assertEqual(1, len(processes)) p = processes[0] self.assertEqual(52, p.pid) self.assertEqual(1, len(p.threads)) t = p.threads[53] self.assertEqual(3, len(t.all_slices)) self.assertEqual(53, t.tid) slice_event = t.all_slices[0] self.assertEqual('a', slice_event.name) self.assertEqual('foo', slice_event.category) self.assertAlmostEqual(0, slice_event.start) self.assertAlmostEqual((560 - 520) / 1000.0, slice_event.duration) self.assertAlmostEqual((560 - 520) / 1000.0, slice_event.end) self.assertAlmostEqual(280 / 1000.0, slice_event.thread_start) self.assertAlmostEqual((310 - 280) / 1000.0, slice_event.thread_duration) self.assertAlmostEqual(310 / 1000.0, slice_event.thread_end) self.assertEqual(0, len(slice_event.sub_slices)) slice_event = t.all_slices[1] self.assertEqual('b', slice_event.name) self.assertEqual('bar', slice_event.category) self.assertAlmostEqual((629 - 520) / 1000.0, slice_event.start) self.assertAlmostEqual((631 - 629) / 1000.0, slice_event.duration) self.assertAlmostEqual((631 - 520) / 1000.0, slice_event.end) self.assertAlmostEqual(356 / 1000.0, slice_event.thread_start) self.assertAlmostEqual((357 - 356) / 1000.0, slice_event.thread_duration) self.assertAlmostEqual(357 / 1000.0, slice_event.thread_end) self.assertEqual(0, len(slice_event.sub_slices)) slice_event = t.all_slices[2] self.assertEqual('c', slice_event.name) self.assertEqual('baz', slice_event.category) self.assertAlmostEqual((633 - 520) / 1000.0, slice_event.start) self.assertAlmostEqual((637 - 633) / 1000.0, slice_event.duration) self.assertEqual(None, slice_event.thread_start) self.assertEqual(None, slice_event.thread_duration) self.assertEqual(None, slice_event.thread_end) self.assertEqual(0, len(slice_event.sub_slices))
def testRepr(self): v = trace.TraceValue(self.pages[0], trace_data.CreateTraceDataFromRawData([{ 'test': 1 }]), important=True, description='desc') self.assertEquals('TraceValue(http://www.bar.com/, trace)', str(v))
def testCleanUpCleansUpTraceValues(self): results = page_test_results.PageTestResults() v0 = trace.TraceValue( None, trace_data.CreateTraceDataFromRawData([{'test': 1}])) v1 = trace.TraceValue( None, trace_data.CreateTraceDataFromRawData([{'test': 2}])) results.WillRunPage(self.pages[0]) results.AddValue(v0) results.DidRunPage(self.pages[0]) results.WillRunPage(self.pages[1]) results.AddValue(v1) results.DidRunPage(self.pages[1]) results.CleanUp() self.assertTrue(v0.cleaned_up) self.assertTrue(v1.cleaned_up)
def testTraceSerializationContainStoryName(self): tempdir = tempfile.mkdtemp() try: v = trace.TraceValue(self.pages[0], trace_data.CreateTraceDataFromRawData([{'test': 1}])) fh = v.Serialize(tempdir) self.assertTrue(os.path.basename(fh.GetAbsPath()).startswith( 'http___www_bar_com')) finally: shutil.rmtree(tempdir)
def testSerialize(self): test_dir = tempfile.mkdtemp() trace_path = os.path.join(test_dir, 'test_trace.json') try: ri = trace_data.CreateTraceDataFromRawData({'traceEvents': [1, 2, 3]}) ri.Serialize(trace_path) with open(trace_path) as f: json_traces = html2trace.ReadTracesFromHTMLFile(f) self.assertEqual(json_traces, [{'traceEvents': [1, 2, 3]}]) finally: shutil.rmtree(test_dir)
def testMultiplePidParsing(self): events = [ {'name': 'a', 'args': {}, 'pid': 1, 'ts': 2, 'tts': 1, 'cat': 'foo', 'tid': 1, 'ph': 'B'}, {'name': 'a', 'args': {}, 'pid': 1, 'ts': 4, 'tts': 2, 'cat': 'foo', 'tid': 1, 'ph': 'E'}, {'name': 'b', 'args': {}, 'pid': 2, 'ts': 6, 'tts': 3, 'cat': 'bar', 'tid': 2, 'ph': 'B'}, {'name': 'b', 'args': {}, 'pid': 2, 'ts': 8, 'tts': 4, 'cat': 'bar', 'tid': 2, 'ph': 'E'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) processes = m.GetAllProcesses() self.assertEqual(2, len(processes)) p = processes[0] self.assertEqual(1, p.pid) self.assertEqual(1, len(p.threads)) # Check process 1 thread 1. t = p.threads[1] self.assertEqual(1, len(t.all_slices)) self.assertEqual(1, t.tid) slice_event = t.all_slices[0] self.assertEqual('a', slice_event.name) self.assertEqual('foo', slice_event.category) self.assertAlmostEqual(0, slice_event.start) self.assertAlmostEqual((4 - 2) / 1000.0, slice_event.duration) self.assertAlmostEqual(1 / 1000.0, slice_event.thread_start) self.assertAlmostEqual((2 - 1) / 1000.0, slice_event.thread_duration) # Check process 2 thread 2. # TODO: will this be in deterministic order? p = processes[1] self.assertEqual(2, p.pid) self.assertEqual(1, len(p.threads)) t = p.threads[2] self.assertEqual(1, len(t.all_slices)) self.assertEqual(2, t.tid) slice_event = t.all_slices[0] self.assertEqual('b', slice_event.name) self.assertEqual('bar', slice_event.category) self.assertAlmostEqual((6 - 2) / 1000.0, slice_event.start) self.assertAlmostEqual((8 - 6) / 1000.0, slice_event.duration) self.assertAlmostEqual(3 / 1000.0, slice_event.thread_start) self.assertAlmostEqual((4 - 3) / 1000.0, slice_event.thread_duration) # Check getAllThreads. self.assertEqual( [processes[0].threads[1], processes[1].threads[2]], m.GetAllThreads())
def testMultiplePagesAndValues(self, cs_insert_mock): cs_insert_mock.return_value = 'https://cloud_storage_url/foo' trace_value = trace.TraceValue( None, trace_data.CreateTraceDataFromRawData('{"traceEvents": []}'), remote_path='rp', upload_bucket='foo', cloud_url='http://google.com') trace_value.UploadToCloud() self.SimulateBenchmarkRun([ (self._story_set[0], [ scalar.ScalarValue( None, 'foo', 'seconds', 4, improvement_direction=improvement_direction.DOWN) ]), (self._story_set[1], [ scalar.ScalarValue( None, 'foo', 'seconds', 3.4, improvement_direction=improvement_direction.DOWN), trace_value, scalar.ScalarValue( None, 'bar', 'km', 10, improvement_direction=improvement_direction.DOWN), scalar.ScalarValue( None, 'baz', 'count', 5, improvement_direction=improvement_direction.DOWN) ]) ]) # Parse CSV output into list of lists. csv_string = self.Format() lines = csv_string.split(self._LINE_SEPARATOR) values = [s.split(',') for s in lines[1:-1]] self.assertEquals(len(values), 5) # We expect 5 value in total. self.assertEquals(len(set((v[1] for v in values))), 2) # 2 pages. self.assertEquals(len(set((v[2] for v in values))), 4) # 4 value names. self.assertEquals(values[2], [ 'story_set', 'http://www.bar.com/', 'trace', 'http://google.com', '', '1' ])
def testSliceHierarchy(self): """The slice hierarchy should look something like this: [ a ] [ b ] [ d ] [ c ] [ e ] """ events = [ {'name': 'a', 'args': {}, 'pid': 52, 'ts': 100, 'cat': 'foo', 'tid': 53, 'ph': 'B'}, {'name': 'a', 'args': {}, 'pid': 52, 'ts': 200, 'cat': 'foo', 'tid': 53, 'ph': 'E'}, {'name': 'b', 'args': {}, 'pid': 52, 'ts': 125, 'cat': 'foo', 'tid': 53, 'ph': 'B'}, {'name': 'b', 'args': {}, 'pid': 52, 'ts': 165, 'cat': 'foo', 'tid': 53, 'ph': 'E'}, {'name': 'c', 'args': {}, 'pid': 52, 'ts': 125, 'cat': 'foo', 'tid': 53, 'ph': 'B'}, {'name': 'c', 'args': {}, 'pid': 52, 'ts': 135, 'cat': 'foo', 'tid': 53, 'ph': 'E'}, {'name': 'd', 'args': {}, 'pid': 52, 'ts': 175, 'cat': 'foo', 'tid': 53, 'ph': 'B'}, {'name': 'd', 'args': {}, 'pid': 52, 'ts': 190, 'cat': 'foo', 'tid': 53, 'ph': 'E'}, {'name': 'e', 'args': {}, 'pid': 52, 'ts': 155, 'cat': 'foo', 'tid': 53, 'ph': 'B'}, {'name': 'e', 'args': {}, 'pid': 52, 'ts': 165, 'cat': 'foo', 'tid': 53, 'ph': 'E'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data, shift_world_to_zero=False) processes = m.GetAllProcesses() self.assertEqual(1, len(processes)) p = processes[0] self.assertEqual(1, len(p.threads)) t = p.threads[53] slice_a = t.all_slices[0] self.assertEqual(4, len(slice_a.GetAllSubSlices())) self.assertEqual('a', slice_a.name) self.assertEqual(100 / 1000.0, slice_a.start) self.assertEqual(200 / 1000.0, slice_a.end) self.assertEqual(2, len(slice_a.sub_slices)) slice_b = slice_a.sub_slices[0] self.assertEqual('b', slice_b.name) self.assertEqual(2, len(slice_b.sub_slices)) self.assertEqual('c', slice_b.sub_slices[0].name) self.assertEqual('e', slice_b.sub_slices[1].name) slice_d = slice_a.sub_slices[1] self.assertEqual('d', slice_d.name) self.assertEqual(0, len(slice_d.sub_slices))
def testAsyncStepsMissingFinish(self): events = [ # Time is intentionally out of order. {'name': 'a', 'args': {'step': 's1', 'y': 2}, 'pid': 52, 'ts': 548, 'cat': 'foo', 'tid': 53, 'ph': 'T', 'id': 72}, {'name': 'a', 'args': {'z': 3}, 'pid': 52, 'ts': 560, 'cat': 'foo', 'tid': 53, 'ph': 'S', 'id': 72} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) t = m.GetAllProcesses()[0].threads[53] self.assertTrue(t is not None)
def testAsChartDictWithTraceValuesThatHasTirLabel(self): v = trace.TraceValue(self._story_set[0], trace_data.CreateTraceDataFromRawData([{'test': 1}])) v.tir_label = 'background' d = chart_json_output_formatter.ResultsAsChartDict( self._benchmark_metadata, page_specific_values=[v], summary_values=[v]) self.assertTrue('trace' in d['charts']) self.assertTrue('http://www.foo.com/' in d['charts']['trace'], msg=d['charts']['trace']) self.assertTrue(d['enabled'])
def testImportSamplesMissingArgs(self): events = [ {'name': 'a', 'pid': 52, 'ts': 548, 'cat': 'test', 'tid': 53, 'ph': 'P'}, {'name': 'b', 'pid': 52, 'ts': 548, 'cat': 'test', 'tid': 53, 'ph': 'P'}, {'name': 'c', 'pid': 52, 'ts': 549, 'cat': 'test', 'tid': 53, 'ph': 'P'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) p = m.GetAllProcesses()[0] t = p.threads[53] self.assertEqual(3, len(t.samples)) self.assertEqual(0, len(m.import_errors))
def testImportErrornousFlowEvent(self): events = [ {'name': 'a', 'cat': 'foo', 'id': 70, 'pid': 52, 'tid': 53, 'ts': 548, 'ph': 's', 'args': {}}, {'name': 'a2', 'cat': 'foo', 'id': 70, 'pid': 52, 'tid': 53, 'ts': 550, 'ph': 's', 'args': {}}, {'name': 'b', 'cat': 'foo', 'id': 73, 'pid': 52, 'tid': 53, 'ts': 570, 'ph': 'f', 'args': {}}, {'name': 'a', 'cat': 'foo', 'id': 72, 'pid': 52, 'tid': 53, 'ts': 560, 'ph': 't', 'args': {}}, ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) self.assertEqual(0, len(m.flow_events))
def testArgumentDupeCreatesNonFailingImportError(self): events = [ {'name': 'a', 'args': {'x': 1}, 'pid': 1, 'ts': 520, 'cat': 'foo', 'tid': 1, 'ph': 'B'}, {'name': 'a', 'args': {'x': 2}, 'pid': 1, 'ts': 560, 'cat': 'foo', 'tid': 1, 'ph': 'E'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) processes = m.GetAllProcesses() t = processes[0].threads[1] slice_a = FindEventNamed(t.all_slices, 'a') self.assertEqual(2, slice_a.args['x']) self.assertEqual(1, len(m.import_errors))
def testInstanceCounter(self): events = [ {'name': 'ctr', 'args': {'value': 0}, 'pid': 1, 'ts': 0, 'cat': 'foo', 'tid': 1, 'ph': 'C', 'id': 0}, {'name': 'ctr', 'args': {'value': 10}, 'pid': 1, 'ts': 10, 'cat': 'foo', 'tid': 1, 'ph': 'C', 'id': 0}, {'name': 'ctr', 'args': {'value': 10}, 'pid': 1, 'ts': 10, 'cat': 'foo', 'tid': 1, 'ph': 'C', 'id': 1}, {'name': 'ctr', 'args': {'value': 20}, 'pid': 1, 'ts': 15, 'cat': 'foo', 'tid': 1, 'ph': 'C', 'id': 1}, {'name': 'ctr', 'args': {'value': 30}, 'pid': 1, 'ts': 18, 'cat': 'foo', 'tid': 1, 'ph': 'C', 'id': 1}, {'name': 'ctr', 'args': {'value': 40}, 'pid': 1, 'ts': 20, 'cat': 'bar', 'tid': 1, 'ph': 'C', 'id': 2} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data) p = m.GetAllProcesses()[0] ctr = p.counters['foo.ctr[0]'] self.assertEqual('ctr[0]', ctr.name) self.assertEqual('foo', ctr.category) self.assertEqual(2, ctr.num_samples) self.assertEqual(1, ctr.num_series) self.assertEqual([0, 0.01], ctr.timestamps) self.assertEqual([0, 10], ctr.samples) ctr = m.GetAllProcesses()[0].counters['foo.ctr[1]'] self.assertEqual('ctr[1]', ctr.name) self.assertEqual('foo', ctr.category) self.assertEqual(3, ctr.num_samples) self.assertEqual(1, ctr.num_series) self.assertEqual([0.01, 0.015, 0.018], ctr.timestamps) self.assertEqual([10, 20, 30], ctr.samples) ctr = m.GetAllProcesses()[0].counters['bar.ctr[2]'] self.assertEqual('ctr[2]', ctr.name) self.assertEqual('bar', ctr.category) self.assertEqual(1, ctr.num_samples) self.assertEqual(1, ctr.num_series) self.assertEqual([0.02], ctr.timestamps) self.assertEqual([40], ctr.samples)
def testAutoclosingWithEventsOutsideBounds(self): events = [ # Slice that begins before min and ends after max of the other threads. {'name': 'a', 'args': {}, 'pid': 1, 'ts': 0, 'tts': 0, 'cat': 'foo', 'tid': 1, 'ph': 'B'}, {'name': 'b', 'args': {}, 'pid': 1, 'ts': 6, 'tts': 3, 'cat': 'foo', 'tid': 1, 'ph': 'B'}, # Slice that does finish to give an 'end time' to establish a basis {'name': 'c', 'args': {}, 'pid': 1, 'ts': 2, 'tts': 1, 'cat': 'bar', 'tid': 2, 'ph': 'B'}, {'name': 'c', 'args': {}, 'pid': 1, 'ts': 4, 'tts': 2, 'cat': 'bar', 'tid': 2, 'ph': 'E'} ] trace_data = trace_data_module.CreateTraceDataFromRawData(events) m = timeline_model.TimelineModel(trace_data, shift_world_to_zero=False) p = m.GetAllProcesses()[0] t1 = p.threads[1] t1_thread_time_bounds = ( m._thread_time_bounds[t1]) # pylint: disable=protected-access self.assertAlmostEqual(0.000, t1_thread_time_bounds.min) self.assertAlmostEqual(0.003, t1_thread_time_bounds.max) self.assertEqual(2, len(t1.all_slices)) slice_event = FindEventNamed(t1.all_slices, 'a') self.assertEqual('a', slice_event.name) self.assertEqual('foo', slice_event.category) self.assertAlmostEqual(0, slice_event.start) self.assertAlmostEqual(0.006, slice_event.duration) self.assertAlmostEqual(0, slice_event.thread_start) self.assertAlmostEqual(0.003, slice_event.thread_duration) t2 = p.threads[2] t2_thread_time_bounds = ( m._thread_time_bounds[t2]) # pylint: disable=protected-access self.assertAlmostEqual(0.001, t2_thread_time_bounds.min) self.assertAlmostEqual(0.002, t2_thread_time_bounds.max) slice2 = FindEventNamed(t2.all_slices, 'c') self.assertEqual('c', slice2.name) self.assertEqual('bar', slice2.category) self.assertAlmostEqual(0.002, slice2.start) self.assertAlmostEqual(0.002, slice2.duration) self.assertAlmostEqual(0.001, slice2.thread_start) self.assertAlmostEqual(0.001, slice2.thread_duration) self.assertAlmostEqual(0.000, m.bounds.min) self.assertAlmostEqual(0.006, m.bounds.max)
def testAsDictWhenTraceIsNotSerializedAndUploaded(self): test_temp_file = tempfile.NamedTemporaryFile(delete=False) try: v = trace.TraceValue(None, trace_data.CreateTraceDataFromRawData([{'test': 1}])) # pylint: disable=no-member trace.cloud_storage.SetCalculatedHashesForTesting( TestDefaultDict(123)) # pylint: enable=no-member bucket = trace.cloud_storage.PUBLIC_BUCKET cloud_url = v.UploadToCloud(bucket) d = v.AsDict() self.assertEqual(d['cloud_url'], cloud_url) finally: if os.path.exists(test_temp_file.name): test_temp_file.close() os.remove(test_temp_file.name)
def testAsDictWhenTraceSerializedAndUploaded(self): tempdir = tempfile.mkdtemp() try: v = trace.TraceValue(None, trace_data.CreateTraceDataFromRawData([{'test': 1}])) fh = v.Serialize(tempdir) # pylint: disable=no-member trace.cloud_storage.SetCalculatedHashesForTesting( {fh.GetAbsPath(): 123}) # pylint: enable=no-member bucket = trace.cloud_storage.PUBLIC_BUCKET cloud_url = v.UploadToCloud(bucket) d = v.AsDict() self.assertEqual(d['file_id'], fh.id) self.assertEqual(d['cloud_url'], cloud_url) finally: shutil.rmtree(tempdir)