Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(4953)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/resources/tracing/timeline_model_test.html

Issue 8342069: Add unit tests for about:tracing TimelineModel. (Closed) Base URL: http://git.chromium.org/chromium/src.git@master
Patch Set: Just use jstest for now. Created 9 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« chrome/browser/resources/tracing/timeline_model.js ('K') | « chrome/browser/resources/tracing/timeline_model.js ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/resources/tracing/timeline_model_test.html
diff --git a/chrome/browser/resources/tracing/timeline_model_test.html b/chrome/browser/resources/tracing/timeline_model_test.html
new file mode 100644
index 0000000000000000000000000000000000000000..4a1c58d3caf55839862fa48414ad7a4c112a2a88
--- /dev/null
+++ b/chrome/browser/resources/tracing/timeline_model_test.html
@@ -0,0 +1,295 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright (c) 2010 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></title>
+<script src="http://closure-library.googlecode.com/svn/trunk/closure/goog/base.js"></script>
+<script src="../shared/js/cr.js"></script>
+<script src="../shared/js/cr/event_target.js"></script>
+<script src="timeline_model.js"></script>
+<script>
+ goog.require('goog.testing.jsunit');
+</script>
+
+</head>
+<body>
+<script>
+function testBasicSingleThreadNonnestedParsing() {
+ var events = [
+ {'name':'a','args':{},'pid':52,'ts':9524,'cat':'foo','tid':53,'ph':'B'},
arv (Not doing code reviews) 2011/10/21 17:09:18 space after :
nduca 2011/10/21 19:50:40 Done.
+ {'name':'a','args':{},'pid':52,'ts':9560,'cat':'foo','tid':53,'ph':'E'},
+ {'name':'b','args':{},'pid':52,'ts':9629,'cat':'foo','tid':53,'ph':'B'},
+ {'name':'b','args':{},'pid':52,'ts':9631,'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.subRows.length);
+ assertEquals(53, t.tid);
+ var subRow = t.subRows[0];
+ assertEquals(2, subRow.length);
+ var slice = subRow[0];
+ assertEquals('a', slice.title);
+ assertEquals(0, slice.start);
+ assertEquals((9560 - 9524) / 1000, slice.duration);
+ assertEquals(0, slice.subSlices.length);
+
+ slice = subRow[1];
+ assertEquals('b', slice.title);
+ assertEquals((9629-9524) / 1000, slice.start);
+ assertEquals((9631 - 9629) / 1000, slice.duration);
+ assertEquals(0, slice.subSlices.length);
+}
+
+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':'foo','tid':1,'ph':'B'},
+ {'name':'b','args':{},'pid':1,'ts':3,'cat':'foo','tid':1,'ph':'E'},
+ {'name':'a','args':{},'pid':1,'ts':4,'cat':'foo','tid':1,'ph':'E'},
+ ];
+ var m = new tracing.TimelineModel(events);
+ var p = m.processes[1];
+ var t = p.threads[1];
+ assertEquals(2, t.subRows.length);
+ var subRow = t.subRows[0];
+ assertEquals(1, subRow.length);
+ var slice = subRow[0];
+ assertEquals('a', slice.title);
+ assertEquals((4-1) / 1000, slice.duration);
arv (Not doing code reviews) 2011/10/21 17:09:18 whitespace
nduca 2011/10/21 19:50:40 Done.
+ assertEquals(1, slice.subSlices.length);
+
+ slice = slice.subSlices[0];
+ assertEquals('b', slice.title);
+ assertEquals((2-1) / 1000, slice.start);
+ assertEquals((3-2) / 1000, slice.duration);
+ assertEquals(0, slice.subSlices.length);
+
+ subRow = t.subRows[1];
+ slice = subRow[0];
+ assertEquals(t.subRows[0][0].subSlices[0], slice);
+}
+
+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':'foo','tid':2,'ph':'B'},
+ {'name':'b','args':{},'pid':1,'ts':2,'cat':'foo','tid':2,'ph':'E'},
+ ];
+ var m = new tracing.TimelineModel(events);
+ var p = m.processes[1];
+ var t = p.threads[1];
+ var subRow = t.subRows[0];
+ var slice = subRow[0];
+ assertEquals('a', slice.title);
+ assertTrue(slice.didNotFinish);
+ assertEquals(0, slice.start);
+ assertEquals((2-1) / 1000, slice.duration);
+}
+
+
+function testNestedAutoclosing() {
+ var events = [
+ // Tasks that dont 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);
+ var p = m.processes[1];
+ var t = p.threads[1];
+ var subRow = t.subRows[0];
+ var slice = subRow[0];
+ assertEquals('a1', slice.title);
+ assertTrue(slice.didNotFinish);
+ assertEquals(0, slice.start);
+ assertEquals((2-1) / 1000, slice.duration);
+
+ var slice = slice.subSlices[0];
+ assertEquals('a2', slice.title);
+ assertTrue(slice.didNotFinish);
+ assertEquals((1.5-1) / 1000, slice.start);
+ assertEquals((2-1.5) / 1000, slice.duration);
+}
+
+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':'foo','tid':1,'ph':'B'},
+ {'name':'b','args':{},'pid':1,'ts':4,'cat':'foo','tid':1,'ph':'E'},
+ {'name':'a','args':{},'pid':1,'ts':5,'cat':'foo','tid':1,'ph':'B'},
+ {'name':'a','args':{},'pid':1,'ts':6,'cat':'foo','tid':1,'ph':'E'},
+ ];
+ var m = new tracing.TimelineModel(events);
+ var p = m.processes[1];
+ var t = p.threads[1];
+ var subRow = t.subRows[0];
+ var a1 = subRow[0];
+ assertEquals('a', a1.title);
+ var b = subRow[1];
+ assertEquals('b', b.title);
+ assertNotEquals(a1.colorId, b.colorId);
+ var a2 = subRow[0];
+ assertEquals('a', a2.title);
+ 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':'foo','tid':2,'ph':'B'},
+ {'name':'b','args':{},'pid':1,'ts':4,'cat':'foo','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.subRows.length);
+ assertEquals(1, t.tid);
+
+ var subRow = t.subRows[0];
+ assertEquals(1, subRow.length);
+ var slice = subRow[0];
+ assertEquals('a', slice.title);
+ 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.subRows.length);
+ assertEquals(2, t.tid);
+
+ subRow = t.subRows[0];
+ assertEquals(1, subRow.length);
+ slice = subRow[0];
+ assertEquals('b', slice.title);
+ 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':'foo','tid':2,'ph':'B'},
+ {'name':'b','args':{},'pid':2,'ts':4,'cat':'foo','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.subRows.length);
+ assertEquals(1, t.tid);
+
+ var subRow = t.subRows[0];
+ assertEquals(1, subRow.length);
+ var slice = subRow[0];
+ assertEquals('a', slice.title);
+ 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.subRows.length);
+ assertEquals(2, t.tid);
+
+ subRow = t.subRows[0];
+ assertEquals(1, subRow.length);
+ slice = subRow[0];
+ assertEquals('b', slice.title);
+ 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 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':'foo','tid':1,'ph':'I'},
+ {'name':'a','args':{},'pid':1,'ts':4,'cat':'foo','tid':1,'ph':'E'},
+ ];
+ var m = new tracing.TimelineModel(events);
+ var p = m.processes[1];
+ var t = p.threads[1];
+ assertEquals(2, t.subRows.length);
+ var subRow = t.subRows[0];
+ assertEquals(1, subRow.length);
+ var slice = subRow[0];
+ assertEquals('a', slice.title);
+ assertEquals((4-1) / 1000, slice.duration);
+ assertEquals(1, slice.subSlices.length);
+
+ var immed = slice.subSlices[0];
+ assertEquals('immediate', immed.title);
+ assertEquals((2-1) / 1000, immed.start);
+ assertEquals(0, immed.duration);
+ assertEquals(0, immed.subSlices.length);
+
+ subRow = t.subRows[1];
+ assertEquals(immed, subRow[0]);
+}
+</script>
+</body>
+</html>
« chrome/browser/resources/tracing/timeline_model.js ('K') | « chrome/browser/resources/tracing/timeline_model.js ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698