<!DOCTYPE html>
<!--
Copyright (c) 2013 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.
-->

<link rel="import" href="/core/test_utils.html">
<link rel="import" href="/model/slice_group.html">
<link rel="import" href="/model/model.html">

<script>
'use strict';

tr.b.unittest.testSuite(function() {
  var Slice = tr.model.Slice;
  var SliceGroup = tr.model.SliceGroup;
  var newSlice = tr.c.test_utils.newSlice;
  var newSliceEx = tr.c.test_utils.newSliceEx;
  var newSliceNamed = tr.c.test_utils.newSliceNamed;
  var newThreadSlice = tr.c.test_utils.newThreadSlice;
  var newModel = tr.c.test_utils.newModel;

  test('basicBeginEnd', function() {
    var group = new SliceGroup({});
    assert.equal(group.openSliceCount, 0);
    var sliceA = group.beginSlice('', 'a', 1, {a: 1});
    assert.equal(group.openSliceCount, 1);
    assert.equal(sliceA.title, 'a');
    assert.equal(sliceA.start, 1);
    assert.equal(sliceA.args.a, 1);

    var sliceB = group.endSlice(3);
    assert.equal(sliceA, sliceB);
    assert.equal(sliceB.duration, 2);
  });

  test('subSlicesBuilderBasic', function() {
    var group = new SliceGroup({});
    var sA = group.pushSlice(newSliceNamed('a', 1, 2));
    var sB = group.pushSlice(newSliceNamed('b', 3, 1));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 2);
    assert.deepEqual(group.topLevelSlices, [sA, sB]);
    assert.equal(group.findSliceAtTs(0), undefined);
    assert.equal(group.findSliceAtTs(1), sA);
    assert.equal(group.findSliceAtTs(3), sA);
    assert.equal(group.findSliceAtTs(3.1), sB);
    assert.equal(group.findSliceAtTs(4), sB);
    assert.equal(group.findSliceAtTs(5), undefined);
  });

  test('subSlicesBuilderBasic2', function() {
    var group = new SliceGroup({});
    var sA = group.pushSlice(newSliceNamed('a', 1, 4));
    var sB = group.pushSlice(newSliceNamed('b', 3, 1));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 1);
    assert.deepEqual(group.topLevelSlices, [sA]);

    assert.equal(sA.subSlices.length, 1);
    assert.deepEqual(sA.subSlices, [sB]);
    assert.equal(sA.selfTime, 3);

    assert.equal(sA, sB.parentSlice);
  });

  test('subSlicesBuilderNestedExactly', function() {
    var group = new SliceGroup({});
    var sB = group.pushSlice(newSliceNamed('b', 1, 4));
    var sA = group.pushSlice(newSliceNamed('a', 1, 4));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 1);
    assert.deepEqual(group.topLevelSlices, [sB]);

    assert.equal(sB.subSlices.length, 1);
    assert.deepEqual(sB.subSlices, [sA]);
    assert.equal(sB.selfTime, 0);

    assert.equal(sB, sA.parentSlice);

    assert.equal(group.findSliceAtTs(0), undefined);
    assert.equal(group.findSliceAtTs(1), sA);
    assert.equal(group.findSliceAtTs(2), sA);
    assert.equal(group.findSliceAtTs(5), sA);
    assert.equal(group.findSliceAtTs(6), undefined);
  });

  test('subSlicesBuilderInstantEvents', function() {
    var group = new SliceGroup({});
    var sA = group.pushSlice(newSliceNamed('a', 1, 0));
    var sB = group.pushSlice(newSliceNamed('b', 2, 0));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 2);
    assert.deepEqual(group.topLevelSlices, [sA, sB]);
    assert.equal(group.findSliceAtTs(1), sA);
    assert.equal(group.findSliceAtTs(1.5), undefined);
    assert.equal(group.findSliceAtTs(2), sB);
  });

  test('subSlicesBuilderTwoInstantEvents', function() {
    var group = new SliceGroup({});
    var sA = group.pushSlice(newSliceNamed('a', 1, 0));
    var sB = group.pushSlice(newSliceNamed('b', 1, 0));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 1);
    assert.deepEqual(group.topLevelSlices, [sA]);

    assert.equal(sA.subSlices.length, 1);
    assert.deepEqual(sA.subSlices, [sB]);
    assert.equal(sA.selfTime, 0);

    assert.equal(sA, sB.parentSlice);
    assert.equal(group.findSliceAtTs(1), sB);
    assert.equal(group.findSliceAtTs(1.0001), undefined);
  });

  test('subSlicesBuilderOutOfOrderAddition', function() {
    var group = new SliceGroup({});

    // Pattern being tested:
    // [    a     ][   b   ]
    // Where insertion is done backward.
    var sB = group.pushSlice(newSliceNamed('b', 3, 1));
    var sA = group.pushSlice(newSliceNamed('a', 1, 2));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 2);
    assert.deepEqual(group.topLevelSlices, [sA, sB]);
    assert.equal(group.findSliceAtTs(3), sA);
  });

  test('subRowBuilderOutOfOrderAddition2', function() {
    var group = new SliceGroup({});

    // Pattern being tested:
    // [    a     ]
    //   [  b   ]
    // Where insertion is done backward.
    var sB = group.pushSlice(newSliceNamed('b', 3, 1));
    var sA = group.pushSlice(newSliceNamed('a', 1, 5));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 1);
    assert.deepEqual(group.topLevelSlices, [sA]);

    assert.equal(sA.subSlices.length, 1);
    assert.deepEqual(sA.subSlices, [sB]);
    assert.equal(sA.selfTime, 4);

    assert.equal(sA, sB.parentSlice);
    assert.equal(group.findSliceAtTs(1.5), sA);
    assert.equal(group.findSliceAtTs(3), sB);
    assert.equal(group.findSliceAtTs(3.5), sB);
    assert.equal(group.findSliceAtTs(4), sB);
    assert.equal(group.findSliceAtTs(4.5), sA);
  });

  test('subSlicesBuilderOnNestedZeroLength', function() {
    var group = new SliceGroup({});

    // Pattern being tested:
    // [    a    ]
    // [  b1 ]  []<- b2 where b2.duration = 0 and b2.end == a.end.
    var sA = group.pushSlice(newSliceNamed('a', 1, 3));
    var sB1 = group.pushSlice(newSliceNamed('b1', 1, 2));
    var sB2 = group.pushSlice(newSliceNamed('b2', 4, 0));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 1);
    assert.deepEqual(group.topLevelSlices, [sA]);

    assert.equal(sA.subSlices.length, 2);
    assert.deepEqual(sA.subSlices, [sB1, sB2]);
    assert.equal(sA.selfTime, 1);

    assert.equal(sA, sB1.parentSlice);
    assert.equal(sA, sB2.parentSlice);
    assert.equal(group.findSliceAtTs(1), sB1);
    assert.equal(group.findSliceAtTs(4), sB2);
  });

  test('subSlicesBuilderOnGroup1', function() {
    var group = new SliceGroup({});

    // Pattern being tested:
    // [    a     ]   [  c   ]
    //   [  b   ]
    var sA = group.pushSlice(newSliceNamed('a', 1, 3));
    var sB = group.pushSlice(newSliceNamed('b', 1.5, 1));
    var sC = group.pushSlice(newSliceNamed('c', 5, 0));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 2);
    assert.deepEqual(group.topLevelSlices, [sA, sC]);

    assert.equal(sA.subSlices.length, 1);
    assert.deepEqual(sA.subSlices, [sB]);
    assert.equal(sA.selfTime, 2);

    assert.equal(sA, sB.parentSlice);
    assert.equal(group.findSliceAtTs(1), sA);
    assert.equal(group.findSliceAtTs(2), sB);
    assert.equal(group.findSliceAtTs(3), sA);
    assert.equal(group.findSliceAtTs(4.5), undefined);
    assert.equal(group.findSliceAtTs(5), sC);
  });

  test('subSlicesBuilderOnGroup2', function() {
    var group = new SliceGroup({});

    // Pattern being tested:
    // [    a     ]   [  d   ]
    //   [  b   ]
    //    [ c ]
    var sA = group.pushSlice(newSliceNamed('a', 1, 3));
    var sB = group.pushSlice(newSliceNamed('b', 1.5, 1));
    var sC = group.pushSlice(newSliceNamed('c', 1.75, 0.5));
    var sD = group.pushSlice(newSliceNamed('d', 5, 0.25));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 2);
    assert.deepEqual(group.topLevelSlices, [sA, sD]);

    assert.equal(sA.subSlices.length, 1);
    assert.deepEqual(sA.subSlices, [sB]);
    assert.equal(sA.selfTime, 2);

    assert.equal(sA, sB.parentSlice);
    assert.equal(sB.subSlices.length, 1);
    assert.deepEqual(sB.subSlices, [sC]);
    assert.equal(sB.selfTime, 0.5);

    assert.equal(sB, sC.parentSlice);
    assert.equal(group.findSliceAtTs(2), sC);
  });

  test('findNextSliceAfterBasic', function() {
    var group = new SliceGroup({});
    // Pattern being tested:
    // [        a         ] [   d    ]
    // [b]    [   c   ]                 where b is dur=0
    var sA = group.pushSlice(newSliceEx({title: 'a', start: 1, end: 4}));
    var sB = group.pushSlice(newSliceEx({title: 'b', start: 1, end: 1}));
    var sC = group.pushSlice(newSliceEx({title: 'c', start: 2, end: 3}));
    var sD = group.pushSlice(newSliceEx({title: 'd', start: 5, end: 6}));

    group.createSubSlices();

    assert.equal(group.findNextSliceAfter(0, 0), sA);
    assert.equal(group.findNextSliceAfter(1, sA.guid), sB);
    assert.equal(group.findNextSliceAfter(1, sB.guid), sC);
    assert.equal(group.findNextSliceAfter(2, sC.guid), sD);
    assert.equal(group.findNextSliceAfter(6, 0), undefined);
  });

  test('subSlicesBuilderTolerateFPInaccuracy', function() {
    var group = new SliceGroup({});

    // Pattern being tested:
    // [  a  ]
    // [  b  ] where b.end contains a tiny FP calculation error.
    var sA = group.pushSlice(newSliceNamed('a', 1, 3));
    var sB = group.pushSlice(newSliceNamed('b', 1, 3.0000000001));

    group.createSubSlices();

    assert.equal(group.topLevelSlices.length, 1);
    assert.deepEqual(group.topLevelSlices, [sA]);

    assert.equal(sA.subSlices.length, 1);
    assert.deepEqual(sA.subSlices, [sB]);
    assert.equal(sA, sB.parentSlice);
    assert.equal(group.findSliceAtTs(1), sB);
    assert.equal(group.findSliceAtTs(3), sB);
  });

  test('basicMerge', function() {
    function TestSlice(
        cat, title, colorId, start, args, opt_duration,
        opt_cpuStart, opt_cpuDuration) {
      Slice.call(this, cat, title, colorId, start, args, opt_duration,
                 opt_cpuStart, opt_cpuDuration);
    }
    TestSlice.prototype = {
      __proto__: Slice.prototype
    };

    var thread = {};
    var a = new SliceGroup(thread, TestSlice);
    var b = new SliceGroup(thread, TestSlice);
    a.beginSlice('', 'one', 1);
    a.endSlice(2);
    b.beginSlice('', 'two', 3);
    b.endSlice(5);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 2);

    assert.equal(m.slices[0].title, 'one');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 1);

    assert.equal(m.slices[1].title, 'two');
    assert.equal(m.slices[1].start, 3);
    assert.equal(m.slices[1].duration, 2);

    // ensure constructor merged correctly
    assert.equal(m.sliceConstructor, TestSlice);
  });

  test('nestedMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 1);
    a.endSlice(4);
    b.beginSlice('', 'two', 2);
    b.endSlice(3);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 2);

    assert.equal(m.slices[0].title, 'one');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 3);

    assert.equal(m.slices[1].title, 'two');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 1);
  });

  test('startSplitMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 2);
    a.endSlice(4);
    b.beginSlice('', 'two', 1);
    b.endSlice(3);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 3);

    assert.equal(m.slices[0].title, 'two');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 1);

    assert.equal(m.slices[1].title, 'one');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 2);

    assert.equal(m.slices[2].title, 'two (cont.)');
    assert.equal(m.slices[2].start, 2);
    assert.equal(m.slices[2].duration, 1);
  });

  test('startSplitTwoMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 3);
    a.endSlice(6);
    b.beginSlice('', 'two', 1);
    b.beginSlice('', 'three', 2);
    b.endSlice(4);
    b.endSlice(5);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 5);

    assert.equal(m.slices[0].title, 'two');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 2);

    assert.equal(m.slices[1].title, 'three');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 1);

    assert.equal(m.slices[2].title, 'one');
    assert.equal(m.slices[2].start, 3);
    assert.equal(m.slices[2].duration, 3);

    assert.equal(m.slices[3].title, 'two (cont.)');
    assert.equal(m.slices[3].start, 3);
    assert.equal(m.slices[3].duration, 2);

    assert.equal(m.slices[4].title, 'three (cont.)');
    assert.equal(m.slices[4].start, 3);
    assert.equal(m.slices[4].duration, 1);
  });

  test('startSplitTwiceMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 2);
    a.beginSlice('', 'two', 3);
    a.endSlice(5);
    a.endSlice(6);
    b.beginSlice('', 'three', 1);
    b.endSlice(4);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 5);

    assert.equal(m.slices[0].title, 'three');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 1);

    assert.equal(m.slices[1].title, 'one');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 4);

    assert.equal(m.slices[2].title, 'three (cont.)');
    assert.equal(m.slices[2].start, 2);
    assert.equal(m.slices[2].duration, 1);

    assert.equal(m.slices[3].title, 'two');
    assert.equal(m.slices[3].start, 3);
    assert.equal(m.slices[3].duration, 2);

    assert.equal(m.slices[4].title, 'three (cont.)');
    assert.equal(m.slices[4].start, 3);
    assert.equal(m.slices[4].duration, 1);
  });

  test('endSplitMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 1);
    a.endSlice(3);
    b.beginSlice('', 'two', 2);
    b.endSlice(4);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 3);

    assert.equal(m.slices[0].title, 'one');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 2);

    assert.equal(m.slices[1].title, 'two');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 1);

    assert.equal(m.slices[2].title, 'two (cont.)');
    assert.equal(m.slices[2].start, 3);
    assert.equal(m.slices[2].duration, 1);
  });

  test('endSplitTwoMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 1);
    a.endSlice(4);
    b.beginSlice('', 'two', 2);
    b.beginSlice('', 'three', 3);
    b.endSlice(5);
    b.endSlice(6);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 5);

    assert.equal(m.slices[0].title, 'one');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 3);

    assert.equal(m.slices[1].title, 'two');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 2);

    assert.equal(m.slices[2].title, 'three');
    assert.equal(m.slices[2].start, 3);
    assert.equal(m.slices[2].duration, 1);

    assert.equal(m.slices[3].title, 'two (cont.)');
    assert.equal(m.slices[3].start, 4);
    assert.equal(m.slices[3].duration, 2);

    assert.equal(m.slices[4].title, 'three (cont.)');
    assert.equal(m.slices[4].start, 4);
    assert.equal(m.slices[4].duration, 1);
  });

  test('endSplitTwiceMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 1);
    a.beginSlice('', 'two', 2);
    a.endSlice(4);
    a.endSlice(5);
    b.beginSlice('', 'three', 3);
    b.endSlice(6);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 5);

    assert.equal(m.slices[0].title, 'one');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 4);

    assert.equal(m.slices[1].title, 'two');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 2);

    assert.equal(m.slices[2].title, 'three');
    assert.equal(m.slices[2].start, 3);
    assert.equal(m.slices[2].duration, 1);

    assert.equal(m.slices[3].title, 'three (cont.)');
    assert.equal(m.slices[3].start, 4);
    assert.equal(m.slices[3].duration, 1);

    assert.equal(m.slices[4].title, 'three (cont.)');
    assert.equal(m.slices[4].start, 5);
    assert.equal(m.slices[4].duration, 1);
  });

  // Input:
  // A:  |    one     |       |     two     |
  //
  // B:       |         three         |
  //
  // Output:
  //     |    one     | three |     two     |
  //          | three |       | three |
  test('splitTwiceMerge', function() {
    var thread = {};
    var a = new SliceGroup(thread);
    var b = new SliceGroup(thread);
    a.beginSlice('', 'one', 1);
    a.endSlice(3);
    a.beginSlice('', 'two', 4);
    a.endSlice(6);
    b.beginSlice('', 'three', 2);
    b.endSlice(5);

    var m = SliceGroup.merge(a, b);
    assert.equal(m.slices.length, 5);

    assert.equal(m.slices[0].title, 'one');
    assert.equal(m.slices[0].start, 1);
    assert.equal(m.slices[0].duration, 2);

    assert.equal(m.slices[1].title, 'three');
    assert.equal(m.slices[1].start, 2);
    assert.equal(m.slices[1].duration, 1);

    assert.equal(m.slices[2].title, 'three (cont.)');
    assert.equal(m.slices[2].start, 3);
    assert.equal(m.slices[2].duration, 1);

    assert.equal(m.slices[3].title, 'two');
    assert.equal(m.slices[3].start, 4);
    assert.equal(m.slices[3].duration, 2);

    assert.equal(m.slices[4].title, 'three (cont.)');
    assert.equal(m.slices[4].start, 4);
    assert.equal(m.slices[4].duration, 1);
  });

  test('bounds', function() {
    var group = new SliceGroup({});
    group.updateBounds();
    assert.isUndefined(group.bounds.min);
    assert.isUndefined(group.bounds.max);

    group.pushSlice(newSlice(1, 3));
    group.pushSlice(newSlice(7, 2));
    group.updateBounds();
    assert.equal(group.bounds.min, 1);
    assert.equal(group.bounds.max, 9);
  });

  test('boundsWithPartial', function() {
    var group = new SliceGroup({});
    group.beginSlice('', 'a', 7);
    group.updateBounds();
    assert.equal(group.bounds.min, 7);
    assert.equal(group.bounds.max, 7);
  });

  test('boundsWithTwoPartials', function() {
    var group = new SliceGroup({});
    group.beginSlice('', 'a', 0);
    group.beginSlice('', 'a', 1);
    group.updateBounds();
    assert.equal(group.bounds.min, 0);
    assert.equal(group.bounds.max, 1);
  });

  test('boundsWithBothPartialAndRegular', function() {
    var group = new SliceGroup({});
    group.updateBounds();
    assert.isUndefined(group.bounds.min);
    assert.isUndefined(group.bounds.max);

    group.pushSlice(newSlice(1, 3));
    group.beginSlice('', 'a', 7);
    group.updateBounds();
    assert.equal(group.bounds.min, 1);
    assert.equal(group.bounds.max, 7);
  });

  test('autocloserBasic', function() {
    var group = new SliceGroup({});
    assert.equal(0, group.openSliceCount);

    group.pushSlice(newSliceNamed('a', 1, 0.5));

    group.beginSlice('', 'b', 2);
    group.beginSlice('', 'c', 2.5);
    group.endSlice(3);

    group.autoCloseOpenSlices();
    group.updateBounds();

    assert.equal(group.bounds.min, 1);
    assert.equal(group.bounds.max, 3);
    assert.equal(group.slices.length, 3);

    assert.equal(group.slices[0].title, 'a');
    assert.isFalse(group.slices[0].didNotFinish);

    assert.equal(group.slices[1].title, 'b');
    assert.isTrue(group.slices[1].didNotFinish);
    assert.equal(group.slices[1].duration, 1);

    assert.equal(group.slices[2].title, 'c');
    assert.isFalse(group.slices[2].didNotFinish);
  });

  test('autocloserWithSubTasks', function() {
    var group = new SliceGroup({});
    assert.equal(0, group.openSliceCount);

    group.beginSlice('', 'a', 1);
    group.beginSlice('', 'b1', 2);
    group.endSlice(3);
    group.beginSlice('', 'b2', 3);

    group.autoCloseOpenSlices();
    assert.equal(group.slices.length, 3);

    assert.equal(group.slices[0].title, 'a');
    assert.isTrue(group.slices[0].didNotFinish);
    assert.equal(group.slices[0].duration, 2);

    assert.equal(group.slices[1].title, 'b1');
    assert.isFalse(group.slices[1].didNotFinish);
    assert.equal(group.slices[1].duration, 1);

    assert.equal(group.slices[2].title, 'b2');
    assert.isTrue(group.slices[2].didNotFinish);
    assert.equal(group.slices[2].duration, 0);
  });

  test('autocloseCompleteSlice', function() {
    var group = new SliceGroup({});

    group.pushCompleteSlice('', 'a', 1, undefined);
    group.pushCompleteSlice('', 'b', 2, 3);

    group.autoCloseOpenSlices();
    assert.equal(group.slices.length, 2);

    assert.equal(group.slices[0].title, 'a');
    assert.isTrue(group.slices[0].didNotFinish);
    assert.equal(group.slices[0].duration, 4);

    assert.equal(group.slices[1].title, 'b');
    assert.isFalse(group.slices[1].didNotFinish);
    assert.equal(group.slices[1].duration, 3);
  });

  test('sliceGroupStableId', function() {
    var model = new tr.Model();
    var process = model.getOrCreateProcess(123);
    var thread = process.getOrCreateThread(456);
    var group = new SliceGroup(thread);

    assert.equal(process.stableId, 123);
    assert.equal(thread.stableId, '123.456');
    assert.equal(group.stableId, '123.456.SliceGroup');
  });

  test('getSlicesOfName', function() {
    var group = new SliceGroup({});
    var expected = [];

    for (var i = 0; i < 10; i++) {
      var aSlice = newSliceNamed('a', i, i + 1);
      group.pushSlice(aSlice);
      group.pushSlice(newSliceNamed('b', i + 1, i + 2));
      expected.push(aSlice);
    }

    assert.deepEqual(group.getSlicesOfName('a'), expected);
  });

  test('iterSlicesInTimeRange', function() {
    var group = new SliceGroup({});
    var expected = [];

    for (var i = 0; i < 10; i++) {
      var slice = newSliceNamed('a', i, 1);
      group.pushSlice(slice);
      if (4 <= i && i <= 7)
        expected.push(slice);
    }
    group.createSubSlices();

    var observed = [];
    group.iterSlicesInTimeRange(function(slice) { observed.push(slice); },
                                4.5, 7.5);
    assert.deepEqual(observed, expected);
  });

  test('computeCpuDurationNoOverlap', function() {
    var model = new tr.Model();
    var SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
    var process = model.getOrCreateProcess(123);
    var t = process.getOrCreateThread(456);
    t.timeSlices = [newThreadSlice(t, SCHEDULING_STATE.RUNNING, 20, 20),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 40, 10),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 50, 10)];
    var group = new SliceGroup(t);
    group.pushSlice(newSliceNamed('draw', 0, 20));
    group.pushSlice(newSliceNamed('render', 60, 20));
    group.createSubSlices();
    assert.equal(group.slices[0].cpuDuration, 0);
    assert.equal(group.slices[1].cpuDuration, 0);
  });

  test('computeCpuDurationPartialOverlap', function() {
    var model = new tr.Model();
    var SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
    var process = model.getOrCreateProcess(123);
    var t = process.getOrCreateThread(456);
    t.timeSlices = [newThreadSlice(t, SCHEDULING_STATE.RUNNING, 20, 20),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 40, 10),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 50, 10)];
    var group = new SliceGroup(t);
    group.pushSlice(newSliceNamed('draw', 10, 30));
    group.pushSlice(newSliceNamed('render', 50, 20));
    group.createSubSlices();
    assert.equal(group.slices[0].cpuDuration, 20);
    assert.equal(group.slices[1].cpuDuration, 10);
  });

  test('computeCpuDurationFullOverlap', function() {
    var model = new tr.Model();
    var SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
    var process = model.getOrCreateProcess(123);
    var t = process.getOrCreateThread(456);
    t.timeSlices = [newThreadSlice(t, SCHEDULING_STATE.RUNNING, 20, 20),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 40, 10),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 50, 20)];
    var group = new SliceGroup(t);
    group.pushSlice(newSliceNamed('draw', 20, 30));
    group.pushSlice(newSliceNamed('render', 50, 20));
    group.createSubSlices();
    assert.equal(group.slices[0].cpuDuration, 20);
    assert.equal(group.slices[1].cpuDuration, 20);
  });

  test('computeCpuSelfDurationWithSubslices', function() {
    var model = new tr.Model();
    var SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
    var process = model.getOrCreateProcess(123);
    var t = process.getOrCreateThread(456);
    t.timeSlices = [newThreadSlice(t, SCHEDULING_STATE.RUNNING, 20, 20),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 40, 10),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 50, 20)];
    var group = new SliceGroup(t);
    group.pushSlice(newSliceNamed('draw', 20, 30));
    group.pushSlice(newSliceNamed('render', 21, 8));
    group.pushSlice(newSliceNamed('flush', 29, 11));
    group.createSubSlices();
    assert.equal(group.slices[0].cpuDuration, 20);
    assert.equal(group.slices[0].cpuSelfTime, 1);
    assert.equal(group.slices[1].cpuDuration, 8);
    assert.equal(group.slices[1].cpuSelfTime, 8);
    assert.equal(group.slices[2].cpuDuration, 11);
    assert.equal(group.slices[2].cpuSelfTime, 11);
  });

  test('computeCpuDurationSmallTimeslices', function() {
    var model = new tr.Model();
    var SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
    var process = model.getOrCreateProcess(123);
    var t = process.getOrCreateThread(456);
    t.timeSlices = [newThreadSlice(t, SCHEDULING_STATE.RUNNING, 20, 1),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 21, 1),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 22, 1),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 23, 1),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 24, 1),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 25, 1),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 26, 1),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 27, 1),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 28, 1),
                    newThreadSlice(t, SCHEDULING_STATE.SLEEPING, 29, 1),
                    newThreadSlice(t, SCHEDULING_STATE.RUNNING, 30, 1)];
    var group = new SliceGroup(t);
    group.pushSlice(newSliceNamed('draw', 20, 11)); // 20,[22,24,26,28],30
    group.pushSlice(newSliceNamed('render', 22, 8)); // 22,[24, 26, 28]
    group.pushSlice(newSliceNamed('flush', 24, 6)); // 24, 26, 28
    group.createSubSlices();
    assert.equal(group.slices[0].cpuDuration, 6);
    assert.equal(group.slices[0].cpuSelfTime, 2);
    assert.equal(group.slices[1].cpuDuration, 4);
    assert.equal(group.slices[1].cpuSelfTime, 1);
    assert.equal(group.slices[2].cpuDuration, 3);
    assert.equal(group.slices[2].cpuSelfTime, 3);
  });

  test('sliceParentContainerSetAtPush', function() {
    var m = newModel(function(m) {
      m.process = m.getOrCreateProcess(123);
      m.thread = m.process.getOrCreateThread(456);
      m.group = new SliceGroup(m.thread);

      m.sA = m.group.pushSlice(newSliceEx(
          { title: 'sA', start: 0.0, duration: 10.0 }));

      m.group.createSubSlices();
    });

    assert.deepEqual(m.sA.parentContainer, m.thread);
  });
});
</script>