| <!DOCTYPE html> |
| <html> |
| <!-- |
| Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| Use of this source code is governed by a BSD-style license that can be |
| found in the LICENSE file. |
| --> |
| <head> |
| <title>TraceEventImporter tests</title> |
| <script src="base.js"></script> |
| <script> |
| base.require('unittest'); |
| base.require('test_utils'); |
| base.require('trace_event_importer'); |
| </script> |
| </head> |
| <body> |
| <script> |
| 'use strict'; |
| |
| var findSliceNamed = test_utils.findSliceNamed; |
| |
| function testCanImportEmpty() { |
| self.assertFalse(tracing.TraceEventImporter.canImport([])); |
| self.assertFalse(tracing.TraceEventImporter.canImport('')); |
| } |
| |
| function testBasicSingleThreadNonnestedParsing() { |
| var events = [ |
| {name: 'a', args: {}, pid: 52, ts: 520, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'}, |
| {name: 'b', args: {}, pid: 52, ts: 629, cat: 'bar', tid: 53, ph: 'B'}, |
| {name: 'b', args: {}, pid: 52, ts: 631, cat: 'bar', tid: 53, ph: 'E'} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| assertEquals(1, m.numProcesses); |
| var p = m.processes[52]; |
| assertNotUndefined(p); |
| |
| assertEquals(1, p.numThreads); |
| var t = p.threads[53]; |
| assertNotUndefined(t); |
| assertEquals(2, t.slices.length); |
| assertEquals(53, t.tid); |
| var slice = t.slices[0]; |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertEquals(0, slice.start); |
| assertAlmostEquals((560 - 520) / 1000, slice.duration); |
| assertEquals(0, slice.subSlices.length); |
| |
| slice = t.slices[1]; |
| assertEquals('b', slice.title); |
| assertEquals('bar', slice.category); |
| assertAlmostEquals((629 - 520) / 1000, slice.start); |
| assertAlmostEquals((631 - 629) / 1000, slice.duration); |
| assertEquals(0, slice.subSlices.length); |
| } |
| |
| function testArgumentDupeCreatesNonFailingImportError() { |
| var 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'} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| var t = m.processes[1].threads[1]; |
| var sA = findSliceNamed(t.slices, 'a'); |
| |
| assertEquals(2, sA.args.x); |
| assertEquals(m.importErrors.length, 1); |
| } |
| |
| function testCategoryBeginEndMismatchPrefersBegin() { |
| var events = [ |
| {name: 'a', args: {}, pid: 52, ts: 520, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'bar', tid: 53, ph: 'E'} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| assertEquals(1, m.numProcesses); |
| var p = m.processes[52]; |
| assertNotUndefined(p); |
| |
| assertEquals(1, p.numThreads); |
| var t = p.threads[53]; |
| assertNotUndefined(t); |
| assertEquals(1, t.slices.length); |
| assertEquals(53, t.tid); |
| var slice = t.slices[0]; |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| } |
| |
| function testNestedParsing() { |
| var events = [ |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'b', args: {}, pid: 1, ts: 2, cat: 'bar', tid: 1, ph: 'B'}, |
| {name: 'b', args: {}, pid: 1, ts: 3, cat: 'bar', tid: 1, ph: 'E'}, |
| {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events, false); |
| var t = m.processes[1].threads[1]; |
| |
| var sA = findSliceNamed(t.slices, 'a'); |
| var sB = findSliceNamed(t.slices, 'b'); |
| |
| assertEquals('a', sA.title); |
| assertEquals('foo', sA.category); |
| assertEquals(0.001, sA.start); |
| assertEquals(0.003, sA.duration); |
| |
| assertEquals('b', sB.title); |
| assertEquals('bar', sB.category); |
| assertEquals(0.002, sB.start); |
| assertEquals(0.001, sB.duration); |
| } |
| |
| function testAutoclosing() { |
| var events = [ |
| // Slice that doesn't finish. |
| {name: 'a', args: {}, pid: 1, ts: 1, 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: 'bar', tid: 2, ph: 'B'}, |
| {name: 'b', args: {}, pid: 1, ts: 2, cat: 'bar', tid: 2, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| var p = m.processes[1]; |
| var t = p.threads[1]; |
| var slice = t.slices[0]; |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertTrue(slice.didNotFinish); |
| assertEquals(0, slice.start); |
| assertEquals((2 - 1) / 1000, slice.duration); |
| } |
| |
| function testAutoclosingLoneBegin() { |
| var events = [ |
| // Slice that doesn't finish. |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| var p = m.processes[1]; |
| var t = p.threads[1]; |
| var slice = t.slices[0]; |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertTrue(slice.didNotFinish); |
| assertEquals(0, slice.start); |
| assertEquals(0, slice.duration); |
| } |
| |
| function testAutoclosingWithSubTasks() { |
| var events = [ |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'b1', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'b1', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 1, ph: 'E'}, |
| {name: 'b2', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 1, ph: 'B'} |
| ]; |
| var m = new tracing.TimelineModel(events, false); |
| var t = m.processes[1].threads[1]; |
| |
| var sA = findSliceNamed(t.slices, 'a'); |
| var sB1 = findSliceNamed(t.slices, 'b1'); |
| var sB2 = findSliceNamed(t.slices, 'b2'); |
| |
| assertEquals(0.003, sA.end); |
| assertEquals(0.003, sB1.end); |
| assertEquals(0.003, sB2.end); |
| } |
| |
| function testAutoclosingWithEventsOutsideRange() { |
| var events = [ |
| // Slice that begins before min and ends after max of the other threads. |
| {name: 'a', args: {}, pid: 1, ts: 0, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'b', args: {}, pid: 1, ts: 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: 1, cat: 'bar', tid: 2, ph: 'B'}, |
| {name: 'c', args: {}, pid: 1, ts: 2, cat: 'bar', tid: 2, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events, false); |
| var p = m.processes[1]; |
| var t = p.threads[1]; |
| assertEquals(2, t.slices.length); |
| |
| var slice = findSliceNamed(t.slices, 'a'); |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertEquals(0, slice.start); |
| assertEquals(0.003, slice.duration); |
| |
| var t2 = p.threads[2]; |
| var slice2 = findSliceNamed(t2.slices, 'c'); |
| assertEquals('c', slice2.title); |
| assertEquals('bar', slice2.category); |
| assertEquals(0.001, slice2.start); |
| assertEquals(0.001, slice2.duration); |
| |
| assertEquals(0.000, m.minTimestamp); |
| assertEquals(0.003, m.maxTimestamp); |
| } |
| |
| function testNestedAutoclosing() { |
| var 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'} |
| ]; |
| var m = new tracing.TimelineModel(events, false); |
| var t1 = m.processes[1].threads[1]; |
| var t2 = m.processes[1].threads[2]; |
| |
| var sA1 = findSliceNamed(t1.slices, 'a1'); |
| var sA2 = findSliceNamed(t1.slices, 'a2'); |
| var sB = findSliceNamed(t2.slices, 'b'); |
| |
| assertEquals(0.002, sA1.end); |
| assertEquals(0.002, sA2.end); |
| } |
| |
| function testTaskColoring() { |
| // The test below depends on hashing of 'a' != 'b'. Fail early if that |
| // assumption is incorrect. |
| assertNotEquals(tracing.getStringHash('a'), tracing.getStringHash('b')); |
| |
| var events = [ |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, |
| {name: 'b', args: {}, pid: 1, ts: 3, cat: 'bar', tid: 1, ph: 'B'}, |
| {name: 'b', args: {}, pid: 1, ts: 4, cat: 'bar', tid: 1, ph: 'E'}, |
| {name: 'a', args: {}, pid: 1, ts: 5, cat: 'baz', tid: 1, ph: 'B'}, |
| {name: 'a', args: {}, pid: 1, ts: 6, cat: 'baz', tid: 1, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| var p = m.processes[1]; |
| var t = p.threads[1]; |
| var a1 = t.slices[0]; |
| assertEquals('a', a1.title); |
| assertEquals('foo', a1.category); |
| var b = t.slices[1]; |
| assertEquals('b', b.title); |
| assertEquals('bar', b.category); |
| assertNotEquals(a1.colorId, b.colorId); |
| var a2 = t.slices[2]; |
| assertEquals('a', a2.title); |
| assertEquals('baz', a2.category); |
| assertEquals(a1.colorId, a2.colorId); |
| } |
| |
| function testMultipleThreadParsing() { |
| var events = [ |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, |
| {name: 'b', args: {}, pid: 1, ts: 3, cat: 'bar', tid: 2, ph: 'B'}, |
| {name: 'b', args: {}, pid: 1, ts: 4, cat: 'bar', tid: 2, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| assertEquals(1, m.numProcesses); |
| var p = m.processes[1]; |
| assertNotUndefined(p); |
| |
| assertEquals(2, p.numThreads); |
| |
| // Check thread 1. |
| var t = p.threads[1]; |
| assertNotUndefined(t); |
| assertEquals(1, t.slices.length); |
| assertEquals(1, t.tid); |
| |
| var slice = t.slices[0]; |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertEquals(0, slice.start); |
| assertEquals((2 - 1) / 1000, slice.duration); |
| assertEquals(0, slice.subSlices.length); |
| |
| // Check thread 2. |
| var t = p.threads[2]; |
| assertNotUndefined(t); |
| assertEquals(1, t.slices.length); |
| assertEquals(2, t.tid); |
| |
| slice = t.slices[0]; |
| assertEquals('b', slice.title); |
| assertEquals('bar', slice.category); |
| assertEquals((3 - 1) / 1000, slice.start); |
| assertEquals((4 - 3) / 1000, slice.duration); |
| assertEquals(0, slice.subSlices.length); |
| } |
| |
| function testMultiplePidParsing() { |
| var events = [ |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, |
| {name: 'b', args: {}, pid: 2, ts: 3, cat: 'bar', tid: 2, ph: 'B'}, |
| {name: 'b', args: {}, pid: 2, ts: 4, cat: 'bar', tid: 2, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| assertEquals(2, m.numProcesses); |
| var p = m.processes[1]; |
| assertNotUndefined(p); |
| |
| assertEquals(1, p.numThreads); |
| |
| // Check process 1 thread 1. |
| var t = p.threads[1]; |
| assertNotUndefined(t); |
| assertEquals(1, t.slices.length); |
| assertEquals(1, t.tid); |
| |
| var slice = t.slices[0]; |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertEquals(0, slice.start); |
| assertEquals((2 - 1) / 1000, slice.duration); |
| assertEquals(0, slice.subSlices.length); |
| |
| // Check process 2 thread 2. |
| var p = m.processes[2]; |
| assertNotUndefined(p); |
| assertEquals(1, p.numThreads); |
| var t = p.threads[2]; |
| assertNotUndefined(t); |
| assertEquals(1, t.slices.length); |
| assertEquals(2, t.tid); |
| |
| slice = t.slices[0]; |
| assertEquals('b', slice.title); |
| assertEquals('bar', slice.category); |
| assertEquals((3 - 1) / 1000, slice.start); |
| assertEquals((4 - 3) / 1000, slice.duration); |
| assertEquals(0, slice.subSlices.length); |
| |
| // Check getAllThreads. |
| assertArrayEquals([m.processes[1].threads[1], m.processes[2].threads[2]], |
| m.getAllThreads()); |
| } |
| |
| // Thread names. |
| function testThreadNames() { |
| var events = [ |
| {name: 'thread_name', args: {name: 'Thread 1'}, |
| pid: 1, ts: 0, tid: 1, ph: 'M'}, |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, |
| {name: 'b', args: {}, pid: 2, ts: 3, cat: 'foo', tid: 2, ph: 'B'}, |
| {name: 'b', args: {}, pid: 2, ts: 4, cat: 'foo', tid: 2, ph: 'E'}, |
| {name: 'thread_name', args: {name: 'Thread 2'}, |
| pid: 2, ts: 0, tid: 2, ph: 'M'} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| assertEquals('Thread 1', m.processes[1].threads[1].name); |
| assertEquals('Thread 2', m.processes[2].threads[2].name); |
| } |
| |
| function testParsingWhenEndComesFirst() { |
| var events = [ |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'E'}, |
| {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'a', args: {}, pid: 1, ts: 5, cat: 'foo', tid: 1, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events, false); |
| var p = m.processes[1]; |
| var t = p.threads[1]; |
| assertEquals(1, t.slices.length); |
| assertEquals('a', t.slices[0].title); |
| assertEquals('foo', t.slices[0].category); |
| assertEquals(0.004, t.slices[0].start); |
| assertEquals(0.001, t.slices[0].duration); |
| assertEquals(1, m.importErrors.length); |
| } |
| |
| function testImmediateParsing() { |
| var events = [ |
| // Need to include immediates inside a task so the timeline |
| // recentering/zeroing doesn't clobber their timestamp. |
| {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| {name: 'immediate', args: {}, pid: 1, ts: 2, cat: 'bar', tid: 1, ph: 'I'}, |
| {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'} |
| ]; |
| var m = new tracing.TimelineModel(events, false); |
| var p = m.processes[1]; |
| var t = p.threads[1]; |
| assertEquals(2, t.slices.length); |
| assertEquals(0.002, t.slices[0].start); |
| assertEquals(0, t.slices[0].duration); |
| assertEquals(0.001, t.slices[1].start); |
| assertEquals(0.003, t.slices[1].duration); |
| |
| assertEquals(2, t.slices.length); |
| var slice = findSliceNamed(t.slices, 'a'); |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertEquals(0.003, slice.duration); |
| |
| var immed = findSliceNamed(t.slices, 'immediate'); |
| assertEquals('immediate', immed.title); |
| assertEquals('bar', immed.category); |
| assertEquals(0.002, immed.start); |
| assertEquals(0, immed.duration); |
| assertEquals(0, immed.subSlices.length); |
| } |
| |
| function testSimpleCounter() { |
| var events = [ |
| {name: 'ctr', args: {'value': 0}, pid: 1, ts: 0, cat: 'foo', tid: 1, |
| ph: 'C'}, |
| {name: 'ctr', args: {'value': 10}, pid: 1, ts: 10, cat: 'foo', tid: 1, |
| ph: 'C'}, |
| {name: 'ctr', args: {'value': 0}, pid: 1, ts: 20, cat: 'foo', tid: 1, |
| ph: 'C'} |
| |
| ]; |
| var m = new tracing.TimelineModel(events); |
| var p = m.processes[1]; |
| var ctr = m.processes[1].counters['foo.ctr']; |
| |
| assertEquals('ctr', ctr.name); |
| assertEquals('foo', ctr.category); |
| assertEquals(3, ctr.numSamples); |
| assertEquals(1, ctr.numSeries); |
| |
| assertArrayEquals(['value'], ctr.seriesNames); |
| assertArrayEquals([tracing.getStringColorId('ctr.value')], ctr.seriesColors); |
| assertArrayEquals([0, 0.01, 0.02], ctr.timestamps); |
| assertArrayEquals([0, 10, 0], ctr.samples); |
| assertArrayEquals([0, 10, 0], ctr.totals); |
| assertEquals(10, ctr.maxTotal); |
| } |
| |
| function testInstanceCounter() { |
| var 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} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| var p = m.processes[1]; |
| var ctr = m.processes[1].counters['foo.ctr[0]']; |
| assertEquals('ctr[0]', ctr.name); |
| assertEquals('foo', ctr.category); |
| assertEquals(2, ctr.numSamples); |
| assertEquals(1, ctr.numSeries); |
| assertArrayEquals([0, 0.01], ctr.timestamps); |
| assertArrayEquals([0, 10], ctr.samples); |
| |
| var ctr = m.processes[1].counters['foo.ctr[1]']; |
| assertEquals('ctr[1]', ctr.name); |
| assertEquals('foo', ctr.category); |
| assertEquals(3, ctr.numSamples); |
| assertEquals(1, ctr.numSeries); |
| assertArrayEquals([0.01, 0.015, 0.018], ctr.timestamps); |
| assertArrayEquals([10, 20, 30], ctr.samples); |
| |
| var ctr = m.processes[1].counters['bar.ctr[2]']; |
| assertEquals('ctr[2]', ctr.name); |
| assertEquals('bar', ctr.category); |
| assertEquals(1, ctr.numSamples); |
| assertEquals(1, ctr.numSeries); |
| assertArrayEquals([0.02], ctr.timestamps); |
| assertArrayEquals([40], ctr.samples); |
| } |
| |
| function testMultiCounterUpdateBounds() { |
| var ctr = new tracing.TimelineCounter(undefined, 'testBasicCounter', |
| '', 'testBasicCounter'); |
| ctr.seriesNames = ['value1', 'value2']; |
| ctr.seriesColors = ['testBasicCounter.value1', 'testBasicCounter.value2']; |
| ctr.timestamps = [0, 1, 2, 3, 4, 5, 6, 7]; |
| ctr.samples = [0, 0, |
| 1, 0, |
| 1, 1, |
| 2, 1.1, |
| 3, 0, |
| 1, 7, |
| 3, 0, |
| 3.1, 0.5]; |
| ctr.updateBounds(); |
| assertEquals(0, ctr.minTimestamp); |
| assertEquals(7, ctr.maxTimestamp); |
| assertEquals(8, ctr.maxTotal); |
| assertArrayEquals([0, 0, |
| 1, 1, |
| 1, 2, |
| 2, 3.1, |
| 3, 3, |
| 1, 8, |
| 3, 3, |
| 3.1, 3.6], ctr.totals); |
| } |
| |
| function testMultiCounter() { |
| var 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'} |
| ]; |
| var m = new tracing.TimelineModel(events); |
| var p = m.processes[1]; |
| var ctr = m.processes[1].counters['foo.ctr']; |
| assertEquals('ctr', ctr.name); |
| |
| assertEquals('ctr', ctr.name); |
| assertEquals('foo', ctr.category); |
| assertEquals(3, ctr.numSamples); |
| assertEquals(2, ctr.numSeries); |
| |
| assertArrayEquals(['value1', 'value2'], ctr.seriesNames); |
| assertArrayEquals([tracing.getStringColorId('ctr.value1'), |
| tracing.getStringColorId('ctr.value2')], |
| ctr.seriesColors); |
| assertArrayEquals([0, 0.01, 0.02], ctr.timestamps); |
| assertArrayEquals([0, 7, |
| 10, 4, |
| 0, 1], ctr.samples); |
| assertArrayEquals([0, 7, |
| 10, 14, |
| 0, 1], ctr.totals); |
| assertEquals(14, ctr.maxTotal); |
| } |
| |
| function testImportObjectInsteadOfArray() { |
| var events = { traceEvents: [ |
| {name: 'a', args: {}, pid: 52, ts: 524, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'} |
| ] }; |
| |
| var m = new tracing.TimelineModel(events); |
| assertEquals(1, m.numProcesses); |
| } |
| |
| function testImportString() { |
| var events = [ |
| {name: 'a', args: {}, pid: 52, ts: 524, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| |
| var m = new tracing.TimelineModel(JSON.stringify(events)); |
| assertEquals(1, m.numProcesses); |
| } |
| |
| function testImportStringWithTrailingNewLine() { |
| var events = [ |
| {name: 'a', args: {}, pid: 52, ts: 524, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| |
| var m = new tracing.TimelineModel(JSON.stringify(events) + '\n'); |
| assertEquals(1, m.numProcesses); |
| } |
| |
| function testImportStringWithMissingCloseSquareBracket() { |
| var events = [ |
| {name: 'a', args: {}, pid: 52, ts: 524, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| |
| var tmp = JSON.stringify(events); |
| assertEquals(']', tmp[tmp.length - 1]); |
| |
| // Drop off the trailing ] |
| var dropped = tmp.substring(0, tmp.length - 1); |
| var m = new tracing.TimelineModel(dropped); |
| assertEquals(1, m.numProcesses); |
| } |
| |
| function testImportStringWithEndingCommaButMissingCloseSquareBracket() { |
| var lines = [ |
| '[', |
| '{"name": "a", "args": {}, "pid": 52, "ts": 524, "cat": "foo", "tid": 53, "ph": "B"},', |
| '{"name": "a", "args": {}, "pid": 52, "ts": 560, "cat": "foo", "tid": 53, "ph": "E"},' |
| ] |
| var text = lines.join('\n'); |
| |
| var m = new tracing.TimelineModel(text); |
| assertEquals(1, m.numProcesses); |
| assertEquals(1, m.processes[52].threads[53].slices.length); |
| } |
| |
| function testImportStringWithMissingCloseSquareBracketAndNewline() { |
| var events = [ |
| {name: 'a', args: {}, pid: 52, ts: 524, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| |
| var tmp = JSON.stringify(events); |
| assertEquals(']', tmp[tmp.length - 1]); |
| |
| // Drop off the trailing ] and add a newline |
| var dropped = tmp.substring(0, tmp.length - 1); |
| var m = new tracing.TimelineModel(dropped + '\n'); |
| assertEquals(1, m.numProcesses); |
| } |
| |
| function testImportStringWithEndingCommaButMissingCloseSquareBracketCRLF() { |
| var lines = [ |
| '[', |
| '{"name": "a", "args": {}, "pid": 52, "ts": 524, "cat": "foo", "tid": 53, "ph": "B"},', |
| '{"name": "a", "args": {}, "pid": 52, "ts": 560, "cat": "foo", "tid": 53, "ph": "E"},' |
| ] |
| var text = lines.join('\r\n'); |
| |
| var m = new tracing.TimelineModel(text); |
| assertEquals(1, m.numProcesses); |
| assertEquals(1, m.processes[52].threads[53].slices.length); |
| } |
| |
| function testStartFinishOneSliceOneThread() { |
| var 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'}} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| var t = m.processes[52].threads[53]; |
| assertNotUndefined(t); |
| assertEquals(1, t.asyncSlices.slices.length); |
| assertEquals('a', t.asyncSlices.slices[0].title); |
| assertEquals('cat', t.asyncSlices.slices[0].category); |
| assertEquals(72, t.asyncSlices.slices[0].id); |
| assertEquals('bar', t.asyncSlices.slices[0].args.foo); |
| assertEquals(0, t.asyncSlices.slices[0].start); |
| assertAlmostEquals((60 - 24) / 1000, t.asyncSlices.slices[0].duration); |
| assertEquals(t, t.asyncSlices.slices[0].startThread); |
| assertEquals(t, t.asyncSlices.slices[0].endThread); |
| } |
| |
| function testEndArgsAddedToSlice() { |
| var events = [ |
| {name: 'a', args: {x: 1}, pid: 52, ts: 520, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {y: 2}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| assertEquals(1, m.numProcesses); |
| var p = m.processes[52]; |
| assertNotUndefined(p); |
| |
| assertEquals(1, p.numThreads); |
| var t = p.threads[53]; |
| assertNotUndefined(t); |
| assertEquals(1, t.slices.length); |
| assertEquals(53, t.tid); |
| var slice = t.slices[0]; |
| assertEquals('a', slice.title); |
| assertEquals('foo', slice.category); |
| assertEquals(0, slice.start); |
| assertEquals(0, slice.subSlices.length); |
| assertEquals(1, slice.args['x']); |
| assertEquals(2, slice.args['y']); |
| } |
| |
| function testEndArgOverrwritesOriginalArgValueIfDuplicated() { |
| var events = [ |
| {name: 'b', args: {z: 3}, pid: 52, ts: 629, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'b', args: {z: 4}, pid: 52, ts: 631, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| assertEquals(1, m.numProcesses); |
| var p = m.processes[52]; |
| assertNotUndefined(p); |
| |
| assertEquals(1, p.numThreads); |
| var t = p.threads[53]; |
| assertNotUndefined(t); |
| var slice = t.slices[0]; |
| assertEquals('b', slice.title); |
| assertEquals('foo', slice.category); |
| assertEquals(0, slice.start); |
| assertEquals(0, slice.subSlices.length); |
| assertEquals(4, slice.args['z']); |
| } |
| |
| function testAsyncEndArgsAddedToSlice() { |
| var events = [ |
| // Time is intentionally out of order. |
| {name: 'c', args: {y: 2}, pid: 52, ts: 560, cat: 'foo', tid: 53, |
| ph: 'F', id: 72}, |
| {name: 'c', args: {x: 1}, pid: 52, ts: 524, cat: 'foo', tid: 53, |
| ph: 'S', id: 72} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| var t = m.processes[52].threads[53]; |
| assertNotUndefined(t); |
| assertEquals(1, t.asyncSlices.slices.length); |
| var parentSlice = t.asyncSlices.slices[0]; |
| assertEquals('c', parentSlice.title); |
| assertEquals('foo', parentSlice.category); |
| |
| assertNotUndefined(parentSlice.subSlices); |
| assertEquals(1, parentSlice.subSlices.length); |
| var subSlice = parentSlice.subSlices[0]; |
| assertEquals(1, subSlice.args['x']); |
| assertEquals(2, subSlice.args['y']); |
| } |
| |
| function testAsyncEndArgOverrwritesOriginalArgValueIfDuplicated() { |
| var events = [ |
| // Time is intentionally out of order. |
| {name: 'd', args: {z: 4}, pid: 52, ts: 560, cat: 'foo', tid: 53, |
| ph: 'F', id: 72}, |
| {name: 'd', args: {z: 3}, pid: 52, ts: 524, cat: 'foo', tid: 53, |
| ph: 'S', id: 72} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| var t = m.processes[52].threads[53]; |
| assertNotUndefined(t); |
| assertEquals(1, t.asyncSlices.slices.length); |
| var parentSlice = t.asyncSlices.slices[0]; |
| assertEquals('d', parentSlice.title); |
| assertEquals('foo', parentSlice.category); |
| |
| assertNotUndefined(parentSlice.subSlices); |
| assertEquals(1, parentSlice.subSlices.length); |
| var subSlice = parentSlice.subSlices[0]; |
| assertEquals(4, subSlice.args['z']); |
| } |
| |
| function testAsyncStepsInOneThread() { |
| var events = [ |
| // Time is intentionally out of order. |
| {name: 'a', args: {z: 3}, pid: 52, ts: 560, cat: 'foo', tid: 53, |
| ph: 'F', id: 72}, |
| {name: 'a', args: {step: 's1', y: 2}, pid: 52, ts: 548, cat: 'foo', tid: 53, |
| ph: 'T', id: 72}, |
| {name: 'a', args: {x: 1}, pid: 52, ts: 524, cat: 'foo', tid: 53, |
| ph: 'S', id: 72} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| var t = m.processes[52].threads[53]; |
| assertNotUndefined(t); |
| assertEquals(1, t.asyncSlices.slices.length); |
| var parentSlice = t.asyncSlices.slices[0]; |
| assertEquals('a', parentSlice.title); |
| assertEquals('foo', parentSlice.category); |
| assertEquals(0, parentSlice.start); |
| |
| assertNotUndefined(parentSlice.subSlices); |
| assertEquals(2, parentSlice.subSlices.length); |
| var subSlice = parentSlice.subSlices[0]; |
| assertEquals('a', subSlice.title); |
| assertEquals('foo', subSlice.category); |
| assertEquals(0, subSlice.start); |
| assertAlmostEquals((548 - 524) / 1000, subSlice.duration); |
| assertEquals(1, subSlice.args['x']); |
| |
| var subSlice = parentSlice.subSlices[1]; |
| assertEquals('a:s1', subSlice.title); |
| assertEquals('foo', subSlice.category); |
| assertAlmostEquals((548 - 524) / 1000, subSlice.start); |
| assertAlmostEquals((560 - 548) / 1000, subSlice.duration); |
| assertEquals(2, subSlice.args['y']); |
| assertEquals(3, subSlice.args['z']); |
| } |
| |
| function testAsyncStepsMissingStart() { |
| var events = [ |
| // Time is intentionally out of order. |
| {name: 'a', args: {z: 3}, pid: 52, ts: 560, cat: 'foo', tid: 53, |
| ph: 'F', id: 72}, |
| {name: 'a', args: {step: 's1', y: 2}, pid: 52, ts: 548, cat: 'foo', tid: 53, |
| ph: 'T', id: 72} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| var t = m.processes[52].threads[53]; |
| assertUndefined(t); |
| } |
| |
| function testAsyncStepsMissingFinish() { |
| var 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} |
| ]; |
| |
| var m = new tracing.TimelineModel(events); |
| var t = m.processes[52].threads[53]; |
| assertUndefined(t); |
| } |
| |
| // TODO(nduca): one slice, two threads |
| // TODO(nduca): one slice, two pids |
| </script> |
| </body> |
| </html> |
