src/third_party/trace-viewer/trace_viewer/tracing/trace_model/slice_group_test.html

   1 <!DOCTYPE html>
   2 <!--
   3 Copyright (c) 2013 The Chromium Authors. All rights reserved.
   4 Use of this source code is governed by a BSD-style license that can be
   5 found in the LICENSE file.
   6 -->
   7
   8 <link rel="import" href="/tracing/test_utils.html">
   9 <link rel="import" href="/tracing/trace_model/slice_group.html">
  10
  11 <script>
  12 'use strict';
  13
  14 tvcm.unittest.testSuite(function() {
  15   var Slice = tracing.trace_model.Slice;
  16   var SliceGroup = tracing.trace_model.SliceGroup;
  17   var newSlice = tracing.test_utils.newSlice;
  18   var newSliceNamed = tracing.test_utils.newSliceNamed;
  19
  20   test('basicBeginEnd', function() {
  21     var group = new SliceGroup();
  22     assertEquals(group.openSliceCount, 0);
  23     var sliceA = group.beginSlice('', 'a', 1, {a: 1});
  24     assertEquals(1, group.openSliceCount);
  25     assertEquals('a', sliceA.title);
  26     assertEquals(1, sliceA.start);
  27     assertEquals(1, sliceA.args.a);
  28
  29     var sliceB = group.endSlice(3);
  30     assertEquals(sliceA, sliceB);
  31     assertEquals(2, sliceB.duration);
  32   });
  33
  34   test('subSlicesBuilderBasic', function() {
  35     var group = new SliceGroup();
  36     var sA = group.pushSlice(newSliceNamed('a', 1, 2));
  37     var sB = group.pushSlice(newSliceNamed('b', 3, 1));
  38
  39     group.createSubSlices();
  40
  41     assertEquals(2, group.topLevelSlices.length);
  42     assertArrayEquals([sA, sB], group.topLevelSlices);
  43   });
  44
  45   test('subSlicesBuilderBasic2', function() {
  46     var group = new SliceGroup();
  47     var sA = group.pushSlice(newSliceNamed('a', 1, 4));
  48     var sB = group.pushSlice(newSliceNamed('b', 3, 1));
  49
  50     group.createSubSlices();
  51
  52     assertEquals(1, group.topLevelSlices.length);
  53     assertArrayEquals([sA], group.topLevelSlices);
  54
  55     assertEquals(1, sA.subSlices.length);
  56     assertArrayEquals([sB], sA.subSlices);
  57     assertEquals(3, sA.selfTime);
  58
  59     assertTrue(sB.parentSlice == sA);
  60   });
  61
  62   test('subSlicesBuilderNestedExactly', function() {
  63     var group = new SliceGroup();
  64     var sB = group.pushSlice(newSliceNamed('b', 1, 4));
  65     var sA = group.pushSlice(newSliceNamed('a', 1, 4));
  66
  67     group.createSubSlices();
  68
  69     assertEquals(1, group.topLevelSlices.length);
  70     assertArrayEquals([sB], group.topLevelSlices);
  71
  72     assertEquals(1, sB.subSlices.length);
  73     assertArrayEquals([sA], sB.subSlices);
  74     assertEquals(0, sB.selfTime);
  75
  76     assertTrue(sA.parentSlice == sB);
  77   });
  78
  79   test('subSlicesBuilderInstantEvents', function() {
  80     var group = new SliceGroup();
  81     var sA = group.pushSlice(newSliceNamed('a', 1, 0));
  82     var sB = group.pushSlice(newSliceNamed('b', 2, 0));
  83
  84     group.createSubSlices();
  85
  86     assertEquals(2, group.topLevelSlices.length);
  87     assertArrayEquals([sA, sB], group.topLevelSlices);
  88   });
  89
  90   test('subSlicesBuilderTwoInstantEvents', function() {
  91     var group = new SliceGroup();
  92     var sA = group.pushSlice(newSliceNamed('a', 1, 0));
  93     var sB = group.pushSlice(newSliceNamed('b', 1, 0));
  94
  95     group.createSubSlices();
  96
  97     assertEquals(1, group.topLevelSlices.length);
  98     assertArrayEquals([sA], group.topLevelSlices);
  99
 100     assertEquals(1, sA.subSlices.length);
 101     assertArrayEquals([sB], sA.subSlices);
 102     assertEquals(0, sA.selfTime);
 103
 104     assertTrue(sB.parentSlice == sA);
 105   });
 106
 107   test('subSlicesBuilderOutOfOrderAddition', function() {
 108     var group = new SliceGroup();
 109
 110     // Pattern being tested:
 111     // [    a     ][   b   ]
 112     // Where insertion is done backward.
 113     var sB = group.pushSlice(newSliceNamed('b', 3, 1));
 114     var sA = group.pushSlice(newSliceNamed('a', 1, 2));
 115
 116     group.createSubSlices();
 117
 118     assertEquals(2, group.topLevelSlices.length);
 119     assertArrayEquals([sA, sB], group.topLevelSlices);
 120   });
 121
 122   test('subRowBuilderOutOfOrderAddition2', function() {
 123     var group = new SliceGroup();
 124
 125     // Pattern being tested:
 126     // [    a     ]
 127     //   [  b   ]
 128     // Where insertion is done backward.
 129     var sB = group.pushSlice(newSliceNamed('b', 3, 1));
 130     var sA = group.pushSlice(newSliceNamed('a', 1, 5));
 131
 132     group.createSubSlices();
 133
 134     assertEquals(1, group.topLevelSlices.length);
 135     assertArrayEquals([sA], group.topLevelSlices);
 136
 137     assertEquals(1, sA.subSlices.length);
 138     assertArrayEquals([sB], sA.subSlices);
 139     assertEquals(4, sA.selfTime);
 140
 141     assertTrue(sB.parentSlice == sA);
 142   });
 143
 144   test('subSlicesBuilderOnNestedZeroLength', function() {
 145     var group = new SliceGroup();
 146
 147     // Pattern being tested:
 148     // [    a    ]
 149     // [  b1 ]  []<- b2 where b2.duration = 0 and b2.end == a.end.
 150     var sA = group.pushSlice(newSliceNamed('a', 1, 3));
 151     var sB1 = group.pushSlice(newSliceNamed('b1', 1, 2));
 152     var sB2 = group.pushSlice(newSliceNamed('b2', 4, 0));
 153
 154     group.createSubSlices();
 155
 156     assertEquals(1, group.topLevelSlices.length);
 157     assertArrayEquals([sA], group.topLevelSlices);
 158
 159     assertEquals(2, sA.subSlices.length);
 160     assertArrayEquals([sB1, sB2], sA.subSlices);
 161     assertEquals(1, sA.selfTime);
 162
 163     assertTrue(sB1.parentSlice == sA);
 164     assertTrue(sB2.parentSlice == sA);
 165   });
 166
 167   test('subSlicesBuilderOnGroup1', function() {
 168     var group = new SliceGroup();
 169
 170     // Pattern being tested:
 171     // [    a     ]   [  c   ]
 172     //   [  b   ]
 173     var sA = group.pushSlice(newSliceNamed('a', 1, 3));
 174     var sB = group.pushSlice(newSliceNamed('b', 1.5, 1));
 175     var sC = group.pushSlice(newSliceNamed('c', 5, 0));
 176
 177     group.createSubSlices();
 178
 179     assertEquals(2, group.topLevelSlices.length);
 180     assertArrayEquals([sA, sC], group.topLevelSlices);
 181
 182     assertEquals(1, sA.subSlices.length);
 183     assertArrayEquals([sB], sA.subSlices);
 184     assertEquals(2, sA.selfTime);
 185
 186     assertTrue(sB.parentSlice == sA);
 187   });
 188
 189   test('subSlicesBuilderOnGroup2', function() {
 190     var group = new SliceGroup();
 191
 192     // Pattern being tested:
 193     // [    a     ]   [  d   ]
 194     //   [  b   ]
 195     //    [ c ]
 196     var sA = group.pushSlice(newSliceNamed('a', 1, 3));
 197     var sB = group.pushSlice(newSliceNamed('b', 1.5, 1));
 198     var sC = group.pushSlice(newSliceNamed('c', 1.75, 0.5));
 199     var sD = group.pushSlice(newSliceNamed('d', 5, 0.25));
 200
 201     group.createSubSlices();
 202
 203     assertEquals(2, group.topLevelSlices.length);
 204     assertArrayEquals([sA, sD], group.topLevelSlices);
 205
 206     assertEquals(1, sA.subSlices.length);
 207     assertArrayEquals([sB], sA.subSlices);
 208     assertEquals(2, sA.selfTime);
 209
 210     assertTrue(sB.parentSlice == sA);
 211     assertEquals(1, sB.subSlices.length);
 212     assertArrayEquals([sC], sB.subSlices);
 213     assertEquals(0.5, sB.selfTime);
 214
 215     assertTrue(sC.parentSlice == sB);
 216   });
 217
 218   test('subSlicesBuilderTolerateFPInaccuracy', function() {
 219     var group = new SliceGroup();
 220
 221     // Pattern being tested:
 222     // [  a  ]
 223     // [  b  ] where b.end contains a tiny FP calculation error.
 224     var sA = group.pushSlice(newSliceNamed('a', 1, 3));
 225     var sB = group.pushSlice(newSliceNamed('b', 1, 3.0000000001));
 226
 227     group.createSubSlices();
 228
 229     assertEquals(1, group.topLevelSlices.length);
 230     assertArrayEquals([sA], group.topLevelSlices);
 231
 232     assertEquals(1, sA.subSlices.length);
 233     assertArrayEquals([sB], sA.subSlices);
 234     assertTrue(sB.parentSlice == sA);
 235   });
 236
 237   test('basicMerge', function() {
 238     var a = new SliceGroup();
 239     var b = new SliceGroup();
 240     a.beginSlice('', 'one', 1);
 241     a.endSlice(2);
 242     b.beginSlice('', 'two', 3);
 243     b.endSlice(5);
 244
 245     var m = SliceGroup.merge(a, b);
 246     assertEquals(2, m.slices.length);
 247
 248     assertEquals('one', m.slices[0].title);
 249     assertEquals(1, m.slices[0].start);
 250     assertEquals(1, m.slices[0].duration);
 251
 252     assertEquals('two', m.slices[1].title);
 253     assertEquals(3, m.slices[1].start);
 254     assertEquals(2, m.slices[1].duration);
 255   });
 256
 257   test('nestedMerge', function() {
 258     var a = new SliceGroup();
 259     var b = new SliceGroup();
 260     a.beginSlice('', 'one', 1);
 261     a.endSlice(4);
 262     b.beginSlice('', 'two', 2);
 263     b.endSlice(3);
 264
 265     var m = SliceGroup.merge(a, b);
 266     assertEquals(2, m.slices.length);
 267
 268     assertEquals('one', m.slices[0].title);
 269     assertEquals(1, m.slices[0].start);
 270     assertEquals(3, m.slices[0].duration);
 271
 272     assertEquals('two', m.slices[1].title);
 273     assertEquals(2, m.slices[1].start);
 274     assertEquals(1, m.slices[1].duration);
 275   });
 276
 277   test('startSplitMerge', function() {
 278     var a = new SliceGroup();
 279     var b = new SliceGroup();
 280     a.beginSlice('', 'one', 2);
 281     a.endSlice(4);
 282     b.beginSlice('', 'two', 1);
 283     b.endSlice(3);
 284
 285     var m = SliceGroup.merge(a, b);
 286     assertEquals(3, m.slices.length);
 287
 288     assertEquals('two', m.slices[0].title);
 289     assertEquals(1, m.slices[0].start);
 290     assertEquals(1, m.slices[0].duration);
 291
 292     assertEquals('one', m.slices[1].title);
 293     assertEquals(2, m.slices[1].start);
 294     assertEquals(2, m.slices[1].duration);
 295
 296     assertEquals('two (cont.)', m.slices[2].title);
 297     assertEquals(2, m.slices[2].start);
 298     assertEquals(1, m.slices[2].duration);
 299   });
 300
 301   test('startSplitTwoMerge', function() {
 302     var a = new SliceGroup();
 303     var b = new SliceGroup();
 304     a.beginSlice('', 'one', 3);
 305     a.endSlice(6);
 306     b.beginSlice('', 'two', 1);
 307     b.beginSlice('', 'three', 2);
 308     b.endSlice(4);
 309     b.endSlice(5);
 310
 311     var m = SliceGroup.merge(a, b);
 312     assertEquals(5, m.slices.length);
 313
 314     assertEquals('two', m.slices[0].title);
 315     assertEquals(1, m.slices[0].start);
 316     assertEquals(2, m.slices[0].duration);
 317
 318     assertEquals('three', m.slices[1].title);
 319     assertEquals(2, m.slices[1].start);
 320     assertEquals(1, m.slices[1].duration);
 321
 322     assertEquals('one', m.slices[2].title);
 323     assertEquals(3, m.slices[2].start);
 324     assertEquals(3, m.slices[2].duration);
 325
 326     assertEquals('two (cont.)', m.slices[3].title);
 327     assertEquals(3, m.slices[3].start);
 328     assertEquals(2, m.slices[3].duration);
 329
 330     assertEquals('three (cont.)', m.slices[4].title);
 331     assertEquals(3, m.slices[4].start);
 332     assertEquals(1, m.slices[4].duration);
 333   });
 334
 335   test('startSplitTwiceMerge', function() {
 336     var a = new SliceGroup();
 337     var b = new SliceGroup();
 338     a.beginSlice('', 'one', 2);
 339     a.beginSlice('', 'two', 3);
 340     a.endSlice(5);
 341     a.endSlice(6);
 342     b.beginSlice('', 'three', 1);
 343     b.endSlice(4);
 344
 345     var m = SliceGroup.merge(a, b);
 346     assertEquals(5, m.slices.length);
 347
 348     assertEquals('three', m.slices[0].title);
 349     assertEquals(1, m.slices[0].start);
 350     assertEquals(1, m.slices[0].duration);
 351
 352     assertEquals('one', m.slices[1].title);
 353     assertEquals(2, m.slices[1].start);
 354     assertEquals(4, m.slices[1].duration);
 355
 356     assertEquals('three (cont.)', m.slices[2].title);
 357     assertEquals(2, m.slices[2].start);
 358     assertEquals(1, m.slices[2].duration);
 359
 360     assertEquals('two', m.slices[3].title);
 361     assertEquals(3, m.slices[3].start);
 362     assertEquals(2, m.slices[3].duration);
 363
 364     assertEquals('three (cont.)', m.slices[4].title);
 365     assertEquals(3, m.slices[4].start);
 366     assertEquals(1, m.slices[4].duration);
 367   });
 368
 369   test('endSplitMerge', function() {
 370     var a = new SliceGroup();
 371     var b = new SliceGroup();
 372     a.beginSlice('', 'one', 1);
 373     a.endSlice(3);
 374     b.beginSlice('', 'two', 2);
 375     b.endSlice(4);
 376
 377     var m = SliceGroup.merge(a, b);
 378     assertEquals(3, m.slices.length);
 379
 380     assertEquals('one', m.slices[0].title);
 381     assertEquals(1, m.slices[0].start);
 382     assertEquals(2, m.slices[0].duration);
 383
 384     assertEquals('two', m.slices[1].title);
 385     assertEquals(2, m.slices[1].start);
 386     assertEquals(1, m.slices[1].duration);
 387
 388     assertEquals('two (cont.)', m.slices[2].title);
 389     assertEquals(3, m.slices[2].start);
 390     assertEquals(1, m.slices[2].duration);
 391   });
 392
 393   test('endSplitTwoMerge', function() {
 394     var a = new SliceGroup();
 395     var b = new SliceGroup();
 396     a.beginSlice('', 'one', 1);
 397     a.endSlice(4);
 398     b.beginSlice('', 'two', 2);
 399     b.beginSlice('', 'three', 3);
 400     b.endSlice(5);
 401     b.endSlice(6);
 402
 403     var m = SliceGroup.merge(a, b);
 404     assertEquals(5, m.slices.length);
 405
 406     assertEquals('one', m.slices[0].title);
 407     assertEquals(1, m.slices[0].start);
 408     assertEquals(3, m.slices[0].duration);
 409
 410     assertEquals('two', m.slices[1].title);
 411     assertEquals(2, m.slices[1].start);
 412     assertEquals(2, m.slices[1].duration);
 413
 414     assertEquals('three', m.slices[2].title);
 415     assertEquals(3, m.slices[2].start);
 416     assertEquals(1, m.slices[2].duration);
 417
 418     assertEquals('two (cont.)', m.slices[3].title);
 419     assertEquals(4, m.slices[3].start);
 420     assertEquals(2, m.slices[3].duration);
 421
 422     assertEquals('three (cont.)', m.slices[4].title);
 423     assertEquals(4, m.slices[4].start);
 424     assertEquals(1, m.slices[4].duration);
 425   });
 426
 427   test('endSplitTwiceMerge', function() {
 428     var a = new SliceGroup();
 429     var b = new SliceGroup();
 430     a.beginSlice('', 'one', 1);
 431     a.beginSlice('', 'two', 2);
 432     a.endSlice(4);
 433     a.endSlice(5);
 434     b.beginSlice('', 'three', 3);
 435     b.endSlice(6);
 436
 437     var m = SliceGroup.merge(a, b);
 438     assertEquals(5, m.slices.length);
 439
 440     assertEquals('one', m.slices[0].title);
 441     assertEquals(1, m.slices[0].start);
 442     assertEquals(4, m.slices[0].duration);
 443
 444     assertEquals('two', m.slices[1].title);
 445     assertEquals(2, m.slices[1].start);
 446     assertEquals(2, m.slices[1].duration);
 447
 448     assertEquals('three', m.slices[2].title);
 449     assertEquals(3, m.slices[2].start);
 450     assertEquals(1, m.slices[2].duration);
 451
 452     assertEquals('three (cont.)', m.slices[3].title);
 453     assertEquals(4, m.slices[3].start);
 454     assertEquals(1, m.slices[3].duration);
 455
 456     assertEquals('three (cont.)', m.slices[4].title);
 457     assertEquals(5, m.slices[4].start);
 458     assertEquals(1, m.slices[4].duration);
 459   });
 460
 461   // Input:
 462   // A:  |    one     |       |     two     |
 463   //
 464   // B:       |         three         |
 465   //
 466   // Output:
 467   //     |    one     | three |     two     |
 468   //          | three |       | three |
 469   test('splitTwiceMerge', function() {
 470     var a = new SliceGroup();
 471     var b = new SliceGroup();
 472     a.beginSlice('', 'one', 1);
 473     a.endSlice(3);
 474     a.beginSlice('', 'two', 4);
 475     a.endSlice(6);
 476     b.beginSlice('', 'three', 2);
 477     b.endSlice(5);
 478
 479     var m = SliceGroup.merge(a, b);
 480     assertEquals(5, m.slices.length);
 481
 482     assertEquals('one', m.slices[0].title);
 483     assertEquals(1, m.slices[0].start);
 484     assertEquals(2, m.slices[0].duration);
 485
 486     assertEquals('three', m.slices[1].title);
 487     assertEquals(2, m.slices[1].start);
 488     assertEquals(1, m.slices[1].duration);
 489
 490     assertEquals('three (cont.)', m.slices[2].title);
 491     assertEquals(3, m.slices[2].start);
 492     assertEquals(1, m.slices[2].duration);
 493
 494     assertEquals('two', m.slices[3].title);
 495     assertEquals(4, m.slices[3].start);
 496     assertEquals(2, m.slices[3].duration);
 497
 498     assertEquals('three (cont.)', m.slices[4].title);
 499     assertEquals(4, m.slices[4].start);
 500     assertEquals(1, m.slices[4].duration);
 501   });
 502
 503   test('bounds', function() {
 504     var group = new SliceGroup();
 505     group.updateBounds();
 506     assertEquals(group.bounds.min, undefined);
 507     assertEquals(group.bounds.max, undefined);
 508
 509     group.pushSlice(newSlice(1, 3));
 510     group.pushSlice(newSlice(7, 2));
 511     group.updateBounds();
 512     assertEquals(1, group.bounds.min);
 513     assertEquals(9, group.bounds.max);
 514   });
 515
 516   test('boundsWithPartial', function() {
 517     var group = new SliceGroup();
 518     group.beginSlice('', 'a', 7);
 519     group.updateBounds();
 520     assertEquals(7, group.bounds.min);
 521     assertEquals(7, group.bounds.max);
 522   });
 523
 524   test('boundsWithTwoPartials', function() {
 525     var group = new SliceGroup();
 526     group.beginSlice('', 'a', 0);
 527     group.beginSlice('', 'a', 1);
 528     group.updateBounds();
 529     assertEquals(0, group.bounds.min);
 530     assertEquals(1, group.bounds.max);
 531   });
 532
 533   test('boundsWithBothPartialAndRegular', function() {
 534     var group = new SliceGroup();
 535     group.updateBounds();
 536     assertEquals(undefined, group.bounds.min);
 537     assertEquals(undefined, group.bounds.max);
 538
 539     group.pushSlice(newSlice(1, 3));
 540     group.beginSlice('', 'a', 7);
 541     group.updateBounds();
 542     assertEquals(1, group.bounds.min);
 543     assertEquals(7, group.bounds.max);
 544   });
 545
 546   test('autocloserBasic', function() {
 547     var group = new SliceGroup();
 548     assertEquals(group.openSliceCount, 0);
 549
 550     group.pushSlice(newSliceNamed('a', 1, 0.5));
 551
 552     group.beginSlice('', 'b', 2);
 553     group.beginSlice('', 'c', 2.5);
 554     group.endSlice(3);
 555
 556     group.autoCloseOpenSlices();
 557     group.updateBounds();
 558
 559     assertEquals(1, group.bounds.min);
 560     assertEquals(3, group.bounds.max);
 561     assertEquals(3, group.slices.length);
 562
 563     assertEquals('a', group.slices[0].title);
 564     assertFalse(group.slices[0].didNotFinish);
 565
 566     assertEquals('b', group.slices[1].title);
 567     assertTrue(group.slices[1].didNotFinish);
 568     assertEquals(1, group.slices[1].duration);
 569
 570     assertEquals('c', group.slices[2].title);
 571     assertFalse(group.slices[2].didNotFinish);
 572   });
 573
 574   test('autocloserWithSubTasks', function() {
 575     var group = new SliceGroup();
 576     assertEquals(group.openSliceCount, 0);
 577
 578     group.beginSlice('', 'a', 1);
 579     group.beginSlice('', 'b1', 2);
 580     group.endSlice(3);
 581     group.beginSlice('', 'b2', 3);
 582
 583     group.autoCloseOpenSlices();
 584     assertEquals(3, group.slices.length);
 585
 586     assertEquals('a', group.slices[0].title);
 587     assertTrue(group.slices[0].didNotFinish);
 588     assertEquals(2, group.slices[0].duration);
 589
 590     assertEquals('b1', group.slices[1].title);
 591     assertFalse(group.slices[1].didNotFinish);
 592     assertEquals(1, group.slices[1].duration);
 593
 594     assertEquals('b2', group.slices[2].title);
 595     assertTrue(group.slices[2].didNotFinish);
 596     assertEquals(0, group.slices[2].duration);
 597   });
 598
 599   test('autocloseCompleteSlice', function() {
 600     var group = new SliceGroup();
 601
 602     group.pushCompleteSlice('', 'a', 1, undefined);
 603     group.pushCompleteSlice('', 'b', 2, 3);
 604
 605     group.autoCloseOpenSlices();
 606     assertEquals(2, group.slices.length);
 607
 608     assertEquals('a', group.slices[0].title);
 609     assertTrue(group.slices[0].didNotFinish);
 610     assertEquals(4, group.slices[0].duration);
 611
 612     assertEquals('b', group.slices[1].title);
 613     assertFalse(group.slices[1].didNotFinish);
 614     assertEquals(3, group.slices[1].duration);
 615   });
 616 });
 617 </script>
 618