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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/browser/resources/tracing/timeline_model_test.html

Issue 8513009: Add TRACE_COUNTER support to about:tracing (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 9 years, 1 month 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 unified diff | Download patch | Annotate | Revision Log
« chrome/browser/resources/tracing/timeline_model.js ('K') | « chrome/browser/resources/tracing/timeline_model.js ('k') | chrome/browser/resources/tracing/timeline_test.html » ('j') | chrome/browser/resources/tracing/timeline_test.html » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 <!DOCTYPE html> 1 <!DOCTYPE html>
2 <html> 2 <html>
3 <!-- 3 <!--
4 Copyright (c) 2010 The Chromium Authors. All rights reserved. 4 Copyright (c) 2010 The Chromium Authors. All rights reserved.
5 Use of this source code is governed by a BSD-style license that can be 5 Use of this source code is governed by a BSD-style license that can be
6 found in the LICENSE file. 6 found in the LICENSE file.
7 --> 7 -->
8 <head> 8 <head>
9 <title></title> 9 <title>TimelineModel tests</title>
10 <script src="http://closure-library.googlecode.com/svn/trunk/closure/goog/base.j s"></script> 10 <script src="http://closure-library.googlecode.com/svn/trunk/closure/goog/base.j s"></script>
11 <script src="../shared/js/cr.js"></script> 11 <script src="../shared/js/cr.js"></script>
12 <script src="../shared/js/cr/event_target.js"></script> 12 <script src="../shared/js/cr/event_target.js"></script>
13 <script src="timeline_model.js"></script> 13 <script src="timeline_model.js"></script>
14 <script> 14 <script>
15 goog.require('goog.testing.jsunit'); 15 goog.require('goog.testing.jsunit');
16 </script> 16 </script>
17 17
18 </head> 18 </head>
19 <body> 19 <body>
(...skipping 28 matching lines...) Expand all
48 assertEquals((629 - 524) / 1000, slice.start); 48 assertEquals((629 - 524) / 1000, slice.start);
49 assertEquals((631 - 629) / 1000, slice.duration); 49 assertEquals((631 - 629) / 1000, slice.duration);
50 assertEquals(0, slice.subSlices.length); 50 assertEquals(0, slice.subSlices.length);
51 } 51 }
52 52
53 function testNestedParsing() { 53 function testNestedParsing() {
54 var events = [ 54 var events = [
55 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 55 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
56 {name: 'b', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'B'}, 56 {name: 'b', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'B'},
57 {name: 'b', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 1, ph: 'E'}, 57 {name: 'b', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 1, ph: 'E'},
58 {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'}, 58 {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'}
59 ]; 59 ];
60 var m = new tracing.TimelineModel(events); 60 var m = new tracing.TimelineModel(events);
61 var p = m.processes[1]; 61 var p = m.processes[1];
62 var t = p.threads[1]; 62 var t = p.threads[1];
63 assertEquals(2, t.subRows.length); 63 assertEquals(2, t.subRows.length);
64 var subRow = t.subRows[0]; 64 var subRow = t.subRows[0];
65 assertEquals(1, subRow.length); 65 assertEquals(1, subRow.length);
66 var slice = subRow[0]; 66 var slice = subRow[0];
67 assertEquals('a', slice.title); 67 assertEquals('a', slice.title);
68 assertEquals((4 - 1) / 1000, slice.duration); 68 assertEquals((4 - 1) / 1000, slice.duration);
69 assertEquals(1, slice.subSlices.length); 69 assertEquals(1, slice.subSlices.length);
70 70
71 slice = slice.subSlices[0]; 71 slice = slice.subSlices[0];
72 assertEquals('b', slice.title); 72 assertEquals('b', slice.title);
73 assertEquals((2 - 1) / 1000, slice.start); 73 assertEquals((2 - 1) / 1000, slice.start);
74 assertEquals((3 - 2) / 1000, slice.duration); 74 assertEquals((3 - 2) / 1000, slice.duration);
75 assertEquals(0, slice.subSlices.length); 75 assertEquals(0, slice.subSlices.length);
76 76
77 subRow = t.subRows[1]; 77 subRow = t.subRows[1];
78 slice = subRow[0]; 78 slice = subRow[0];
79 assertEquals(t.subRows[0][0].subSlices[0], slice); 79 assertEquals(t.subRows[0][0].subSlices[0], slice);
80 } 80 }
81 81
82 function testAutoclosing() { 82 function testAutoclosing() {
83 var events = [ 83 var events = [
84 // Slice that doesn't finish 84 // Slice that doesn't finish.
85 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 85 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
86 86
87 // Slice that does finish to give an 'end time' to make autoclosing work 87 // Slice that does finish to give an 'end time' to make autoclosing work.
88 {name: 'b', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 2, ph: 'B'}, 88 {name: 'b', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 2, ph: 'B'},
89 {name: 'b', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 2, ph: 'E'}, 89 {name: 'b', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 2, ph: 'E'}
90 ]; 90 ];
91 var m = new tracing.TimelineModel(events); 91 var m = new tracing.TimelineModel(events);
92 var p = m.processes[1]; 92 var p = m.processes[1];
93 var t = p.threads[1]; 93 var t = p.threads[1];
94 var subRow = t.subRows[0]; 94 var subRow = t.subRows[0];
95 var slice = subRow[0]; 95 var slice = subRow[0];
96 assertEquals('a', slice.title); 96 assertEquals('a', slice.title);
97 assertTrue(slice.didNotFinish); 97 assertTrue(slice.didNotFinish);
98 assertEquals(0, slice.start); 98 assertEquals(0, slice.start);
99 assertEquals((2 - 1) / 1000, slice.duration); 99 assertEquals((2 - 1) / 1000, slice.duration);
100 } 100 }
101 101
102 102
103 function testNestedAutoclosing() { 103 function testNestedAutoclosing() {
104 var events = [ 104 var events = [
105 // Tasks that dont finish 105 // Tasks that dont finish.
106 {name: 'a1', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 106 {name: 'a1', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
107 {name: 'a2', args: {}, pid: 1, ts: 1.5, cat: 'foo', tid: 1, ph: 'B'}, 107 {name: 'a2', args: {}, pid: 1, ts: 1.5, cat: 'foo', tid: 1, ph: 'B'},
108 108
109 // Slice that does finish to give an 'end time' to make autoclosing work 109 // Slice that does finish to give an 'end time' to make autoclosing work.
110 {name: 'b', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 2, ph: 'B'}, 110 {name: 'b', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 2, ph: 'B'},
111 {name: 'b', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 2, ph: 'E'}, 111 {name: 'b', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 2, ph: 'E'}
112 ]; 112 ];
113 var m = new tracing.TimelineModel(events); 113 var m = new tracing.TimelineModel(events);
114 var p = m.processes[1]; 114 var p = m.processes[1];
115 var t = p.threads[1]; 115 var t = p.threads[1];
116 var subRow = t.subRows[0]; 116 var subRow = t.subRows[0];
117 var slice = subRow[0]; 117 var slice = subRow[0];
118 assertEquals('a1', slice.title); 118 assertEquals('a1', slice.title);
119 assertTrue(slice.didNotFinish); 119 assertTrue(slice.didNotFinish);
120 assertEquals(0, slice.start); 120 assertEquals(0, slice.start);
121 assertEquals((2 - 1) / 1000, slice.duration); 121 assertEquals((2 - 1) / 1000, slice.duration);
122 122
123 var slice = slice.subSlices[0]; 123 var slice = slice.subSlices[0];
124 assertEquals('a2', slice.title); 124 assertEquals('a2', slice.title);
125 assertTrue(slice.didNotFinish); 125 assertTrue(slice.didNotFinish);
126 assertEquals((1.5 - 1) / 1000, slice.start); 126 assertEquals((1.5 - 1) / 1000, slice.start);
127 assertEquals((2 - 1.5) / 1000, slice.duration); 127 assertEquals((2 - 1.5) / 1000, slice.duration);
128 } 128 }
129 129
130 function testTaskColoring() { 130 function testTaskColoring() {
131 // The test below depends on hashing of 'a' != 'b'. Fail early if that 131 // The test below depends on hashing of 'a' != 'b'. Fail early if that
132 // assumption is incorrect. 132 // assumption is incorrect.
133 assertNotEquals(tracing.getStringHash('a'), tracing.getStringHash('b')); 133 assertNotEquals(tracing.getStringHash('a'), tracing.getStringHash('b'));
134 134
135 var events = [ 135 var events = [
136 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 136 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
137 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, 137 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'},
138 {name: 'b', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 1, ph: 'B'}, 138 {name: 'b', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 1, ph: 'B'},
139 {name: 'b', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'}, 139 {name: 'b', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'},
140 {name: 'a', args: {}, pid: 1, ts: 5, cat: 'foo', tid: 1, ph: 'B'}, 140 {name: 'a', args: {}, pid: 1, ts: 5, cat: 'foo', tid: 1, ph: 'B'},
141 {name: 'a', args: {}, pid: 1, ts: 6, cat: 'foo', tid: 1, ph: 'E'}, 141 {name: 'a', args: {}, pid: 1, ts: 6, cat: 'foo', tid: 1, ph: 'E'}
142 ]; 142 ];
143 var m = new tracing.TimelineModel(events); 143 var m = new tracing.TimelineModel(events);
144 var p = m.processes[1]; 144 var p = m.processes[1];
145 var t = p.threads[1]; 145 var t = p.threads[1];
146 var subRow = t.subRows[0]; 146 var subRow = t.subRows[0];
147 var a1 = subRow[0]; 147 var a1 = subRow[0];
148 assertEquals('a', a1.title); 148 assertEquals('a', a1.title);
149 var b = subRow[1]; 149 var b = subRow[1];
150 assertEquals('b', b.title); 150 assertEquals('b', b.title);
151 assertNotEquals(a1.colorId, b.colorId); 151 assertNotEquals(a1.colorId, b.colorId);
152 var a2 = subRow[0]; 152 var a2 = subRow[0];
153 assertEquals('a', a2.title); 153 assertEquals('a', a2.title);
154 assertEquals(a1.colorId, a2.colorId); 154 assertEquals(a1.colorId, a2.colorId);
155 } 155 }
156 156
157 function testMultipleThreadParsing() { 157 function testMultipleThreadParsing() {
158 var events = [ 158 var events = [
159 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 159 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
160 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, 160 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'},
161 {name: 'b', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 2, ph: 'B'}, 161 {name: 'b', args: {}, pid: 1, ts: 3, cat: 'foo', tid: 2, ph: 'B'},
162 {name: 'b', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 2, ph: 'E'} 162 {name: 'b', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 2, ph: 'E'}
163 ]; 163 ];
164 var m = new tracing.TimelineModel(events); 164 var m = new tracing.TimelineModel(events);
165 assertEquals(1, m.numProcesses); 165 assertEquals(1, m.numProcesses);
166 var p = m.processes[1]; 166 var p = m.processes[1];
167 assertNotUndefined(p); 167 assertNotUndefined(p);
168 168
169 assertEquals(2, p.numThreads); 169 assertEquals(2, p.numThreads);
170 170
171 // Check thread 1 171 // Check thread 1.
172 var t = p.threads[1]; 172 var t = p.threads[1];
173 assertNotUndefined(t); 173 assertNotUndefined(t);
174 assertEquals(1, t.subRows.length); 174 assertEquals(1, t.subRows.length);
175 assertEquals(1, t.tid); 175 assertEquals(1, t.tid);
176 176
177 var subRow = t.subRows[0]; 177 var subRow = t.subRows[0];
178 assertEquals(1, subRow.length); 178 assertEquals(1, subRow.length);
179 var slice = subRow[0]; 179 var slice = subRow[0];
180 assertEquals('a', slice.title); 180 assertEquals('a', slice.title);
181 assertEquals(0, slice.start); 181 assertEquals(0, slice.start);
182 assertEquals((2 - 1) / 1000, slice.duration); 182 assertEquals((2 - 1) / 1000, slice.duration);
183 assertEquals(0, slice.subSlices.length); 183 assertEquals(0, slice.subSlices.length);
184 184
185 // Check thread 2 185 // Check thread 2.
186 var t = p.threads[2]; 186 var t = p.threads[2];
187 assertNotUndefined(t); 187 assertNotUndefined(t);
188 assertEquals(1, t.subRows.length); 188 assertEquals(1, t.subRows.length);
189 assertEquals(2, t.tid); 189 assertEquals(2, t.tid);
190 190
191 subRow = t.subRows[0]; 191 subRow = t.subRows[0];
192 assertEquals(1, subRow.length); 192 assertEquals(1, subRow.length);
193 slice = subRow[0]; 193 slice = subRow[0];
194 assertEquals('b', slice.title); 194 assertEquals('b', slice.title);
195 assertEquals((3 - 1) / 1000, slice.start); 195 assertEquals((3 - 1) / 1000, slice.start);
196 assertEquals((4 - 3) / 1000, slice.duration); 196 assertEquals((4 - 3) / 1000, slice.duration);
197 assertEquals(0, slice.subSlices.length); 197 assertEquals(0, slice.subSlices.length);
198 } 198 }
199 199
200 function testMultiplePidParsing() { 200 function testMultiplePidParsing() {
201 var events = [ 201 var events = [
202 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 202 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
203 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, 203 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'},
204 {name: 'b', args: {}, pid: 2, ts: 3, cat: 'foo', tid: 2, ph: 'B'}, 204 {name: 'b', args: {}, pid: 2, ts: 3, cat: 'foo', tid: 2, ph: 'B'},
205 {name: 'b', args: {}, pid: 2, ts: 4, cat: 'foo', tid: 2, ph: 'E'} 205 {name: 'b', args: {}, pid: 2, ts: 4, cat: 'foo', tid: 2, ph: 'E'}
206 ]; 206 ];
207 var m = new tracing.TimelineModel(events); 207 var m = new tracing.TimelineModel(events);
208 assertEquals(2, m.numProcesses); 208 assertEquals(2, m.numProcesses);
209 var p = m.processes[1]; 209 var p = m.processes[1];
210 assertNotUndefined(p); 210 assertNotUndefined(p);
211 211
212 assertEquals(1, p.numThreads); 212 assertEquals(1, p.numThreads);
213 213
214 // Check process 1 thread 1 214 // Check process 1 thread 1.
215 var t = p.threads[1]; 215 var t = p.threads[1];
216 assertNotUndefined(t); 216 assertNotUndefined(t);
217 assertEquals(1, t.subRows.length); 217 assertEquals(1, t.subRows.length);
218 assertEquals(1, t.tid); 218 assertEquals(1, t.tid);
219 219
220 var subRow = t.subRows[0]; 220 var subRow = t.subRows[0];
221 assertEquals(1, subRow.length); 221 assertEquals(1, subRow.length);
222 var slice = subRow[0]; 222 var slice = subRow[0];
223 assertEquals('a', slice.title); 223 assertEquals('a', slice.title);
224 assertEquals(0, slice.start); 224 assertEquals(0, slice.start);
225 assertEquals((2 - 1) / 1000, slice.duration); 225 assertEquals((2 - 1) / 1000, slice.duration);
226 assertEquals(0, slice.subSlices.length); 226 assertEquals(0, slice.subSlices.length);
227 227
228 // Check process 2 thread 2 228 // Check process 2 thread 2.
229 var p = m.processes[2]; 229 var p = m.processes[2];
230 assertNotUndefined(p); 230 assertNotUndefined(p);
231 assertEquals(1, p.numThreads); 231 assertEquals(1, p.numThreads);
232 var t = p.threads[2]; 232 var t = p.threads[2];
233 assertNotUndefined(t); 233 assertNotUndefined(t);
234 assertEquals(1, t.subRows.length); 234 assertEquals(1, t.subRows.length);
235 assertEquals(2, t.tid); 235 assertEquals(2, t.tid);
236 236
237 subRow = t.subRows[0]; 237 subRow = t.subRows[0];
238 assertEquals(1, subRow.length); 238 assertEquals(1, subRow.length);
239 slice = subRow[0]; 239 slice = subRow[0];
240 assertEquals('b', slice.title); 240 assertEquals('b', slice.title);
241 assertEquals((3 - 1) / 1000, slice.start); 241 assertEquals((3 - 1) / 1000, slice.start);
242 assertEquals((4 - 3) / 1000, slice.duration); 242 assertEquals((4 - 3) / 1000, slice.duration);
243 assertEquals(0, slice.subSlices.length); 243 assertEquals(0, slice.subSlices.length);
244 244
245 // Check getAllThreads. 245 // Check getAllThreads.
246 assertArrayEquals([m.processes[1].threads[1], m.processes[2].threads[2]], 246 assertArrayEquals([m.processes[1].threads[1], m.processes[2].threads[2]],
247 m.getAllThreads()) 247 m.getAllThreads());
248 } 248 }
249 249
250 // Thread names 250 // Thread names.
251 function testThreadNames() { 251 function testThreadNames() {
252 var events = [ 252 var events = [
253 {name: 'thread_name', args: {name: 'Thread 1'}, 253 {name: 'thread_name', args: {name: 'Thread 1'},
254 pid: 1, ts: 0, tid: 1, ph: 'M'}, 254 pid: 1, ts: 0, tid: 1, ph: 'M'},
255 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 255 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
256 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'}, 256 {name: 'a', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'E'},
257 {name: 'b', args: {}, pid: 2, ts: 3, cat: 'foo', tid: 2, ph: 'B'}, 257 {name: 'b', args: {}, pid: 2, ts: 3, cat: 'foo', tid: 2, ph: 'B'},
258 {name: 'b', args: {}, pid: 2, ts: 4, cat: 'foo', tid: 2, ph: 'E'}, 258 {name: 'b', args: {}, pid: 2, ts: 4, cat: 'foo', tid: 2, ph: 'E'},
259 {name: 'thread_name', args: {name: 'Thread 2'}, 259 {name: 'thread_name', args: {name: 'Thread 2'},
260 pid: 2, ts: 0, tid: 2, ph: 'M'}, 260 pid: 2, ts: 0, tid: 2, ph: 'M'}
261 ]; 261 ];
262 var m = new tracing.TimelineModel(events); 262 var m = new tracing.TimelineModel(events);
263 assertEquals('Thread 1', m.processes[1].threads[1].name); 263 assertEquals('Thread 1', m.processes[1].threads[1].name);
264 assertEquals('Thread 2', m.processes[2].threads[2].name); 264 assertEquals('Thread 2', m.processes[2].threads[2].name);
265 } 265 }
266 266
267 // User time 267 // User time.
268 function testUserTime() { 268 function testUserTime() {
269 var events = [ 269 var events = [
270 {name: 'thread_name', args: {name: 'Thread 1'}, 270 {name: 'thread_name', args: {name: 'Thread 1'},
271 pid: 1, ts: 0, tid: 1, ph: 'M'}, 271 pid: 1, ts: 0, tid: 1, ph: 'M'},
272 {name: 'a', args: {}, pid: 1, ts: 1, uts: 70, cat: 'foo', tid: 1, ph: 'B'}, 272 {name: 'a', args: {}, pid: 1, ts: 1, uts: 70, cat: 'foo', tid: 1, ph: 'B'},
273 {name: 'a', args: {}, pid: 1, ts: 2, uts: 77, cat: 'foo', tid: 1, ph: 'E'}, 273 {name: 'a', args: {}, pid: 1, ts: 2, uts: 77, cat: 'foo', tid: 1, ph: 'E'},
274 {name: 'a', args: {}, pid: 1, ts: 2 , uts: 80, cat: 'foo', tid: 1, ph: 'I'}, 274 {name: 'a', args: {}, pid: 1, ts: 2 , uts: 80, cat: 'foo', tid: 1, ph: 'I'}
275 ]; 275 ];
276 var m = new tracing.TimelineModel(events); 276 var m = new tracing.TimelineModel(events);
277 var subRow = m.processes[1].threads[1].subRows[0]; 277 var subRow = m.processes[1].threads[1].subRows[0];
278 assertEquals(subRow[0].startInUserTime, 0.07); 278 assertEquals(subRow[0].startInUserTime, 0.07);
279 assertEquals(subRow[0].durationInUserTime, 0.007); 279 assertEquals(subRow[0].durationInUserTime, 0.007);
280 assertEquals(subRow[1].startInUserTime, 0.08); 280 assertEquals(subRow[1].startInUserTime, 0.08);
281 assertEquals(subRow[1].durationInUserTime, 0); 281 assertEquals(subRow[1].durationInUserTime, 0);
282 } 282 }
283 283
284 284
285 function testImmediateParsing() { 285 function testImmediateParsing() {
286 var events = [ 286 var events = [
287 // Need to include immediates inside a task so the timeline 287 // Need to include immediates inside a task so the timeline
288 // recentering/zeroing doesn't clobber their timestamp. 288 // recentering/zeroing doesn't clobber their timestamp.
289 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, 289 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'},
290 {name: 'immediate', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'I'}, 290 {name: 'immediate', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'I'},
291 {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'}, 291 {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'}
292 ]; 292 ];
293 var m = new tracing.TimelineModel(events); 293 var m = new tracing.TimelineModel(events);
294 var p = m.processes[1]; 294 var p = m.processes[1];
295 var t = p.threads[1]; 295 var t = p.threads[1];
296 assertEquals(2, t.subRows.length); 296 assertEquals(2, t.subRows.length);
297 var subRow = t.subRows[0]; 297 var subRow = t.subRows[0];
298 assertEquals(1, subRow.length); 298 assertEquals(1, subRow.length);
299 var slice = subRow[0]; 299 var slice = subRow[0];
300 assertEquals('a', slice.title); 300 assertEquals('a', slice.title);
301 assertEquals((4 - 1) / 1000, slice.duration); 301 assertEquals((4 - 1) / 1000, slice.duration);
302 assertEquals(1, slice.subSlices.length); 302 assertEquals(1, slice.subSlices.length);
303 303
304 var immed = slice.subSlices[0]; 304 var immed = slice.subSlices[0];
305 assertEquals('immediate', immed.title); 305 assertEquals('immediate', immed.title);
306 assertEquals((2 - 1) / 1000, immed.start); 306 assertEquals((2 - 1) / 1000, immed.start);
307 assertEquals(0, immed.duration); 307 assertEquals(0, immed.duration);
308 assertEquals(0, immed.subSlices.length); 308 assertEquals(0, immed.subSlices.length);
309 309
310 subRow = t.subRows[1]; 310 subRow = t.subRows[1];
311 assertEquals(immed, subRow[0]); 311 assertEquals(immed, subRow[0]);
312 } 312 }
313
314 function testSimpleCounter() {
315 var events = [
316 {name: 'ctr', args: {'value': 0}, pid: 1, ts: 0, cat: 'foo', tid: 1,
317 ph: 'C'},
318 {name: 'ctr', args: {'value': 10}, pid: 1, ts: 10, cat: 'foo', tid: 1,
319 ph: 'C'},
320 {name: 'ctr', args: {'value': 0}, pid: 1, ts: 20, cat: 'foo', tid: 1,
321 ph: 'C'}
322
323 ];
324 var m = new tracing.TimelineModel(events);
325 var p = m.processes[1];
326 var ctr = m.processes[1].counters['ctr'];
327
328 assertEquals('ctr', ctr.name);
329 assertEquals(3, ctr.numSamples);
330 assertEquals(1, ctr.numSeries);
331
332 assertArrayEquals(['value'], ctr.seriesNames);
333 assertArrayEquals([tracing.getStringHash('ctr.value')], ctr.seriesColors);
334 assertArrayEquals([0, 0.01, 0.02], ctr.timestamps);
335 assertArrayEquals([0, 10, 0], ctr.samples);
336 assertArrayEquals([0, 10, 0], ctr.totals);
337 assertEquals(10, ctr.maxTotal);
338 }
339
340 function testMultiCounterUpdateBounds() {
341 var ctr = new tracing.TimelineCounter(undefined, 'testBasicCounter');
342 ctr.numSeries = 1;
343 ctr.seriesNames = ['value1', 'value2'];
344 ctr.seriesColors = ['testBasicCounter.value1', 'testBasicCounter.value2'];
345 ctr.timestamps = [0, 1, 2, 3, 4, 5, 6, 7];
346 ctr.samples = [0, 0,
347 1, 0,
348 1, 1,
349 2, 1.1,
350 3, 0,
351 1, 7,
352 3, 0,
353 3.1, 0.5];
354 ctr.updateBounds();
355 assertEquals(0, ctr.minTimestamp);
356 assertEquals(7, ctr.maxTimestamp);
357 assertEquals(8, ctr.maxTotal);
358 assertArrayEquals([0, 0,
359 1, 1,
360 1, 2,
361 2, 3.1,
362 3, 3,
363 1, 8,
364 3, 3,
365 3.1, 3.6], ctr.totals);
366 }
367
368 function testMultiCounter() {
369 var events = [
370 {name: 'ctr', args: {'value1': 0, 'value2': 7}, pid: 1, ts: 0, cat: 'foo',
371 tid: 1, ph: 'C'},
372 {name: 'ctr', args: {'value1': 10, 'value2': 4}, pid: 1, ts: 10, cat: 'foo',
373 tid: 1, ph: 'C'},
374 {name: 'ctr', args: {'value1': 0, 'value2': 1 }, pid: 1, ts: 20, cat: 'foo',
375 tid: 1, ph: 'C'}
376 ];
377 var m = new tracing.TimelineModel(events);
378 var p = m.processes[1];
379 var ctr = m.processes[1].counters['ctr'];
380 assertEquals('ctr', ctr.name);
381
382 assertEquals('ctr', ctr.name);
383 assertEquals(3, ctr.numSamples);
384 assertEquals(2, ctr.numSeries);
385
386 assertArrayEquals(['value1', 'value2'], ctr.seriesNames);
387 assertArrayEquals([tracing.getStringHash('ctr.value1'),
388 tracing.getStringHash('ctr.value2')],
389 ctr.seriesColors);
390 assertArrayEquals([0, 0.01, 0.02], ctr.timestamps);
391 assertArrayEquals([0, 7,
392 10, 4,
393 0, 1], ctr.samples);
394 assertArrayEquals([0, 7,
395 10, 14,
396 0, 1], ctr.totals);
397 assertEquals(14, ctr.maxTotal);
398 }
399
313 </script> 400 </script>
314 </body> 401 </body>
315 </html> 402 </html>
OLDNEW
« chrome/browser/resources/tracing/timeline_model.js ('K') | « chrome/browser/resources/tracing/timeline_model.js ('k') | chrome/browser/resources/tracing/timeline_test.html » ('j') | chrome/browser/resources/tracing/timeline_test.html » ('J')

Powered by Google App Engine
This is Rietveld 408576698