| <!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="/core/trace_model/slice_group.html"> |
| <link rel="import" href="/core/trace_model/trace_model.html"> |
| |
| <script> |
| 'use strict'; |
| |
| tv.b.unittest.testSuite(function() { |
| var Slice = tv.c.trace_model.Slice; |
| var SliceGroup = tv.c.trace_model.SliceGroup; |
| var newSlice = tv.c.test_utils.newSlice; |
| var newSliceNamed = tv.c.test_utils.newSliceNamed; |
| |
| 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]); |
| }); |
| |
| 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); |
| }); |
| |
| 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]); |
| }); |
| |
| 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); |
| }); |
| |
| 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]); |
| }); |
| |
| 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); |
| }); |
| |
| 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); |
| }); |
| |
| 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); |
| }); |
| |
| 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); |
| }); |
| |
| 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); |
| }); |
| |
| 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 tv.c.TraceModel(); |
| 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); |
| }); |
| }); |
| </script> |