summaryrefslogtreecommitdiff
path: root/chromium/third_party/catapult/tracing/tracing/ui/tracks/async_slice_group_track_test.html
diff options
context:
space:
mode:
authorAllan Sandfeld Jensen <allan.jensen@qt.io>2019-03-05 17:34:47 +0100
committerAllan Sandfeld Jensen <allan.jensen@qt.io>2019-03-06 10:04:14 +0000
commiteaf1da4d961fbbda9455f9af3b23d1af777f43fa (patch)
tree95970599ecee31c4f7f940bc97ac98c61a3d0cad /chromium/third_party/catapult/tracing/tracing/ui/tracks/async_slice_group_track_test.html
parent38a9a29f4f9436cace7f0e7abf9c586057df8a4e (diff)
downloadqtwebengine-chromium-eaf1da4d961fbbda9455f9af3b23d1af777f43fa.tar.gz
BASELINE: Update Chromium to 73.0.3683.64
Change-Id: I76517dc277ba4e16bfd7e098fda3d079656b3b9f Reviewed-by: Michael Brüning <michael.bruning@qt.io>
Diffstat (limited to 'chromium/third_party/catapult/tracing/tracing/ui/tracks/async_slice_group_track_test.html')
-rw-r--r--chromium/third_party/catapult/tracing/tracing/ui/tracks/async_slice_group_track_test.html328
1 files changed, 328 insertions, 0 deletions
diff --git a/chromium/third_party/catapult/tracing/tracing/ui/tracks/async_slice_group_track_test.html b/chromium/third_party/catapult/tracing/tracing/ui/tracks/async_slice_group_track_test.html
new file mode 100644
index 00000000000..96003e1b5f2
--- /dev/null
+++ b/chromium/third_party/catapult/tracing/tracing/ui/tracks/async_slice_group_track_test.html
@@ -0,0 +1,328 @@
+<!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/core/test_utils.html">
+<link rel="import" href="/tracing/model/model.html">
+<link rel="import" href="/tracing/ui/timeline_track_view.html">
+
+<script>
+'use strict';
+
+tr.b.unittest.testSuite(function() {
+ const AsyncSliceGroup = tr.model.AsyncSliceGroup;
+ const AsyncSliceGroupTrack = tr.ui.tracks.AsyncSliceGroupTrack;
+ const Process = tr.model.Process;
+ const ProcessTrack = tr.ui.tracks.ProcessTrack;
+ const Thread = tr.model.Thread;
+ const ThreadTrack = tr.ui.tracks.ThreadTrack;
+ const newAsyncSlice = tr.c.TestUtils.newAsyncSlice;
+ const newAsyncSliceNamed = tr.c.TestUtils.newAsyncSliceNamed;
+ const groupAsyncSlicesIntoSubRows = tr.ui.tracks.groupAsyncSlicesIntoSubRows;
+
+ test('filterSubRows', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+ g.push(newAsyncSlice(0, 1, t1, t1));
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+
+ assert.strictEqual(track.children.length, 1);
+ assert.isTrue(track.hasVisibleContent);
+ });
+
+ test('groupAsyncSlicesIntoSubRows_empty', function() {
+ const rows = groupAsyncSlicesIntoSubRows([]);
+ assert.strictEqual(rows.length, 0);
+ });
+
+ test('groupAsyncSlicesIntoSubRows_trivial', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+
+ const s1 = newAsyncSlice(10, 200, t1, t1);
+ const s2 = newAsyncSlice(300, 30, t1, t1);
+
+ const slices = [s2, s1];
+ const rows = groupAsyncSlicesIntoSubRows(slices);
+
+ assert.strictEqual(rows.length, 1);
+ assert.sameMembers(rows[0], [s1, s2]);
+ });
+
+ test('groupAsyncSlicesIntoSubRows_nonTrivial', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+
+ const s1 = newAsyncSlice(10, 200, t1, t1); // Should be stripped.
+ const s1s1 = newAsyncSlice(10, 200, t1, t1);
+ s1.subSlices = [s1s1];
+
+ const s2 = newAsyncSlice(300, 30, t1, t1);
+ const s2s1 = newAsyncSlice(300, 10, t1, t1);
+ const s2s2 = newAsyncSlice(310, 20, t1, t1); // Should not be stripped.
+ const s2s2s1 = newAsyncSlice(310, 20, t1, t1);
+ s2s2.subSlices = [s2s2s1];
+ s2.subSlices = [s2s2, s2s1];
+
+ const s3 = newAsyncSlice(200, 50, t1, t1); // Overlaps with s1.
+ const s3s1 = newAsyncSlice(220, 5, t1, t1);
+ s3.subSlices = [s3s1];
+
+ const slices = [s2, s3, s1];
+ const rows = groupAsyncSlicesIntoSubRows(slices);
+
+ assert.strictEqual(rows.length, 5);
+ assert.sameMembers(rows[0], [s1s1, s2]);
+ assert.sameMembers(rows[1], [s2s1, s2s2]);
+ assert.sameMembers(rows[2], [s2s2s1]);
+ assert.sameMembers(rows[3], [s3]);
+ assert.sameMembers(rows[4], [s3s1]);
+ });
+
+ test('rebuildSubRows_twoNonOverlappingSlices', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+ const s1 = newAsyncSlice(0, 1, t1, t1);
+ const subs1 = newAsyncSliceNamed('b', 0, 1, t1, t1);
+ s1.subSlices = [subs1];
+ g.push(s1);
+ g.push(newAsyncSlice(1, 1, t1, t1));
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+ const subRows = track.subRows;
+ assert.strictEqual(subRows.length, 1);
+ assert.strictEqual(subRows[0].length, 2);
+ assert.sameMembers(g.slices[1].subSlices, []);
+ });
+
+ test('rebuildSubRows_twoOverlappingSlices', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+
+ const s1 = newAsyncSlice(0, 1, t1, t1);
+ const subs1 = newAsyncSliceNamed('b', 0, 1, t1, t1);
+ s1.subSlices = [subs1];
+ const s2 = newAsyncSlice(0, 1.5, t1, t1);
+ const subs2 = newAsyncSliceNamed('b', 0, 1, t1, t1);
+ s2.subSlices = [subs2];
+ g.push(s1);
+ g.push(s2);
+
+ g.updateBounds();
+
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+
+ const subRows = track.subRows;
+
+ assert.strictEqual(subRows.length, 2);
+ assert.strictEqual(subRows[0].length, 1);
+ assert.strictEqual(subRows[1].length, 1);
+ assert.strictEqual(subRows[1][0], g.slices[1].subSlices[0]);
+ });
+
+ test('rebuildSubRows_threePartlyOverlappingSlices', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+ g.push(newAsyncSlice(0, 1, t1, t1));
+ g.push(newAsyncSlice(0, 1.5, t1, t1));
+ g.push(newAsyncSlice(1, 1.5, t1, t1));
+ g.updateBounds();
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+ const subRows = track.subRows;
+
+ assert.strictEqual(subRows.length, 2);
+ assert.strictEqual(subRows[0].length, 2);
+ assert.strictEqual(subRows[0][0], g.slices[0]);
+ assert.strictEqual(subRows[0][1], g.slices[2]);
+ assert.strictEqual(subRows[1][0], g.slices[1]);
+ assert.strictEqual(subRows[1].length, 1);
+ assert.sameMembers(g.slices[0].subSlices, []);
+ assert.sameMembers(g.slices[1].subSlices, []);
+ assert.sameMembers(g.slices[2].subSlices, []);
+ });
+
+ test('rebuildSubRows_threeOverlappingSlices', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+
+ g.push(newAsyncSlice(0, 1, t1, t1));
+ g.push(newAsyncSlice(0, 1.5, t1, t1));
+ g.push(newAsyncSlice(2, 1, t1, t1));
+ g.updateBounds();
+
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+
+ const subRows = track.subRows;
+ assert.strictEqual(subRows.length, 2);
+ assert.strictEqual(subRows[0].length, 2);
+ assert.strictEqual(subRows[1].length, 1);
+ assert.strictEqual(subRows[0][0], g.slices[0]);
+ assert.strictEqual(subRows[1][0], g.slices[1]);
+ assert.strictEqual(subRows[0][1], g.slices[2]);
+ });
+
+ test('rebuildSubRows_twoViewSubGroups', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+ g.push(newAsyncSliceNamed('foo', 0, 1, t1, t1));
+ g.push(newAsyncSliceNamed('foo', 2, 1, t1, t1));
+ g.push(newAsyncSliceNamed('bar', 1, 2, t1, t1));
+ g.push(newAsyncSliceNamed('bar', 3, 2, t1, t1));
+ g.updateBounds();
+
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+ track.heading = 'sup';
+
+ assert.strictEqual(track.subRows.length, 2);
+ const subTracks = Polymer.dom(track).children;
+ assert.strictEqual(subTracks.length, 3);
+ assert.strictEqual(subTracks[0].slices.length, 0);
+ assert.strictEqual(subTracks[1].slices.length, 2);
+ assert.strictEqual(subTracks[2].slices.length, 2);
+ const headings =
+ [subTracks[0].heading, subTracks[1].heading, subTracks[2].heading];
+ assert.sameMembers(headings, ['foo', 'bar', 'sup']);
+ });
+
+ // Tests that no slices and their sub slices overlap.
+ test('rebuildSubRows_NonOverlappingSubSlices', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+
+ const slice1 = newAsyncSlice(0, 5, t1, t1);
+ const slice1Child = newAsyncSlice(1, 2, t1, t1);
+ slice1.subSlices = [slice1Child];
+ const slice2 = newAsyncSlice(3, 5, t1, t1);
+ const slice3 = newAsyncSlice(5, 4, t1, t1);
+ const slice3Child = newAsyncSlice(6, 2, t1, t1);
+ slice3.subSlices = [slice3Child];
+ g.push(slice1);
+ g.push(slice2);
+ g.push(slice3);
+ g.updateBounds();
+
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+
+ const subRows = track.subRows;
+ // Checks each sub row to see that we don't have any overlapping slices.
+ for (let i = 0; i < subRows.length; i++) {
+ const row = subRows[i];
+ for (let j = 0; j < row.length; j++) {
+ for (let k = j + 1; k < row.length; k++) {
+ assert.isTrue(row[j].end <= row[k].start);
+ }
+ }
+ }
+ });
+
+ test('rebuildSubRows_NonOverlappingSubSlicesThreeNestedLevels', function() {
+ const model = new tr.Model();
+ const p1 = new Process(model, 1);
+ const t1 = new Thread(p1, 1);
+ const g = new AsyncSliceGroup(t1);
+
+ const slice1 = newAsyncSlice(0, 4, t1, t1);
+ const slice1Child = newAsyncSlice(1, 2, t1, t1);
+ slice1.subSlices = [slice1Child];
+ const slice2 = newAsyncSlice(2, 7, t1, t1);
+ const slice3 = newAsyncSlice(5, 5, t1, t1);
+ const slice3Child = newAsyncSlice(6, 3, t1, t1);
+ const slice3Child2 = newAsyncSlice(7, 1, t1, t1);
+ slice3.subSlices = [slice3Child];
+ slice3Child.subSlices = [slice3Child2];
+ g.push(slice1);
+ g.push(slice2);
+ g.push(slice3);
+ g.updateBounds();
+
+ const track = new AsyncSliceGroupTrack(new tr.ui.TimelineViewport());
+ track.group = g;
+
+ const subRows = track.subRows;
+ // Checks each sub row to see that we don't have any overlapping slices.
+ for (let i = 0; i < subRows.length; i++) {
+ const row = subRows[i];
+ for (let j = 0; j < row.length; j++) {
+ for (let k = j + 1; k < row.length; k++) {
+ assert.isTrue(row[j].end <= row[k].start);
+ }
+ }
+ }
+ });
+
+ test('asyncSliceGroupContainerMap', function() {
+ const vp = new tr.ui.TimelineViewport();
+ const containerToTrack = vp.containerToTrackMap;
+ const model = new tr.Model();
+ const process = model.getOrCreateProcess(123);
+ const thread = process.getOrCreateThread(456);
+ const group = new AsyncSliceGroup(thread);
+
+ const processTrack = new ProcessTrack(vp);
+ const threadTrack = new ThreadTrack(vp);
+ const groupTrack = new AsyncSliceGroupTrack(vp);
+ processTrack.process = process;
+ threadTrack.thread = thread;
+ groupTrack.group = group;
+ Polymer.dom(processTrack).appendChild(threadTrack);
+ Polymer.dom(threadTrack).appendChild(groupTrack);
+
+ assert.strictEqual(processTrack.eventContainer, process);
+ assert.strictEqual(threadTrack.eventContainer, thread);
+ assert.strictEqual(groupTrack.eventContainer, group);
+
+ assert.isUndefined(containerToTrack.getTrackByStableId('123'));
+ assert.isUndefined(containerToTrack.getTrackByStableId('123.456'));
+ assert.isUndefined(
+ containerToTrack.getTrackByStableId('123.456.AsyncSliceGroup'));
+
+ vp.modelTrackContainer = {
+ addContainersToTrackMap(containerToTrackMap) {
+ processTrack.addContainersToTrackMap(containerToTrackMap);
+ },
+ addEventListener() {}
+ };
+ vp.rebuildContainerToTrackMap();
+
+ // Check that all tracks call childs' addContainersToTrackMap()
+ // by checking the resulting map.
+ assert.strictEqual(
+ containerToTrack.getTrackByStableId('123'), processTrack);
+ assert.strictEqual(
+ containerToTrack.getTrackByStableId('123.456'), threadTrack);
+ assert.strictEqual(
+ containerToTrack.getTrackByStableId('123.456.AsyncSliceGroup'),
+ groupTrack);
+
+ // Check the track's eventContainer getter.
+ assert.strictEqual(processTrack.eventContainer, process);
+ assert.strictEqual(threadTrack.eventContainer, thread);
+ assert.strictEqual(groupTrack.eventContainer, group);
+ });
+});
+</script>
View Lorry Controller Status