catapult/tracing/tracing/model/event_set_test.html - platform/external/chromium-trace - Git at Google

 <!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="/tracing/base/iteration_helpers.html">
 <link rel="import" href="/tracing/core/test_utils.html">
 <link rel="import" href="/tracing/model/event_set.html">
 <link rel="import" href="/tracing/model/model.html">

 <script>
 'use strict';

 tr.b.unittest.testSuite(function() {
   var newModel = tr.c.TestUtils.newModel;
   var newSliceEx = tr.c.TestUtils.newSliceEx;

   test('eventSetObject', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 5, {}, 1));

     var eventSet = new tr.model.EventSet();
     eventSet.push(t1.sliceGroup.slices[0]);

     assert.equal(eventSet.bounds.min, 1);
     assert.equal(eventSet.bounds.max, 4);
     assert.deepEqual(eventSet, new tr.model.EventSet(
         t1.sliceGroup.slices[0]));

     eventSet.push(t1.sliceGroup.slices[1]);
     assert.equal(eventSet.bounds.min, 1);
     assert.equal(eventSet.bounds.max, 6);
     assert.deepEqual(eventSet, new tr.model.EventSet(
         [t1.sliceGroup.slices[0], t1.sliceGroup.slices[1]]));

     eventSet.clear();
     assert.equal(eventSet.length, 0);
   });

   test('iteration', function() {
     var eventSet = new tr.model.EventSet([{guid: 1}, {guid: 2}, {guid: 3}]);

     var expectedId = 1;
     for (var event of eventSet)
       assert.equal(event.guid, expectedId++);
   });

   test('uniqueContents', function() {
     var sample1 = {guid: 1};
     var sample2 = {guid: 2};

     var eventSet = new tr.model.EventSet();

     eventSet.push(sample1);
     eventSet.push(sample2);
     assert.equal(eventSet.length, 2);

     eventSet.push(sample1);
     assert.equal(eventSet.length, 2);
   });

   test('userFriendlyNameSingular', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     var selection = new tr.model.EventSet(t1.sliceGroup.slices[0]);
     assert.isDefined(selection.userFriendlyName);
   });

   test('userFriendlyNamePlural', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
     var eventSet = new tr.model.EventSet([
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[1]
     ]);
     assert.isDefined(eventSet.userFriendlyName);
   });

   test('userFriendlyNameMixedPlural', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));

     var i10 = new tr.model.ObjectInstance(
     {}, '0x1000', 'cat', 'name', 10);
     var s10 = i10.addSnapshot(10, {foo: 1});

     var eventSet = new tr.model.EventSet([
         t1.sliceGroup.slices[0],
         s10
     ]);
     assert.isDefined(eventSet.userFriendlyName);
   });

   test('groupEventsByTitle', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'b', 0, 3, {}, 3));
     var eventSet = new tr.model.EventSet([
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[1],
         t1.sliceGroup.slices[2]
     ]);

     var eventsByTitle = eventSet.getEventsOrganizedByTitle();
     assert.equal(2, tr.b.dictionaryLength(eventsByTitle));
     assert.sameMembers(eventsByTitle['a'].toArray(),
                  [t1.sliceGroup.slices[0], t1.sliceGroup.slices[1]]);
     assert.sameMembers(eventsByTitle['b'].toArray(),
                  [t1.sliceGroup.slices[2]]);
   });

   test('groupEventsByCallback', function() {
     var a1 = new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3);
     var a2 = new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3);
     var b1 = new tr.model.ThreadSlice('', 'b', 0, 1, {}, 3);
     var eventSet = new tr.model.EventSet([a1, a2, b1]);
     function getEventKey(event) {
       return 's' + event.start;
     }
     var eventsByCallback = eventSet.getEventsOrganizedByCallback(getEventKey);
     assert.equal(2, tr.b.dictionaryLength(eventsByCallback));
     assert.sameMembers(eventsByCallback.s1.toArray(), [a1, b1]);
     assert.sameMembers(eventsByCallback.s2.toArray(), [a2]);
   });

   test('groupEventsByBaseType', function() {
     var a = new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3);
     var b = new tr.model.ThreadSlice('', 'b', 0, 1, {}, 3);
     var c = new tr.model.AsyncSlice('', 'c', 0, 1, {}, 3);
     var eventSet = new tr.model.EventSet([a, b, c]);
     var eventsByBaseType = eventSet.getEventsOrganizedByBaseType(true);
     assert.equal(2, tr.b.dictionaryLength(eventsByBaseType));
     assert.sameMembers(eventsByBaseType.slice.toArray(), [a, b]);
     assert.sameMembers(eventsByBaseType.asyncSlice.toArray(), [c]);

     var eventsByBaseType = eventSet.getEventsOrganizedByBaseType(false);
     assert.isTrue(2 < tr.b.dictionaryLength(eventsByBaseType));
     assert.sameMembers(eventsByBaseType.slice.toArray(), [a, b]);
     assert.sameMembers(eventsByBaseType.asyncSlice.toArray(), [c]);
     for (var baseType in eventsByBaseType) {
       if (baseType !== 'slice' && baseType !== 'asyncSlice')
         assert.equal(0, eventsByBaseType[baseType].length);
     }
   });

   test('intersectionIsEmpty1', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'b', 0, 3, {}, 3));

     var set1 = new tr.model.EventSet([
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[1],
         t1.sliceGroup.slices[2]
     ]);
     var set2 = new tr.model.EventSet([
         t1.sliceGroup.slices[2]
     ]);
     assert.isFalse(set1.intersectionIsEmpty(set2));
   });

   test('intersectionIsNonEmpty2', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'b', 0, 3, {}, 3));

     var set1 = new tr.model.EventSet([
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[1]
     ]);
     var set2 = new tr.model.EventSet([
         t1.sliceGroup.slices[2]
     ]);
     assert.isTrue(set1.intersectionIsEmpty(set2));
   });

   test('equals', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'b', 0, 2, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'c', 0, 3, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'd', 0, 4, {}, 5));

     var eventSet1 = new tr.model.EventSet([
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[1],
         t1.sliceGroup.slices[2]
     ]);
     var eventSet2 = new tr.model.EventSet([
         t1.sliceGroup.slices[1],
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[2]
     ]);
     var eventSet3 = new tr.model.EventSet([
         t1.sliceGroup.slices[1],
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[3]
     ]);
     var eventSet4 = new tr.model.EventSet([
         t1.sliceGroup.slices[1],
         t1.sliceGroup.slices[0]
     ]);
     assert.isTrue(eventSet1.equals(eventSet2));
     assert.isFalse(eventSet1.equals(eventSet3));
     assert.isFalse(eventSet1.equals(eventSet4));
   });

   test('filter', function() {
     var m = newModel(function(m) {

       var p = m.getOrCreateProcess(1);
       var t = p.getOrCreateThread(1);

       m.s0 = t.sliceGroup.pushSlice(newSliceEx(
           { title: 's0', start: 0.0, duration: 1.0 }));
       m.s1 = t.sliceGroup.pushSlice(newSliceEx(
           { title: 's1', start: 0.0, duration: 1.0 }));
       m.s2 = t.sliceGroup.pushSlice(newSliceEx(
           { title: 's2', start: 0.0, duration: 1.0 }));

       m.eventSet = new tr.model.EventSet([m.s0, m.s1, m.s2]);
     });

     var res = m.eventSet.filter(function(slice) {
       return slice.title === 's0';
     });

     assert.isTrue(res.equals(new tr.model.EventSet([m.s0])));
   });

   test('toArray', function() {
      var samples = [
        {guid: 1},
        {guid: 2}
      ];
      var eventSet = new tr.model.EventSet(samples);

      assert.deepEqual(eventSet.toArray(), samples);
    });

   test('asDict', function() {
     var model = new tr.Model();
     var p1 = model.getOrCreateProcess(1);
     var t1 = p1.getOrCreateThread(1);
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'b', 0, 2, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'c', 0, 3, {}, 3));
     t1.sliceGroup.pushSlice(
         new tr.model.ThreadSlice('', 'd', 0, 4, {}, 5));

     var eventSet = new tr.model.EventSet([
         t1.sliceGroup.slices[0],
         t1.sliceGroup.slices[1],
         t1.sliceGroup.slices[2]
     ]);

     assert.deepEqual(
         {'events':
             ['1.1.SliceGroup.0', '1.1.SliceGroup.1', '1.1.SliceGroup.2']},
         eventSet.asDict());
    });

   test('immutableEmptySet', function() {
     var s = tr.model.EventSet.IMMUTABLE_EMPTY_SET;
     assert.lengthOf(s, 0);
     assert.isTrue(s.bounds.isEmpty);

     // Check that the iteration methods still work correctly.
     function throwOnCall() {
       throw new Error('This function should never be called!!!');
     }
     assert.deepEqual(s.map(throwOnCall), []);
     s.forEach(throwOnCall);

     // Check that the set is indeed immutable.
     assert.throws(function() { s[0] = b; });
     assert.throws(function() { s.push(b); });
     assert.throws(function() { s.addEventSet(new tr.model.EventSet()); });
   });
 });
 </script>
	<!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="/tracing/base/iteration_helpers.html">
	<link rel="import" href="/tracing/core/test_utils.html">
	<link rel="import" href="/tracing/model/event_set.html">
	<link rel="import" href="/tracing/model/model.html">

	<script>
	'use strict';

	tr.b.unittest.testSuite(function() {
	var newModel = tr.c.TestUtils.newModel;
	var newSliceEx = tr.c.TestUtils.newSliceEx;

	test('eventSetObject', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 5, {}, 1));

	var eventSet = new tr.model.EventSet();
	eventSet.push(t1.sliceGroup.slices[0]);

	assert.equal(eventSet.bounds.min, 1);
	assert.equal(eventSet.bounds.max, 4);
	assert.deepEqual(eventSet, new tr.model.EventSet(
	t1.sliceGroup.slices[0]));

	eventSet.push(t1.sliceGroup.slices[1]);
	assert.equal(eventSet.bounds.min, 1);
	assert.equal(eventSet.bounds.max, 6);
	assert.deepEqual(eventSet, new tr.model.EventSet(
	[t1.sliceGroup.slices[0], t1.sliceGroup.slices[1]]));

	eventSet.clear();
	assert.equal(eventSet.length, 0);
	});

	test('iteration', function() {
	var eventSet = new tr.model.EventSet([{guid: 1}, {guid: 2}, {guid: 3}]);

	var expectedId = 1;
	for (var event of eventSet)
	assert.equal(event.guid, expectedId++);
	});

	test('uniqueContents', function() {
	var sample1 = {guid: 1};
	var sample2 = {guid: 2};

	var eventSet = new tr.model.EventSet();

	eventSet.push(sample1);
	eventSet.push(sample2);
	assert.equal(eventSet.length, 2);

	eventSet.push(sample1);
	assert.equal(eventSet.length, 2);
	});

	test('userFriendlyNameSingular', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	var selection = new tr.model.EventSet(t1.sliceGroup.slices[0]);
	assert.isDefined(selection.userFriendlyName);
	});

	test('userFriendlyNamePlural', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
	var eventSet = new tr.model.EventSet([
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[1]
	]);
	assert.isDefined(eventSet.userFriendlyName);
	});

	test('userFriendlyNameMixedPlural', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));

	var i10 = new tr.model.ObjectInstance(
	{}, '0x1000', 'cat', 'name', 10);
	var s10 = i10.addSnapshot(10, {foo: 1});

	var eventSet = new tr.model.EventSet([
	t1.sliceGroup.slices[0],
	s10
	]);
	assert.isDefined(eventSet.userFriendlyName);
	});

	test('groupEventsByTitle', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'b', 0, 3, {}, 3));
	var eventSet = new tr.model.EventSet([
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[1],
	t1.sliceGroup.slices[2]
	]);

	var eventsByTitle = eventSet.getEventsOrganizedByTitle();
	assert.equal(2, tr.b.dictionaryLength(eventsByTitle));
	assert.sameMembers(eventsByTitle['a'].toArray(),
	[t1.sliceGroup.slices[0], t1.sliceGroup.slices[1]]);
	assert.sameMembers(eventsByTitle['b'].toArray(),
	[t1.sliceGroup.slices[2]]);
	});

	test('groupEventsByCallback', function() {
	var a1 = new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3);
	var a2 = new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3);
	var b1 = new tr.model.ThreadSlice('', 'b', 0, 1, {}, 3);
	var eventSet = new tr.model.EventSet([a1, a2, b1]);
	function getEventKey(event) {
	return 's' + event.start;
	}
	var eventsByCallback = eventSet.getEventsOrganizedByCallback(getEventKey);
	assert.equal(2, tr.b.dictionaryLength(eventsByCallback));
	assert.sameMembers(eventsByCallback.s1.toArray(), [a1, b1]);
	assert.sameMembers(eventsByCallback.s2.toArray(), [a2]);
	});

	test('groupEventsByBaseType', function() {
	var a = new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3);
	var b = new tr.model.ThreadSlice('', 'b', 0, 1, {}, 3);
	var c = new tr.model.AsyncSlice('', 'c', 0, 1, {}, 3);
	var eventSet = new tr.model.EventSet([a, b, c]);
	var eventsByBaseType = eventSet.getEventsOrganizedByBaseType(true);
	assert.equal(2, tr.b.dictionaryLength(eventsByBaseType));
	assert.sameMembers(eventsByBaseType.slice.toArray(), [a, b]);
	assert.sameMembers(eventsByBaseType.asyncSlice.toArray(), [c]);

	var eventsByBaseType = eventSet.getEventsOrganizedByBaseType(false);
	assert.isTrue(2 < tr.b.dictionaryLength(eventsByBaseType));
	assert.sameMembers(eventsByBaseType.slice.toArray(), [a, b]);
	assert.sameMembers(eventsByBaseType.asyncSlice.toArray(), [c]);
	for (var baseType in eventsByBaseType) {
	if (baseType !== 'slice' && baseType !== 'asyncSlice')
	assert.equal(0, eventsByBaseType[baseType].length);
	}
	});

	test('intersectionIsEmpty1', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'b', 0, 3, {}, 3));

	var set1 = new tr.model.EventSet([
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[1],
	t1.sliceGroup.slices[2]
	]);
	var set2 = new tr.model.EventSet([
	t1.sliceGroup.slices[2]
	]);
	assert.isFalse(set1.intersectionIsEmpty(set2));
	});

	test('intersectionIsNonEmpty2', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 2, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'b', 0, 3, {}, 3));

	var set1 = new tr.model.EventSet([
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[1]
	]);
	var set2 = new tr.model.EventSet([
	t1.sliceGroup.slices[2]
	]);
	assert.isTrue(set1.intersectionIsEmpty(set2));
	});

	test('equals', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'b', 0, 2, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'c', 0, 3, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'd', 0, 4, {}, 5));

	var eventSet1 = new tr.model.EventSet([
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[1],
	t1.sliceGroup.slices[2]
	]);
	var eventSet2 = new tr.model.EventSet([
	t1.sliceGroup.slices[1],
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[2]
	]);
	var eventSet3 = new tr.model.EventSet([
	t1.sliceGroup.slices[1],
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[3]
	]);
	var eventSet4 = new tr.model.EventSet([
	t1.sliceGroup.slices[1],
	t1.sliceGroup.slices[0]
	]);
	assert.isTrue(eventSet1.equals(eventSet2));
	assert.isFalse(eventSet1.equals(eventSet3));
	assert.isFalse(eventSet1.equals(eventSet4));
	});

	test('filter', function() {
	var m = newModel(function(m) {

	var p = m.getOrCreateProcess(1);
	var t = p.getOrCreateThread(1);

	m.s0 = t.sliceGroup.pushSlice(newSliceEx(
	{ title: 's0', start: 0.0, duration: 1.0 }));
	m.s1 = t.sliceGroup.pushSlice(newSliceEx(
	{ title: 's1', start: 0.0, duration: 1.0 }));
	m.s2 = t.sliceGroup.pushSlice(newSliceEx(
	{ title: 's2', start: 0.0, duration: 1.0 }));

	m.eventSet = new tr.model.EventSet([m.s0, m.s1, m.s2]);
	});

	var res = m.eventSet.filter(function(slice) {
	return slice.title === 's0';
	});

	assert.isTrue(res.equals(new tr.model.EventSet([m.s0])));
	});

	test('toArray', function() {
	var samples = [
	{guid: 1},
	{guid: 2}
	];
	var eventSet = new tr.model.EventSet(samples);

	assert.deepEqual(eventSet.toArray(), samples);
	});

	test('asDict', function() {
	var model = new tr.Model();
	var p1 = model.getOrCreateProcess(1);
	var t1 = p1.getOrCreateThread(1);
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'a', 0, 1, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'b', 0, 2, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'c', 0, 3, {}, 3));
	t1.sliceGroup.pushSlice(
	new tr.model.ThreadSlice('', 'd', 0, 4, {}, 5));

	var eventSet = new tr.model.EventSet([
	t1.sliceGroup.slices[0],
	t1.sliceGroup.slices[1],
	t1.sliceGroup.slices[2]
	]);

	assert.deepEqual(
	{'events':
	['1.1.SliceGroup.0', '1.1.SliceGroup.1', '1.1.SliceGroup.2']},
	eventSet.asDict());
	});

	test('immutableEmptySet', function() {
	var s = tr.model.EventSet.IMMUTABLE_EMPTY_SET;
	assert.lengthOf(s, 0);
	assert.isTrue(s.bounds.isEmpty);

	// Check that the iteration methods still work correctly.
	function throwOnCall() {
	throw new Error('This function should never be called!!!');
	}
	assert.deepEqual(s.map(throwOnCall), []);
	s.forEach(throwOnCall);

	// Check that the set is indeed immutable.
	assert.throws(function() { s[0] = b; });
	assert.throws(function() { s.push(b); });
	assert.throws(function() { s.addEventSet(new tr.model.EventSet()); });
	});
	});
	</script>