| OLD | NEW |
|---|
| (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: 524, cat: 'foo', tid: 53, ph: 'B'}, |
| 24 {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'}, |
| 25 {name: 'b', args: {}, pid: 52, ts: 629, cat: 'foo', tid: 53, ph: 'B'}, |
| 26 {name: 'b', args: {}, pid: 52, ts: 631, 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((560 - 524) / 1000, slice.duration); |
| 44 assertEquals(0, slice.subSlices.length); |
| 45 |
| 46 slice = subRow[1]; |
| 47 assertEquals('b', slice.title); |
| 48 assertEquals((629 - 524) / 1000, slice.start); |
| 49 assertEquals((631 - 629) / 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); |
| 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 |
| 132 // assumption is incorrect. |
| 133 assertNotEquals(tracing.getStringHash('a'), tracing.getStringHash('b')); |
| 134 |
| 135 var events = [ |
| 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'}, |
| 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'}, |
| 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'}, |
| 142 ]; |
| 143 var m = new tracing.TimelineModel(events); |
| 144 var p = m.processes[1]; |
| 145 var t = p.threads[1]; |
| 146 var subRow = t.subRows[0]; |
| 147 var a1 = subRow[0]; |
| 148 assertEquals('a', a1.title); |
| 149 var b = subRow[1]; |
| 150 assertEquals('b', b.title); |
| 151 assertNotEquals(a1.colorId, b.colorId); |
| 152 var a2 = subRow[0]; |
| 153 assertEquals('a', a2.title); |
| 154 assertEquals(a1.colorId, a2.colorId); |
| 155 } |
| 156 |
| 157 function testMultipleThreadParsing() { |
| 158 var events = [ |
| 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'}, |
| 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'} |
| 163 ]; |
| 164 var m = new tracing.TimelineModel(events); |
| 165 assertEquals(1, m.numProcesses); |
| 166 var p = m.processes[1]; |
| 167 assertNotUndefined(p); |
| 168 |
| 169 assertEquals(2, p.numThreads); |
| 170 |
| 171 // Check thread 1 |
| 172 var t = p.threads[1]; |
| 173 assertNotUndefined(t); |
| 174 assertEquals(1, t.subRows.length); |
| 175 assertEquals(1, t.tid); |
| 176 |
| 177 var subRow = t.subRows[0]; |
| 178 assertEquals(1, subRow.length); |
| 179 var slice = subRow[0]; |
| 180 assertEquals('a', slice.title); |
| 181 assertEquals(0, slice.start); |
| 182 assertEquals((2 - 1) / 1000, slice.duration); |
| 183 assertEquals(0, slice.subSlices.length); |
| 184 |
| 185 // Check thread 2 |
| 186 var t = p.threads[2]; |
| 187 assertNotUndefined(t); |
| 188 assertEquals(1, t.subRows.length); |
| 189 assertEquals(2, t.tid); |
| 190 |
| 191 subRow = t.subRows[0]; |
| 192 assertEquals(1, subRow.length); |
| 193 slice = subRow[0]; |
| 194 assertEquals('b', slice.title); |
| 195 assertEquals((3 - 1) / 1000, slice.start); |
| 196 assertEquals((4 - 3) / 1000, slice.duration); |
| 197 assertEquals(0, slice.subSlices.length); |
| 198 } |
| 199 |
| 200 function testMultiplePidParsing() { |
| 201 var events = [ |
| 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'}, |
| 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'} |
| 206 ]; |
| 207 var m = new tracing.TimelineModel(events); |
| 208 assertEquals(2, m.numProcesses); |
| 209 var p = m.processes[1]; |
| 210 assertNotUndefined(p); |
| 211 |
| 212 assertEquals(1, p.numThreads); |
| 213 |
| 214 // Check process 1 thread 1 |
| 215 var t = p.threads[1]; |
| 216 assertNotUndefined(t); |
| 217 assertEquals(1, t.subRows.length); |
| 218 assertEquals(1, t.tid); |
| 219 |
| 220 var subRow = t.subRows[0]; |
| 221 assertEquals(1, subRow.length); |
| 222 var slice = subRow[0]; |
| 223 assertEquals('a', slice.title); |
| 224 assertEquals(0, slice.start); |
| 225 assertEquals((2 - 1) / 1000, slice.duration); |
| 226 assertEquals(0, slice.subSlices.length); |
| 227 |
| 228 // Check process 2 thread 2 |
| 229 var p = m.processes[2]; |
| 230 assertNotUndefined(p); |
| 231 assertEquals(1, p.numThreads); |
| 232 var t = p.threads[2]; |
| 233 assertNotUndefined(t); |
| 234 assertEquals(1, t.subRows.length); |
| 235 assertEquals(2, t.tid); |
| 236 |
| 237 subRow = t.subRows[0]; |
| 238 assertEquals(1, subRow.length); |
| 239 slice = subRow[0]; |
| 240 assertEquals('b', slice.title); |
| 241 assertEquals((3 - 1) / 1000, slice.start); |
| 242 assertEquals((4 - 3) / 1000, slice.duration); |
| 243 assertEquals(0, slice.subSlices.length); |
| 244 |
| 245 // Check getAllThreads. |
| 246 assertArrayEquals([m.processes[1].threads[1], m.processes[2].threads[2]], |
| 247 m.getAllThreads()) |
| 248 } |
| 249 |
| 250 // Thread names |
| 251 function testThreadNames() { |
| 252 var events = [ |
| 253 {name: 'thread_name', args: {name: 'Thread 1'}, |
| 254 pid: 1, ts: 0, tid: 1, ph: 'M'}, |
| 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'}, |
| 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'}, |
| 259 {name: 'thread_name', args: {name: 'Thread 2'}, |
| 260 pid: 2, ts: 0, tid: 2, ph: 'M'}, |
| 261 ]; |
| 262 var m = new tracing.TimelineModel(events); |
| 263 assertEquals('Thread 1', m.processes[1].threads[1].name); |
| 264 assertEquals('Thread 2', m.processes[2].threads[2].name); |
| 265 } |
| 266 |
| 267 |
| 268 function testImmediateParsing() { |
| 269 var events = [ |
| 270 // Need to include immediates inside a task so the timeline |
| 271 // recentering/zeroing doesn't clobber their timestamp. |
| 272 {name: 'a', args: {}, pid: 1, ts: 1, cat: 'foo', tid: 1, ph: 'B'}, |
| 273 {name: 'immediate', args: {}, pid: 1, ts: 2, cat: 'foo', tid: 1, ph: 'I'}, |
| 274 {name: 'a', args: {}, pid: 1, ts: 4, cat: 'foo', tid: 1, ph: 'E'}, |
| 275 ]; |
| 276 var m = new tracing.TimelineModel(events); |
| 277 var p = m.processes[1]; |
| 278 var t = p.threads[1]; |
| 279 assertEquals(2, t.subRows.length); |
| 280 var subRow = t.subRows[0]; |
| 281 assertEquals(1, subRow.length); |
| 282 var slice = subRow[0]; |
| 283 assertEquals('a', slice.title); |
| 284 assertEquals((4 - 1) / 1000, slice.duration); |
| 285 assertEquals(1, slice.subSlices.length); |
| 286 |
| 287 var immed = slice.subSlices[0]; |
| 288 assertEquals('immediate', immed.title); |
| 289 assertEquals((2 - 1) / 1000, immed.start); |
| 290 assertEquals(0, immed.duration); |
| 291 assertEquals(0, immed.subSlices.length); |
| 292 |
| 293 subRow = t.subRows[1]; |
| 294 assertEquals(immed, subRow[0]); |
| 295 } |
| 296 </script> |
| 297 </body> |
| 298 </html> |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 8342069:
Add unit tests for about:tracing TimelineModel. (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master