133 lines
3.6 KiB
JavaScript
133 lines
3.6 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
"use strict";
|
|
|
|
// Test that the DominatorTreeNode.attachShortestPaths function can correctly
|
|
// attach the deduplicated shortest retaining paths for each node it is given.
|
|
|
|
const startNodeId = 9999;
|
|
const maxNumPaths = 2;
|
|
|
|
// Mock data mapping node id to shortest paths to that node id.
|
|
const shortestPaths = new Map([
|
|
[1000, [
|
|
[pathEntry(1100, "a"), pathEntry(1200, "b")],
|
|
[pathEntry(1100, "c"), pathEntry(1300, "d")],
|
|
]],
|
|
[2000, [
|
|
[pathEntry(2100, "e"), pathEntry(2200, "f"), pathEntry(2300, "g")]
|
|
]],
|
|
[3000, [
|
|
[pathEntry(3100, "h")],
|
|
[pathEntry(3100, "i")],
|
|
[pathEntry(3100, "j")],
|
|
[pathEntry(3200, "k")],
|
|
[pathEntry(3300, "l")],
|
|
[pathEntry(3400, "m")],
|
|
]],
|
|
]);
|
|
|
|
const actual = [
|
|
makeTestDominatorTreeNode({ nodeId: 1000 }),
|
|
makeTestDominatorTreeNode({ nodeId: 2000 }),
|
|
makeTestDominatorTreeNode({ nodeId: 3000 }),
|
|
];
|
|
|
|
const expected = [
|
|
makeTestDominatorTreeNode({
|
|
nodeId: 1000,
|
|
shortestPaths: {
|
|
nodes: [
|
|
{ id: 1000, label: ["SomeType-1000"] },
|
|
{ id: 1100, label: ["SomeType-1100"] },
|
|
{ id: 1200, label: ["SomeType-1200"] },
|
|
{ id: 1300, label: ["SomeType-1300"] },
|
|
],
|
|
edges: [
|
|
{ from: 1100, to: 1200, name: "a" },
|
|
{ from: 1100, to: 1300, name: "c" },
|
|
{ from: 1200, to: 1000, name: "b" },
|
|
{ from: 1300, to: 1000, name: "d" },
|
|
]
|
|
}
|
|
}),
|
|
|
|
makeTestDominatorTreeNode({
|
|
nodeId: 2000,
|
|
shortestPaths: {
|
|
nodes: [
|
|
{ id: 2000, label: ["SomeType-2000"] },
|
|
{ id: 2100, label: ["SomeType-2100"] },
|
|
{ id: 2200, label: ["SomeType-2200"] },
|
|
{ id: 2300, label: ["SomeType-2300"] },
|
|
],
|
|
edges: [
|
|
{ from: 2100, to: 2200, name: "e" },
|
|
{ from: 2200, to: 2300, name: "f" },
|
|
{ from: 2300, to: 2000, name: "g" },
|
|
]
|
|
}
|
|
}),
|
|
|
|
makeTestDominatorTreeNode({ nodeId: 3000,
|
|
shortestPaths: {
|
|
nodes: [
|
|
{ id: 3000, label: ["SomeType-3000"] },
|
|
{ id: 3100, label: ["SomeType-3100"] },
|
|
{ id: 3200, label: ["SomeType-3200"] },
|
|
{ id: 3300, label: ["SomeType-3300"] },
|
|
{ id: 3400, label: ["SomeType-3400"] },
|
|
],
|
|
edges: [
|
|
{ from: 3100, to: 3000, name: "h" },
|
|
{ from: 3100, to: 3000, name: "i" },
|
|
{ from: 3100, to: 3000, name: "j" },
|
|
{ from: 3200, to: 3000, name: "k" },
|
|
{ from: 3300, to: 3000, name: "l" },
|
|
{ from: 3400, to: 3000, name: "m" },
|
|
]
|
|
}
|
|
}),
|
|
];
|
|
|
|
const breakdown = {
|
|
by: "internalType",
|
|
then: { by: "count", count: true, bytes: true }
|
|
};
|
|
|
|
const mockSnapshot = {
|
|
computeShortestPaths: (start, nodeIds, max) => {
|
|
equal(start, startNodeId);
|
|
equal(max, maxNumPaths);
|
|
|
|
return new Map(nodeIds.map(nodeId => {
|
|
const paths = shortestPaths.get(nodeId);
|
|
ok(paths, "Expected computeShortestPaths call for node id = " + nodeId);
|
|
return [nodeId, paths];
|
|
}));
|
|
},
|
|
|
|
describeNode: (bd, nodeId) => {
|
|
equal(bd, breakdown);
|
|
return {
|
|
["SomeType-" + nodeId]: {
|
|
count: 1,
|
|
bytes: 10,
|
|
}
|
|
};
|
|
},
|
|
};
|
|
|
|
function run_test() {
|
|
DominatorTreeNode.attachShortestPaths(mockSnapshot,
|
|
breakdown,
|
|
startNodeId,
|
|
actual,
|
|
maxNumPaths);
|
|
|
|
dumpn("Expected = " + JSON.stringify(expected, null, 2));
|
|
dumpn("Actual = " + JSON.stringify(actual, null, 2));
|
|
|
|
assertStructurallyEquivalent(expected, actual);
|
|
}
|