src/third_party/WebKit/LayoutTests/inspector/profiler/heap-snapshot.html

   1 <html>
   2 <head>
   3 <script src="../../http/tests/inspector/inspector-test.js"></script>
   4 <script src="heap-snapshot-test.js"></script>
   5 <script>
   6
   7 function test()
   8 {
   9     WebInspector.inspectorView.showPanel("profiles");
  10
  11     function createTestEnvironmentInWorker()
  12     {
  13         if (!this.InspectorTest)
  14             InspectorTest = {};
  15
  16         InspectorTest.assertEquals = function(expected, found, message)
  17         {
  18             if (expected === found)
  19                 return;
  20
  21             var error;
  22             if (message)
  23                 error = "Failure (" + message + "):";
  24             else
  25                 error = "Failure:";
  26             throw new Error(error + " expected <" + expected + "> found <" + found + ">");
  27         }
  28     }
  29
  30     function runTestSuiteInWorker()
  31     {
  32         var testSuite = [
  33             function postOrderIndexBug()
  34             {
  35                 var builder = new InspectorTest.HeapSnapshotBuilder();
  36                 var node1 = new InspectorTest.HeapNode("Node1");
  37                 var node2 = new InspectorTest.HeapNode("Node2");
  38                 builder.rootNode.linkNode(node1, InspectorTest.HeapEdge.Type.internal);
  39                 builder.rootNode.linkNode(node2, InspectorTest.HeapEdge.Type.internal);
  40                 node2.linkNode(node1, InspectorTest.HeapEdge.Type.internal);
  41                 var snapshot = builder.createJSHeapSnapshot();
  42                 var postOrderIndexes = snapshot._buildPostOrderIndex().nodeOrdinal2PostOrderIndex;
  43                 var nodeOrdinals = snapshot._buildPostOrderIndex().postOrderIndex2NodeOrdinal;
  44                 InspectorTest.assertEquals(JSON.stringify(new Uint32Array([2, 0, 1])), JSON.stringify(postOrderIndexes), "postOrderIndexes");
  45                 InspectorTest.assertEquals(JSON.stringify(new Uint32Array([1, 2, 0])), JSON.stringify(nodeOrdinals), "nodeOrdinals");
  46             },
  47
  48             function heapSnapshotNodeSimpleTest()
  49             {
  50                 var snapshot = InspectorTest.createJSHeapSnapshotMockObject();
  51                 var nodeRoot = snapshot.createNode(snapshot._rootNodeIndex);
  52                 InspectorTest.assertEquals("", nodeRoot.name(), "root name");
  53                 InspectorTest.assertEquals("hidden", nodeRoot.type(), "root type");
  54                 InspectorTest.assertEquals(2, nodeRoot.edgesCount(), "root edges");
  55                 var nodeE = snapshot.createNode(15);
  56                 InspectorTest.assertEquals("E", nodeE.name(), "E name");
  57                 InspectorTest.assertEquals("object", nodeE.type(), "E type");
  58                 InspectorTest.assertEquals(0, nodeE.edgesCount(), "E edges");
  59             },
  60
  61             function heapSnapshotNodeIteratorTest()
  62             {
  63                 var snapshot = InspectorTest.createJSHeapSnapshotMockObject();
  64                 var nodeRoot = snapshot.createNode(snapshot._rootNodeIndex);
  65                 var iterator = new WebInspector.HeapSnapshotNodeIterator(nodeRoot);
  66                 var names = [];
  67                 for (; iterator.hasNext(); iterator.next())
  68                     names.push(iterator.item().name());
  69                 InspectorTest.assertEquals(",A,B,C,D,E", names.join(","), "node iterator");
  70             },
  71
  72             function heapSnapshotEdgeSimpleTest()
  73             {
  74                 var snapshot = InspectorTest.createJSHeapSnapshotMockObject();
  75                 var nodeRoot = snapshot.createNode(snapshot._rootNodeIndex);
  76                 var edgeIterator = new WebInspector.HeapSnapshotEdgeIterator(nodeRoot);
  77                 InspectorTest.assertEquals(true, edgeIterator.hasNext(), "has edges");
  78                 var edge = edgeIterator.item();
  79                 InspectorTest.assertEquals("shortcut", edge.type(), "edge type");
  80                 InspectorTest.assertEquals("a", edge.name(), "edge name");
  81                 InspectorTest.assertEquals("A", edge.node().name(), "edge node name");
  82
  83                 var edgesCount = 0;
  84                 for (; edgeIterator.hasNext(); edgeIterator.next())
  85                     ++edgesCount;
  86                 InspectorTest.assertEquals(nodeRoot.edgesCount(), edgesCount, "edges count");
  87             },
  88
  89             function heapSnapshotEdgeIteratorTest()
  90             {
  91                 var snapshot = InspectorTest.createJSHeapSnapshotMockObject();
  92                 var nodeRoot = snapshot.createNode(snapshot._rootNodeIndex);
  93                 var names = [];
  94                 for (var iterator = nodeRoot.edges(); iterator.hasNext(); iterator.next())
  95                     names.push(iterator.item().name());
  96                 InspectorTest.assertEquals("a,b", names.join(","), "edge iterator");
  97                 var nodeE = snapshot.createNode(15);
  98                 InspectorTest.assertEquals(false, nodeE.edges().hasNext(), "empty edge iterator");
  99             },
 100
 101             function heapSnapshotNodeAndEdgeTest()
 102             {
 103                 var snapshotMock = InspectorTest.createJSHeapSnapshotMockObject();
 104                 var nodeRoot = snapshotMock.createNode(snapshotMock._rootNodeIndex);
 105                 var names = [];
 106
 107                 function depthFirstTraversal(node)
 108                 {
 109                     names.push(node.name());
 110                     for (var edges = node.edges(); edges.hasNext(); edges.next()) {
 111                         names.push(edges.item().name());
 112                         depthFirstTraversal(edges.item().node());
 113                     }
 114                 }
 115
 116                 depthFirstTraversal(nodeRoot);
 117                 var reference = ",a,A,1,B,bc,C,ce,E,bd,D,ac,C,ce,E,b,B,bc,C,ce,E,bd,D";
 118                 InspectorTest.assertEquals(reference, names.join(","), "mock traversal");
 119
 120                 // Now check against a real HeapSnapshot instance.
 121                 names = [];
 122                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 123                 depthFirstTraversal(snapshot.rootNode());
 124                 InspectorTest.assertEquals(reference, names.join(","), "snapshot traversal");
 125             },
 126
 127             function heapSnapshotSimpleTest()
 128             {
 129                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 130                 InspectorTest.assertEquals(6, snapshot.nodeCount, "node count");
 131                 InspectorTest.assertEquals(20, snapshot.totalSize, "total size");
 132             },
 133
 134             function heapSnapshotContainmentEdgeIndexesTest()
 135             {
 136                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 137                 var actual = snapshot._firstEdgeIndexes;
 138                 var expected = [0, 6, 12, 18, 21, 21, 21];
 139                 InspectorTest.assertEquals(expected.length, actual.length, "Edge indexes size");
 140                 for (var i = 0; i < expected.length; ++i)
 141                     InspectorTest.assertEquals(expected[i], actual[i], "Edge indexes");
 142             },
 143
 144             function heapSnapshotPostOrderIndexTest()
 145             {
 146                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 147                 var postOrderIndex2NodeOrdinal = snapshot._buildPostOrderIndex().postOrderIndex2NodeOrdinal;
 148                 var expected = [5,3,4,2,1,0];
 149                 for (var i = 0; i < expected.length; ++i)
 150                     InspectorTest.assertEquals(expected[i], postOrderIndex2NodeOrdinal[i], "Post ordered indexes");
 151             },
 152
 153             function heapSnapshotDominatorsTreeTest()
 154             {
 155                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 156                 var result = snapshot._buildPostOrderIndex();
 157                 var dominatorsTree = snapshot._buildDominatorTree(result.postOrderIndex2NodeOrdinal, result.nodeOrdinal2PostOrderIndex);
 158                 var expected = [0, 0, 0, 0, 2, 3];
 159                 for (var i = 0; i < expected.length; ++i)
 160                     InspectorTest.assertEquals(expected[i], dominatorsTree[i], "Dominators Tree");
 161             },
 162
 163             function heapSnapshotRetainedSizeTest()
 164             {
 165                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 166                 var actualRetainedSizes = new Array(snapshot.nodeCount);
 167                 for (var nodeOrdinal = 0; nodeOrdinal < snapshot.nodeCount; ++nodeOrdinal)
 168                     actualRetainedSizes[nodeOrdinal] = snapshot._retainedSizes[nodeOrdinal];
 169                 var expectedRetainedSizes = [20, 2, 8, 10, 5, 6];
 170                 InspectorTest.assertEquals(JSON.stringify(expectedRetainedSizes), JSON.stringify(actualRetainedSizes), "Retained sizes");
 171             },
 172
 173             function heapSnapshotLargeRetainedSize(next)
 174             {
 175                 var builder = new InspectorTest.HeapSnapshotBuilder();
 176                 var node = builder.rootNode;
 177
 178                 var iterations = 6;
 179                 var nodeSize = 1000 * 1000 * 1000;
 180                 for (var i = 0; i < 6; i++) {
 181                     var newNode = new InspectorTest.HeapNode("Node" + i, nodeSize);
 182                     node.linkNode(newNode, InspectorTest.HeapEdge.Type.element);
 183                     node = newNode;
 184                 }
 185
 186                 var snapshot = builder.createJSHeapSnapshot();
 187                 InspectorTest.assertEquals(
 188                     iterations * nodeSize, snapshot.rootNode().retainedSize(),
 189                     "Ensure that root node retained size supports values exceeding 2^32 bytes.");
 190             },
 191
 192             function heapSnapshotDominatedNodesTest()
 193             {
 194                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 195
 196                 var expectedDominatedNodes = [21, 14, 7, 28, 35];
 197                 var actualDominatedNodes = snapshot._dominatedNodes;
 198                 InspectorTest.assertEquals(expectedDominatedNodes.length, actualDominatedNodes.length, "Dominated Nodes length");
 199                 for (var i = 0; i < expectedDominatedNodes.length; ++i)
 200                     InspectorTest.assertEquals(expectedDominatedNodes[i], actualDominatedNodes[i], "Dominated Nodes");
 201
 202                 var expectedDominatedNodeIndex = [0, 3, 3, 4, 5, 5, 5];
 203                 var actualDominatedNodeIndex = snapshot._firstDominatedNodeIndex;
 204                 InspectorTest.assertEquals(expectedDominatedNodeIndex.length, actualDominatedNodeIndex.length, "Dominated Nodes Index length");
 205                 for (var i = 0; i < expectedDominatedNodeIndex.length; ++i)
 206                     InspectorTest.assertEquals(expectedDominatedNodeIndex[i], actualDominatedNodeIndex[i], "Dominated Nodes Index");
 207             },
 208
 209             function heapSnapshotPageOwnedTest(next)
 210             {
 211                 var builder = new InspectorTest.HeapSnapshotBuilder();
 212                 var rootNode = builder.rootNode;
 213
 214                 var debuggerNode = new InspectorTest.HeapNode("Debugger");
 215                 rootNode.linkNode(debuggerNode, InspectorTest.HeapEdge.Type.element);
 216
 217                 var windowNode = new InspectorTest.HeapNode("Window");
 218                 rootNode.linkNode(windowNode, InspectorTest.HeapEdge.Type.shortcut);
 219
 220                 var pageOwnedNode = new InspectorTest.HeapNode("PageOwnedNode");
 221                 windowNode.linkNode(pageOwnedNode, InspectorTest.HeapEdge.Type.element);
 222                 debuggerNode.linkNode(pageOwnedNode, InspectorTest.HeapEdge.Type.property, "debugger2pageOwnedNode");
 223
 224                 var debuggerOwnedNode = new InspectorTest.HeapNode("debuggerOwnedNode");
 225                 debuggerNode.linkNode(debuggerOwnedNode, InspectorTest.HeapEdge.Type.element);
 226
 227                 var snapshot = builder.createJSHeapSnapshot();
 228                 snapshot._flags = new Array(snapshot.nodeCount);
 229                 for (var i = 0; i < snapshot.nodeCount; ++i)
 230                     snapshot._flags[i] = 0;
 231                 snapshot._markPageOwnedNodes();
 232
 233                 var expectedFlags = [0, 0, 4, 4, 0];
 234                 InspectorTest.assertEquals(
 235                     JSON.stringify(expectedFlags),
 236                     JSON.stringify(snapshot._flags),
 237                     "We are expecting that only window(third element) and PageOwnedNode(forth element) have flag === 4.");
 238             },
 239
 240             function heapSnapshotRetainersTest()
 241             {
 242                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 243                 var expectedRetainers = {
 244                     "": [],
 245                     "A": [""],
 246                     "B": ["", "A"],
 247                     "C": ["A", "B"],
 248                     "D": ["B"],
 249                     "E": ["C"]};
 250                 for (var nodes = snapshot._allNodes(); nodes.hasNext(); nodes.next()) {
 251                     var names = [];
 252                     for (var retainers = nodes.item().retainers(); retainers.hasNext(); retainers.next())
 253                         names.push(retainers.item().node().name());
 254                     names.sort();
 255                     InspectorTest.assertEquals(expectedRetainers[nodes.item().name()].join(","), names.join(","), "retainers of \"" + nodes.item().name() + "\"");
 256                 }
 257             },
 258
 259             function heapSnapshotAggregatesTest()
 260             {
 261                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 262                 var expectedAggregates = {
 263                     "A": { count: 1, self: 2, maxRet: 2, type: "object", name: "A" },
 264                     "B": { count: 1, self: 3, maxRet: 8, type: "object", name: "B" },
 265                     "C": { count: 1, self: 4, maxRet: 10, type: "object", name: "C" },
 266                     "D": { count: 1, self: 5, maxRet: 5, type: "object", name: "D" },
 267                     "E": { count: 1, self: 6, maxRet: 6, type: "object", name: "E" }
 268                 };
 269                 var aggregates = snapshot.aggregates(false);
 270                 for (var name in aggregates) {
 271                     var aggregate = aggregates[name];
 272                     var expectedAggregate = expectedAggregates[name];
 273                     for (var parameter in expectedAggregate)
 274                         InspectorTest.assertEquals(expectedAggregate[parameter], aggregate[parameter], "parameter " + parameter + " of \"" + name + "\"");
 275                 }
 276                 var expectedIndexes = {
 277                               // Index of corresponding node in the raw snapshot:
 278                    "A": [7],  // 14
 279                    "B": [14], // 27
 280                    "C": [21], // 40
 281                    "D": [28], // 50
 282                    "E": [35]  // 57
 283                 };
 284                 var indexes = snapshot.aggregates(true);
 285                 for (var name in aggregates) {
 286                     var aggregate = aggregates[name];
 287                     var expectedIndex = expectedIndexes[name];
 288                     InspectorTest.assertEquals(expectedIndex.join(","), aggregate.idxs.join(","), "indexes of \"" + name + "\"");
 289                 }
 290             },
 291
 292             function heapSnapshotFlagsTest()
 293             {
 294                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMockWithDOM(), new WebInspector.HeapSnapshotProgress());
 295                 var expectedCanBeQueried = {
 296                     "": false,
 297                    "A": true,
 298                    "B": true,
 299                    "C": true,
 300                    "D": true,
 301                    "E": false,
 302                    "F": false,
 303                    "G": false,
 304                    "H": false,
 305                    "M": false,
 306                    "N": false,
 307                    "Window": true
 308                 };
 309                 for (var nodes = snapshot._allNodes(); nodes.hasNext(); nodes.next()) {
 310                     var node = nodes.item();
 311                     InspectorTest.assertEquals(expectedCanBeQueried[node.name()], node.canBeQueried(), "canBeQueried of \"" + node.name() + "\"");
 312                 }
 313             },
 314
 315             function heapSnapshotNodesProviderTest()
 316             {
 317                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 318
 319                 function nodeFilter(node)
 320                 {
 321                     return node.type() === "object" && node.name() !== "B" && node.name() !== "D";
 322                 }
 323
 324                 var allNodeIndexes = [];
 325                 for (var i = 0; i < snapshot.nodes.length; i += snapshot._nodeFieldCount)
 326                     allNodeIndexes.push(i);
 327                 var provider = new WebInspector.HeapSnapshotNodesProvider(snapshot, nodeFilter, allNodeIndexes);
 328                 // Sort by names in reverse order.
 329                 provider.sortAndRewind({fieldName1: "name", ascending1: false, fieldName2: "id", ascending2: false});
 330                 var range = provider.serializeItemsRange(0, 3);
 331                 InspectorTest.assertEquals(3, range.totalLength, "Node range total length");
 332                 InspectorTest.assertEquals(0, range.startPosition, "Node range start position");
 333                 InspectorTest.assertEquals(3, range.endPosition, "Node range end position");
 334                 var names = range.items.map(function(item)
 335                 {
 336                     return item.name;
 337                 });
 338                 InspectorTest.assertEquals("E,C,A", names.join(","), "nodes provider names");
 339             },
 340
 341             function heapSnapshotEdgesProviderTest()
 342             {
 343                 var snapshot = new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress());
 344
 345                 function edgeFilter(edge)
 346                 {
 347                     return edge.name() === "b";
 348                 }
 349
 350                 var provider = snapshot.createEdgesProviderForTest(snapshot.rootNodeIndex, edgeFilter);
 351                 provider.sortAndRewind({fieldName1: "!edgeName", ascending1: false, fieldName2: "id", ascending2: false});
 352                 var range = provider.serializeItemsRange(0, 10);
 353                 InspectorTest.assertEquals(1, range.totalLength, "Edge range total length");
 354                 InspectorTest.assertEquals(0, range.startPosition, "Edge range start position");
 355                 InspectorTest.assertEquals(1, range.endPosition, "Edge range end position");
 356                 var names = range.items.map(function(item)
 357                 {
 358                     return item.name;
 359                 });
 360                 InspectorTest.assertEquals("b", names.join(","), "edges provider names");
 361             },
 362
 363             function heapSnapshotLoaderTest()
 364             {
 365                 var source = InspectorTest.createHeapSnapshotMockRaw();
 366                 var sourceStringified = JSON.stringify(source);
 367                 var partSize = sourceStringified.length >> 3;
 368
 369                 var loader = new WebInspector.HeapSnapshotLoader();
 370                 for (var i = 0, l = sourceStringified.length; i < l; i += partSize)
 371                     loader.write(sourceStringified.slice(i, i + partSize));
 372                 loader.close();
 373                 var result = loader.buildSnapshot(false);
 374                 result.nodes = new Uint32Array(result.nodes);
 375                 result.containmentEdges = new Uint32Array(result.containmentEdges);
 376                 function assertSnapshotEquals(reference, actual)
 377                 {
 378                     InspectorTest.assertEquals(JSON.stringify(reference), JSON.stringify(actual));
 379                 }
 380                 assertSnapshotEquals(new WebInspector.JSHeapSnapshot(InspectorTest.createHeapSnapshotMock(), new WebInspector.HeapSnapshotProgress(), false), result);
 381             },
 382         ];
 383
 384         var result = [];
 385         for (var i = 0; i < testSuite.length; i++) {
 386             var test = testSuite[i];
 387             result.push("");
 388             result.push("Running: " + test.name);
 389             try {
 390                 test();
 391             } catch (e) {
 392                 result.push("FAIL: " + e);
 393             }
 394         }
 395         return result.join("\n");
 396     }
 397
 398     var proxy = new WebInspector.HeapSnapshotWorkerProxy(function(eventName, arg)
 399     {
 400         InspectorTest.addResult("Unexpected event from worker: " + eventName);
 401     });
 402     var source = "(" + createTestEnvironmentInWorker + ")();" +
 403                  "(" + InspectorTest.createHeapSnapshotMockFactories + ")();" +
 404                  "(" + runTestSuiteInWorker + ")();";
 405     proxy.evaluateForTest(source, function(result)
 406     {
 407         InspectorTest.addResult(result);
 408         InspectorTest.completeTest();
 409     });
 410 }
 411
 412 </script>
 413 </head>
 414
 415 <body onload="runTest()">
 416 <p>
 417 This test checks HeapSnapshots module.
 418 </p>
 419
 420 </body>
 421 </html>