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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side 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 unified diff | 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 »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 <!DOCTYPE html>
2 <html>
3 <!--
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
6 found in the LICENSE file.
7 -->
8 <head>
9 <title></title>
10 <script src="http://closure-library.googlecode.com/svn/trunk/closure/goog/base.j s"></script>
11 <script src="../shared/js/cr.js"></script>
12 <script src="../shared/js/cr/event_target.js"></script>
13 <script src="timeline_model.js"></script>
14 <script>
15 goog.require('goog.testing.jsunit');
16 </script>
17
18 </head>
19 <body>
20 <script>
21 function testBasicSingleThreadNonnestedParsing() {
22 var events = [
23 {'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.
24 {'name':'a','args':{},'pid':52,'ts':9560,'cat':'foo','tid':53,'ph':'E'},
25 {'name':'b','args':{},'pid':52,'ts':9629,'cat':'foo','tid':53,'ph':'B'},
26 {'name':'b','args':{},'pid':52,'ts':9631,'cat':'foo','tid':53,'ph':'E'}
27 ];
28 var m = new tracing.TimelineModel(events);
29 assertEquals(1, m.numProcesses);
30 var p = m.processes[52];
31 assertNotUndefined(p);
32
33 assertEquals(1, p.numThreads);
34 var t = p.threads[53];
35 assertNotUndefined(t);
36 assertEquals(1, t.subRows.length);
37 assertEquals(53, t.tid);
38 var subRow = t.subRows[0];
39 assertEquals(2, subRow.length);
40 var slice = subRow[0];
41 assertEquals('a', slice.title);
42 assertEquals(0, slice.start);
43 assertEquals((9560 - 9524) / 1000, slice.duration);
44 assertEquals(0, slice.subSlices.length);
45
46 slice = subRow[1];
47 assertEquals('b', slice.title);
48 assertEquals((9629-9524) / 1000, slice.start);
49 assertEquals((9631 - 9629) / 1000, slice.duration);
50 assertEquals(0, slice.subSlices.length);
51 }
52
53 function testNestedParsing() {
54 var events = [
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'},
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'},
59 ];
60 var m = new tracing.TimelineModel(events);
61 var p = m.processes[1];
62 var t = p.threads[1];
63 assertEquals(2, t.subRows.length);
64 var subRow = t.subRows[0];
65 assertEquals(1, subRow.length);
66 var slice = subRow[0];
67 assertEquals('a', slice.title);
68 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.
69 assertEquals(1, slice.subSlices.length);
70
71 slice = slice.subSlices[0];
72 assertEquals('b', slice.title);
73 assertEquals((2-1) / 1000, slice.start);
74 assertEquals((3-2) / 1000, slice.duration);
75 assertEquals(0, slice.subSlices.length);
76
77 subRow = t.subRows[1];
78 slice = subRow[0];
79 assertEquals(t.subRows[0][0].subSlices[0], slice);
80 }
81
82 function testAutoclosing() {
83 var events = [
84 // Slice that doesn't finish
85 {'name':'a','args':{},'pid':1,'ts':1,'cat':'foo','tid':1,'ph':'B'},
86
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'},
89 {'name':'b','args':{},'pid':1,'ts':2,'cat':'foo','tid':2,'ph':'E'},
90 ];
91 var m = new tracing.TimelineModel(events);
92 var p = m.processes[1];
93 var t = p.threads[1];
94 var subRow = t.subRows[0];
95 var slice = subRow[0];
96 assertEquals('a', slice.title);
97 assertTrue(slice.didNotFinish);
98 assertEquals(0, slice.start);
99 assertEquals((2-1) / 1000, slice.duration);
100 }
101
102
103 function testNestedAutoclosing() {
104 var events = [
105 // Tasks that dont finish
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'},
108
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'},
111 {'name':'b','args':{},'pid':1,'ts':2,'cat':'foo','tid':2,'ph':'E'},
112 ];
113 var m = new tracing.TimelineModel(events);
114 var p = m.processes[1];
115 var t = p.threads[1];
116 var subRow = t.subRows[0];
117 var slice = subRow[0];
118 assertEquals('a1', slice.title);
119 assertTrue(slice.didNotFinish);
120 assertEquals(0, slice.start);
121 assertEquals((2-1) / 1000, slice.duration);
122
123 var slice = slice.subSlices[0];
124 assertEquals('a2', slice.title);
125 assertTrue(slice.didNotFinish);
126 assertEquals((1.5-1) / 1000, slice.start);
127 assertEquals((2-1.5) / 1000, slice.duration);
128 }
129
130 function testTaskColoring() {
131 // The test below depends on hashing of 'a' != 'b'. Fail early if that assumpt ion is incorrect.
132 assertNotEquals(tracing.getStringHash('a'), tracing.getStringHash('b'));
133
134 var events = [
135 {'name':'a','args':{},'pid':1,'ts':1,'cat':'foo','tid':1,'ph':'B'},
136 {'name':'a','args':{},'pid':1,'ts':2,'cat':'foo','tid':1,'ph':'E'},
137 {'name':'b','args':{},'pid':1,'ts':3,'cat':'foo','tid':1,'ph':'B'},
138 {'name':'b','args':{},'pid':1,'ts':4,'cat':'foo','tid':1,'ph':'E'},
139 {'name':'a','args':{},'pid':1,'ts':5,'cat':'foo','tid':1,'ph':'B'},
140 {'name':'a','args':{},'pid':1,'ts':6,'cat':'foo','tid':1,'ph':'E'},
141 ];
142 var m = new tracing.TimelineModel(events);
143 var p = m.processes[1];
144 var t = p.threads[1];
145 var subRow = t.subRows[0];
146 var a1 = subRow[0];
147 assertEquals('a', a1.title);
148 var b = subRow[1];
149 assertEquals('b', b.title);
150 assertNotEquals(a1.colorId, b.colorId);
151 var a2 = subRow[0];
152 assertEquals('a', a2.title);
153 assertEquals(a1.colorId, a2.colorId);
154 }
155
156 function testMultipleThreadParsing() {
157 var events = [
158 {'name':'a','args':{},'pid':1,'ts':1,'cat':'foo','tid':1,'ph':'B'},
159 {'name':'a','args':{},'pid':1,'ts':2,'cat':'foo','tid':1,'ph':'E'},
160 {'name':'b','args':{},'pid':1,'ts':3,'cat':'foo','tid':2,'ph':'B'},
161 {'name':'b','args':{},'pid':1,'ts':4,'cat':'foo','tid':2,'ph':'E'}
162 ];
163 var m = new tracing.TimelineModel(events);
164 assertEquals(1, m.numProcesses);
165 var p = m.processes[1];
166 assertNotUndefined(p);
167
168 assertEquals(2, p.numThreads);
169
170 // Check thread 1
171 var t = p.threads[1];
172 assertNotUndefined(t);
173 assertEquals(1, t.subRows.length);
174 assertEquals(1, t.tid);
175
176 var subRow = t.subRows[0];
177 assertEquals(1, subRow.length);
178 var slice = subRow[0];
179 assertEquals('a', slice.title);
180 assertEquals(0, slice.start);
181 assertEquals((2-1) / 1000, slice.duration);
182 assertEquals(0, slice.subSlices.length);
183
184 // Check thread 2
185 var t = p.threads[2];
186 assertNotUndefined(t);
187 assertEquals(1, t.subRows.length);
188 assertEquals(2, t.tid);
189
190 subRow = t.subRows[0];
191 assertEquals(1, subRow.length);
192 slice = subRow[0];
193 assertEquals('b', slice.title);
194 assertEquals((3-1) / 1000, slice.start);
195 assertEquals((4 - 3) / 1000, slice.duration);
196 assertEquals(0, slice.subSlices.length);
197 }
198
199 function testMultiplePidParsing() {
200 var events = [
201 {'name':'a','args':{},'pid':1,'ts':1,'cat':'foo','tid':1,'ph':'B'},
202 {'name':'a','args':{},'pid':1,'ts':2,'cat':'foo','tid':1,'ph':'E'},
203 {'name':'b','args':{},'pid':2,'ts':3,'cat':'foo','tid':2,'ph':'B'},
204 {'name':'b','args':{},'pid':2,'ts':4,'cat':'foo','tid':2,'ph':'E'}
205 ];
206 var m = new tracing.TimelineModel(events);
207 assertEquals(2, m.numProcesses);
208 var p = m.processes[1];
209 assertNotUndefined(p);
210
211 assertEquals(1, p.numThreads);
212
213 // Check process 1 thread 1
214 var t = p.threads[1];
215 assertNotUndefined(t);
216 assertEquals(1, t.subRows.length);
217 assertEquals(1, t.tid);
218
219 var subRow = t.subRows[0];
220 assertEquals(1, subRow.length);
221 var slice = subRow[0];
222 assertEquals('a', slice.title);
223 assertEquals(0, slice.start);
224 assertEquals((2-1) / 1000, slice.duration);
225 assertEquals(0, slice.subSlices.length);
226
227 // Check process 2 thread 2
228 var p = m.processes[2];
229 assertNotUndefined(p);
230 assertEquals(1, p.numThreads);
231 var t = p.threads[2];
232 assertNotUndefined(t);
233 assertEquals(1, t.subRows.length);
234 assertEquals(2, t.tid);
235
236 subRow = t.subRows[0];
237 assertEquals(1, subRow.length);
238 slice = subRow[0];
239 assertEquals('b', slice.title);
240 assertEquals((3-1) / 1000, slice.start);
241 assertEquals((4 - 3) / 1000, slice.duration);
242 assertEquals(0, slice.subSlices.length);
243
244 // Check getAllThreads.
245 assertArrayEquals([m.processes[1].threads[1], m.processes[2].threads[2]],
246 m.getAllThreads())
247 }
248
249 // Thread names
250 function testThreadNames() {
251 var events = [
252 {'name': 'thread_name', args: {'name': 'Thread 1'}, 'pid': 1, 'ts': 0, 'tid' : 1, 'ph': 'M'},
253 {'name':'a','args':{},'pid':1,'ts':1,'cat':'foo','tid':1,'ph':'B'},
254 {'name':'a','args':{},'pid':1,'ts':2,'cat':'foo','tid':1,'ph':'E'},
255 {'name':'b','args':{},'pid':2,'ts':3,'cat':'foo','tid':2,'ph':'B'},
256 {'name':'b','args':{},'pid':2,'ts':4,'cat':'foo','tid':2,'ph':'E'},
257 {'name': 'thread_name', args: {'name': 'Thread 2'}, 'pid': 2, 'ts': 0, 'tid' : 2, 'ph': 'M'},
258 ];
259 var m = new tracing.TimelineModel(events);
260 assertEquals('Thread 1', m.processes[1].threads[1].name);
261 assertEquals('Thread 2', m.processes[2].threads[2].name);
262 }
263
264
265 function testImmediateParsing() {
266 var events = [
267 // Need to include immediates inside a task so the timeline
268 // recentering/zeroing doesn't clobber their timestamp.
269 {'name':'a','args':{},'pid':1,'ts':1,'cat':'foo','tid':1,'ph':'B'},
270 {'name':'immediate','args':{},'pid':1,'ts':2,'cat':'foo','tid':1,'ph':'I'},
271 {'name':'a','args':{},'pid':1,'ts':4,'cat':'foo','tid':1,'ph':'E'},
272 ];
273 var m = new tracing.TimelineModel(events);
274 var p = m.processes[1];
275 var t = p.threads[1];
276 assertEquals(2, t.subRows.length);
277 var subRow = t.subRows[0];
278 assertEquals(1, subRow.length);
279 var slice = subRow[0];
280 assertEquals('a', slice.title);
281 assertEquals((4-1) / 1000, slice.duration);
282 assertEquals(1, slice.subSlices.length);
283
284 var immed = slice.subSlices[0];
285 assertEquals('immediate', immed.title);
286 assertEquals((2-1) / 1000, immed.start);
287 assertEquals(0, immed.duration);
288 assertEquals(0, immed.subSlices.length);
289
290 subRow = t.subRows[1];
291 assertEquals(immed, subRow[0]);
292 }
293 </script>
294 </body>
295 </html>
OLDNEW
« 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